def test_project_waitingfortickets(self):
projects = {'foo': '37', 'foobar': '2', 'foobaz': '3', 'fooblabla': '5'}
par = SmartAddParser(u'omg omg @fooblabla hey ^1 #', projects=projects)
self.assertEqual([u'Ticket is missing'], par.validation_errors())
self.assertDictContainsSubset({
'description': u'omg omg hey #',
'project_id': '5',
}, par.parsed_time_entry)
def test_project_notfound(self):
"""
A project control character is used but the project is not found
"""
par = SmartAddParser(u'this is some @foo stuff #1 ^:30',
projects={'bar': '2', 'baz': '3'},
available_tickets=[1])
self.assertEqual([u'Project not found'],
par.validation_errors())
def test_hours_error(self):
"""
A time control character is used but the time could not be parsed
"""
par = SmartAddParser(u'@foo #3 this is^wrong',
projects={'foo':'foo'},
available_tickets=[3])
self.assertEqual([u'Could not parse time'],
par.validation_errors())
def test_ticket_notfound(self):
"""
A ticket tag that does not match an existing ticket
"""
par = SmartAddParser(u'@proj #47 works for me ^1:00',
projects={'proj': 'proj'},
available_tickets=[1, 2, 3, 4, 45])
self.assertEqual([u'Ticket #47 not found'],
par.validation_errors())
def test_project_ignorecase(self):
"""
A project name is found if the case is different
"""
projects = {'FOO': '37', 'bar': '2', 'baz': '3'}
par = SmartAddParser(u'this is some @Foo stuff ^1', projects=projects)
self.assertEqual([u'Ticket is missing'], par.validation_errors())
self.assertDictContainsSubset({
'description': u'this is some stuff',
'project_id': '37',
}, par.parsed_time_entry)
def test_ticket(self):
"""
A ticket tag that matches an existing ticket
"""
tickets = [1, 2, 3, 4, 45]
par = SmartAddParser(u'fixed #45 for ever ^1', available_tickets=tickets)
self.assertEqual([u'Project is missing'], par.validation_errors())
self.assertDictContainsSubset({
'description': u'fixed for ever',
'tickets': ['45'],
}, par.parsed_time_entry)
def test_project_longest(self):
"""
Matches the longest project name, if there are several matches
"""
projects = {'foo': '37', 'foobar': '2', 'foobaz': '3', 'fooblabla': '5'}
par = SmartAddParser(u'this is some @fooblabla stuff ^1',
projects=projects)
self.assertEqual([u'Ticket is missing'], par.validation_errors())
self.assertDictContainsSubset({
'description': u'this is some stuff',
'project_id': '5',
}, par.parsed_time_entry)
def test_project_first(self):
"""
Only matches the first tag
"""
projects = {'foo': '37', 'barbaz': '2'}
par = SmartAddParser(u'this is some @foo @barbaz stuff ^1',
projects=projects)
self.assertEqual([u'Ticket is missing'], par.validation_errors())
self.assertDictContainsSubset({
'description': u'this is some @barbaz stuff',
'project_id': '37',
}, par.parsed_time_entry)
def test_project_with_space(self):
"""
A project name may contain spaces (regression #85)
"""
par = SmartAddParser(u'@my project #47 works for me ^1:00',
projects={'my project': 'proj'},
available_tickets=[1, 2, 3, 4, 47])
self.assertEqual([], par.validation_errors())
self.assertDictContainsSubset({
'description': u'works for me',
'tickets': ['47'],
}, par.parsed_time_entry)
def test_project_name_space(self):
"""
The project name can contain spaces.
"""
par = SmartAddParser(u'@proj name #47 works for me ^1:00',
projects={'proj name': 'pr_id'},
available_tickets=[1, 2, 3, 4, 47])
self.assertEqual([], par.validation_errors())
self.assertDictContainsSubset({
'description': u'works for me',
'tickets': ['47'],
}, par.parsed_time_entry)
def test_project_name_uppercase(self):
"""
The match is case insensitive.
"""
par = SmartAddParser(u'@Proj_Name #47 works for me ^1:00',
projects={'Proj_Name': 'pr_id'},
available_tickets=[1, 2, 3, 4, 47])
self.assertEqual([], par.validation_errors())
self.assertDictContainsSubset({
'description': u'works for me',
'tickets': ['47'],
}, par.parsed_time_entry)
def test_ticket_callable(self):
"""
A ticket list may be provided by a callable. The project_id is then passed to the callable.
"""
def ticket_provider(project_code):
if project_code == 'one':
return [1]
if project_code == 'two':
return [2]
par = SmartAddParser(u'@one #1 ^0:20 blabla',
projects={'one': 'one'},
available_tickets=ticket_provider)
self.assertEqual([], par.validation_errors())
par = SmartAddParser(u'@two #2 ^0:20 blabla',
projects={'two': 'two'},
available_tickets=ticket_provider)
self.assertEqual([], par.validation_errors())
par = SmartAddParser(u'@one #2 ^0:20 blabla',
projects={'one': 'one'},
available_tickets=ticket_provider)
self.assertEqual([u'Ticket #2 not found'],
par.validation_errors())
par = SmartAddParser(u'@two #1 ^0:20 blabla',
projects={'two': 'two'},
available_tickets=ticket_provider)
self.assertEqual([u'Ticket #1 not found'],
par.validation_errors())
def test_ticket_notfound(self):
"""
Missing tickets raise an error even when multiple tickets are selected.
"""
par = SmartAddParser(u'@proj #3 #47 works for me ^1:00',
projects={'proj': 'proj'},
available_tickets=[1, 2, 3, 4, 45])
self.assertEqual([u'Ticket #47 not found'],
par.validation_errors())
par = SmartAddParser(u'@proj #47 #3 #2 #66 works for me ^1:00',
projects={'proj': 'proj'},
available_tickets=[1, 2, 3, 4, 45])
self.assertEqual([u'Tickets #47, #66 not found'],
par.validation_errors())
def test_dates(self):
"""
A project tag that matches an existing project
"""
projects = {'foo': '37', 'bar': '2', 'baz': '3'}
par = SmartAddParser(u'!today this is some @foo stuff', projects=projects)
self.assertEquals(par.unparsed, u'this is some stuff')
self.assertEquals(par.date, datetime.date.today())
par = SmartAddParser(u'this is !yesterday some @foo stuff', projects=projects)
self.assertEquals(par.unparsed, u'this is some stuff')
self.assertEquals(par.date, datetime.date.today() - datetime.timedelta(days=1))
par = SmartAddParser(u'this is !foobar some @foo stuff #3 ^2:30',
projects=projects,
available_tickets=[3])
self.assertEquals(par.unparsed, u'this is !foobar some stuff')
self.assertEqual([u'Cannot parse date'],
par.validation_errors())
def test_complete(self):
"""
Checks that all the required tags are present, and description is there
"""
par = SmartAddParser(u'')
self.assertEqual([u'Project is missing', u'Time is missing', u'Ticket is missing', u'Description is empty'],
par.validation_errors())
par = SmartAddParser(u'bla bla bla')
self.assertEqual([u'Project is missing', u'Time is missing', u'Ticket is missing'],
par.validation_errors())
par = SmartAddParser(u'bla bla bla @ppp', projects={'ppp': 1})
self.assertEqual([u'Time is missing', u'Ticket is missing'],
par.validation_errors())
par = SmartAddParser(u'bla bla bla @ppp #2', projects={'ppp': 1}, available_tickets=[2])
self.assertEqual([u'Time is missing'],
par.validation_errors())
