]> git.madduck.net Git - etc/taskwarrior.git/blobdiff - tasklib/tests.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

tests: Add tests for starting active task
[etc/taskwarrior.git] / tasklib / tests.py
index bc2885a1867175defe7c356201d5f6423ce734fe..adcb3c855f302596a02948d604aba9820e245c12 100644 (file)
@@ -7,6 +7,7 @@ import json
 import pytz
 import six
 import shutil
+import sys
 import tempfile
 import unittest
 
@@ -36,11 +37,14 @@ TASK_STANDARD_ATTRS = (
     'annotations',
 )
 
+total_seconds_2_6 = lambda x: x.microseconds / 1e6 + x.seconds + x.days * 24 * 3600
+
+
 class TasklibTest(unittest.TestCase):
 
     def setUp(self):
         self.tmp = tempfile.mkdtemp(dir='.')
-        self.tw = TaskWarrior(data_location=self.tmp)
+        self.tw = TaskWarrior(data_location=self.tmp, taskrc_location='/')
 
     def tearDown(self):
         shutil.rmtree(self.tmp)
@@ -129,6 +133,110 @@ class TaskFilterTest(TasklibTest):
     def test_filter_with_empty_uuid(self):
         self.assertRaises(ValueError, lambda: self.tw.tasks.get(uuid=''))
 
+    def test_filter_dummy_by_status(self):
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(status=t['status'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_uuid(self):
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(uuid=t['uuid'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_entry(self):
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(entry=t['entry'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_description(self):
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(description=t['description'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_start(self):
+        t = Task(self.tw, description="test")
+        t.save()
+        t.start()
+
+        tasks = self.tw.tasks.filter(start=t['start'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_end(self):
+        t = Task(self.tw, description="test")
+        t.save()
+        t.done()
+
+        tasks = self.tw.tasks.filter(end=t['end'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_due(self):
+        t = Task(self.tw, description="test", due=datetime.datetime.now())
+        t.save()
+
+        tasks = self.tw.tasks.filter(due=t['due'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_until(self):
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(until=t['until'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_modified(self):
+        # Older TW version does not support bumping modified
+        # on save
+        if self.tw.version < six.text_type('2.2.0'):
+            # Python2.6 does not support SkipTest. As a workaround
+            # mark the test as passed by exiting.
+            if getattr(unittest, 'SkipTest', None) is not None:
+                raise unittest.SkipTest()
+            else:
+                return
+
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(modified=t['modified'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_scheduled(self):
+        t = Task(self.tw, description="test")
+        t.save()
+
+        tasks = self.tw.tasks.filter(scheduled=t['scheduled'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_tags(self):
+        t = Task(self.tw, description="test", tags=["home"])
+        t.save()
+
+        tasks = self.tw.tasks.filter(tags=t['tags'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_dummy_by_projects(self):
+        t = Task(self.tw, description="test", project="random")
+        t.save()
+
+        tasks = self.tw.tasks.filter(project=t['project'])
+        self.assertEqual(list(tasks), [t])
+
+    def test_filter_by_priority(self):
+        t = Task(self.tw, description="test", priority="H")
+        t.save()
+
+        tasks = self.tw.tasks.filter(priority=t['priority'])
+        self.assertEqual(list(tasks), [t])
+
+
 class TaskTest(TasklibTest):
 
     def test_create_unsaved_task(self):
@@ -151,6 +259,10 @@ class TaskTest(TasklibTest):
         t = Task(self.tw, description="test task")
         self.assertRaises(Task.NotSaved, t.refresh)
 
+    def test_start_unsaved_task(self):
+        t = Task(self.tw, description="test task")
+        self.assertRaises(Task.NotSaved, t.start)
+
     def test_delete_deleted_task(self):
         t = Task(self.tw, description="test task")
         t.save()
@@ -165,6 +277,13 @@ class TaskTest(TasklibTest):
 
         self.assertRaises(Task.CompletedTask, t.done)
 
+    def test_start_completed_task(self):
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.done()
+
+        self.assertRaises(Task.CompletedTask, t.start)
+
     def test_complete_deleted_task(self):
         t = Task(self.tw, description="test task")
         t.save()
@@ -172,6 +291,96 @@ class TaskTest(TasklibTest):
 
         self.assertRaises(Task.DeletedTask, t.done)
 
+    def test_starting_task(self):
+        t = Task(self.tw, description="test task")
+        now = t.datetime_normalizer(datetime.datetime.now())
+        t.save()
+        t.start()
+
+        self.assertTrue(now.replace(microsecond=0) <= t['start'])
+        self.assertEqual(t['status'], 'pending')
+
+    def test_completing_task(self):
+        t = Task(self.tw, description="test task")
+        now = t.datetime_normalizer(datetime.datetime.now())
+        t.save()
+        t.done()
+
+        self.assertTrue(now.replace(microsecond=0) <= t['end'])
+        self.assertEqual(t['status'], 'completed')
+
+    def test_deleting_task(self):
+        t = Task(self.tw, description="test task")
+        now = t.datetime_normalizer(datetime.datetime.now())
+        t.save()
+        t.delete()
+
+        self.assertTrue(now.replace(microsecond=0) <= t['end'])
+        self.assertEqual(t['status'], 'deleted')
+
+    def test_started_task_active(self):
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.start()
+        self.assertTrue(t.active)
+
+    def test_unstarted_task_inactive(self):
+        t = Task(self.tw, description="test task")
+        self.assertFalse(t.active)
+        t.save()
+        self.assertFalse(t.active)
+
+    def test_start_active_task(self):
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.start()
+        self.assertRaises(Task.ActiveTask, t.start)
+
+    def test_stop_completed_task(self):
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.start()
+        t.done()
+
+        self.assertRaises(Task.InactiveTask, t.stop)
+
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.done()
+
+        self.assertRaises(Task.InactiveTask, t.stop)
+
+    def test_stop_deleted_task(self):
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.start()
+        t.delete()
+        t.stop()
+
+    def test_stop_inactive_task(self):
+        t = Task(self.tw, description="test task")
+        t.save()
+
+        self.assertRaises(Task.InactiveTask, t.stop)
+
+        t = Task(self.tw, description="test task")
+        t.save()
+        t.start()
+        t.stop()
+
+        self.assertRaises(Task.InactiveTask, t.stop)
+
+    def test_stopping_task(self):
+        t = Task(self.tw, description="test task")
+        now = t.datetime_normalizer(datetime.datetime.now())
+        t.save()
+        t.start()
+        t.stop()
+
+        self.assertEqual(t['end'], None)
+        self.assertEqual(t['status'], 'pending')
+        self.assertFalse(t.active)
+
     def test_modify_simple_attribute_without_space(self):
         t = Task(self.tw, description="test")
         t.save()
@@ -502,15 +711,8 @@ class TaskTest(TasklibTest):
         # Test that any normalizer can handle None as a valid value
         t = Task(self.tw)
 
-        # These normalizers are not supposed to handle None
-        exempt_normalizers = ('normalize_uuid', )
-
-        normalizers = [getattr(t, normalizer_name) for normalizer_name in
-                       filter(lambda x: x.startswith('normalize_'), dir(t))
-                       if normalizer_name not in exempt_normalizers]
-
-        for normalizer in normalizers:
-            normalizer(None)
+        for key in TASK_STANDARD_ATTRS:
+            t._normalize(key, None)
 
     def test_recurrent_task_generation(self):
         today = datetime.date.today()
@@ -519,12 +721,31 @@ class TaskTest(TasklibTest):
         t.save()
         self.assertEqual(len(self.tw.tasks.pending()), 2)
 
+    def test_modify_number_of_tasks_at_once(self):
+        for i in range(1, 100):
+            Task(self.tw, description="test task %d" % i, tags=['test']).save()
+
+        self.tw.execute_command(['+test', 'mod', 'unified', 'description'])
+
+    def test_return_all_from_executed_command(self):
+        Task(self.tw, description="test task", tags=['test']).save()
+        out, err, rc = self.tw.execute_command(['count'], return_all=True)
+        self.assertEqual(rc, 0)
+
+    def test_return_all_from_failed_executed_command(self):
+        Task(self.tw, description="test task", tags=['test']).save()
+        out, err, rc = self.tw.execute_command(['countinvalid'],
+            return_all=True, allow_failure=False)
+        self.assertNotEqual(rc, 0)
+
+
 class TaskFromHookTest(TasklibTest):
 
     input_add_data = six.StringIO(
         '{"description":"Buy some milk",'
         '"entry":"20141118T050231Z",'
         '"status":"pending",'
+        '"start":"20141119T152233Z",'
         '"uuid":"a360fc44-315c-4366-b70c-ea7e7520b749"}')
 
     input_modify_data = six.StringIO(input_add_data.getvalue() + '\n' +
@@ -539,12 +760,13 @@ class TaskFromHookTest(TasklibTest):
          '"description":"test task"}')
 
     def test_setting_up_from_add_hook_input(self):
-        t = Task.from_input(input_file=self.input_add_data)
+        t = Task.from_input(input_file=self.input_add_data, warrior=self.tw)
         self.assertEqual(t['description'], "Buy some milk")
         self.assertEqual(t.pending, True)
 
     def test_setting_up_from_modified_hook_input(self):
-        t = Task.from_input(input_file=self.input_modify_data, modify=True)
+        t = Task.from_input(input_file=self.input_modify_data, modify=True,
+                            warrior=self.tw)
         self.assertEqual(t['description'], "Buy some milk finally")
         self.assertEqual(t.pending, False)
         self.assertEqual(t.completed, True)
@@ -552,7 +774,7 @@ class TaskFromHookTest(TasklibTest):
         self.assertEqual(t._original_data['status'], "pending")
         self.assertEqual(t._original_data['description'], "Buy some milk")
         self.assertEqual(set(t._modified_fields),
-                         set(['status', 'description']))
+                         set(['status', 'description', 'start']))
 
     def test_export_data(self):
         t = Task(self.tw, description="test task",
@@ -597,7 +819,7 @@ class TimezoneAwareDatetimeTest(TasklibTest):
 
     def test_serialize_naive_datetime(self):
         t = Task(self.tw, description="task1", due=self.localtime_naive)
-        self.assertEqual(json.loads(t.export_data())['due'], 
+        self.assertEqual(json.loads(t.export_data())['due'],
                          self.utctime_aware.strftime(DATE_FORMAT))
 
     def test_timezone_naive_date_setitem(self):
@@ -617,7 +839,7 @@ class TimezoneAwareDatetimeTest(TasklibTest):
 
     def test_serialize_naive_date(self):
         t = Task(self.tw, description="task1", due=self.localdate_naive)
-        self.assertEqual(json.loads(t.export_data())['due'], 
+        self.assertEqual(json.loads(t.export_data())['due'],
                          self.utctime_aware.strftime(DATE_FORMAT))
 
     def test_timezone_aware_datetime_setitem(self):
@@ -637,9 +859,87 @@ class TimezoneAwareDatetimeTest(TasklibTest):
 
     def test_serialize_aware_datetime(self):
         t = Task(self.tw, description="task1", due=self.localtime_aware)
-        self.assertEqual(json.loads(t.export_data())['due'], 
+        self.assertEqual(json.loads(t.export_data())['due'],
                          self.utctime_aware.strftime(DATE_FORMAT))
 
+class DatetimeStringTest(TasklibTest):
+
+    def test_simple_now_conversion(self):
+        if self.tw.version < six.text_type('2.4.0'):
+            # Python2.6 does not support SkipTest. As a workaround
+            # mark the test as passed by exiting.
+            if getattr(unittest, 'SkipTest', None) is not None:
+                raise unittest.SkipTest()
+            else:
+                return
+
+        t = Task(self.tw, description="test task", due="now")
+        now = local_zone.localize(datetime.datetime.now())
+
+        # Assert that both times are not more than 5 seconds apart
+        if sys.version_info < (2,7):
+            self.assertTrue(total_seconds_2_6(now - t['due']) < 5)
+            self.assertTrue(total_seconds_2_6(t['due'] - now) < 5)
+        else:
+            self.assertTrue((now - t['due']).total_seconds() < 5)
+            self.assertTrue((t['due'] - now).total_seconds() < 5)
+
+    def test_simple_eoy_conversion(self):
+        if self.tw.version < six.text_type('2.4.0'):
+            # Python2.6 does not support SkipTest. As a workaround
+            # mark the test as passed by exiting.
+            if getattr(unittest, 'SkipTest', None) is not None:
+                raise unittest.SkipTest()
+            else:
+                return
+
+        t = Task(self.tw, description="test task", due="eoy")
+        now = local_zone.localize(datetime.datetime.now())
+        eoy = local_zone.localize(datetime.datetime(
+            year=now.year,
+            month=12,
+            day=31,
+            hour=23,
+            minute=59,
+            second=59
+            ))
+        self.assertEqual(eoy, t['due'])
+
+    def test_complex_eoy_conversion(self):
+        if self.tw.version < six.text_type('2.4.0'):
+            # Python2.6 does not support SkipTest. As a workaround
+            # mark the test as passed by exiting.
+            if getattr(unittest, 'SkipTest', None) is not None:
+                raise unittest.SkipTest()
+            else:
+                return
+
+        t = Task(self.tw, description="test task", due="eoy - 4 months")
+        now = local_zone.localize(datetime.datetime.now())
+        due_date = local_zone.localize(datetime.datetime(
+            year=now.year,
+            month=12,
+            day=31,
+            hour=23,
+            minute=59,
+            second=59
+            )) - datetime.timedelta(0,4 * 30 * 86400)
+        self.assertEqual(due_date, t['due'])
+
+    def test_filtering_with_string_datetime(self):
+        if self.tw.version < six.text_type('2.4.0'):
+            # Python2.6 does not support SkipTest. As a workaround
+            # mark the test as passed by exiting.
+            if getattr(unittest, 'SkipTest', None) is not None:
+                raise unittest.SkipTest()
+            else:
+                return
+
+        t = Task(self.tw, description="test task",
+                 due=datetime.datetime.now() - datetime.timedelta(0,2))
+        t.save()
+        self.assertEqual(len(self.tw.tasks.filter(due__before="now")), 1)
+
 class AnnotationTest(TasklibTest):
 
     def setUp(self):
@@ -702,9 +1002,14 @@ class AnnotationTest(TasklibTest):
 class UnicodeTest(TasklibTest):
 
     def test_unicode_task(self):
-        Task(self.tw, description="†åßk").save()
+        Task(self.tw, description=six.u("†åßk")).save()
         self.tw.tasks.get()
 
+    def test_filter_by_unicode_task(self):
+        Task(self.tw, description=six.u("†åßk")).save()
+        tasks = self.tw.tasks.filter(description=six.u("†åßk"))
+        self.assertEqual(len(tasks), 1)
+
     def test_non_unicode_task(self):
         Task(self.tw, description="test task").save()
         self.tw.tasks.get()