tests: Replace key with different config keys that are more consistent across versions

[etc/taskwarrior.git] / tasklib / tests.py

diff --git a/tasklib/tests.py b/tasklib/tests.py
index 7611536c5cc1734ee4475194141e4e1f7217ea2f..3e60ac013376fc571c0c8d2f66db613f5c948ed9 100644 (file)
--- a/tasklib/tests.py
+++ b/tasklib/tests.py
@@ -12,8 +12,8 @@ import tempfile
 import unittest
 
 from .backends import TaskWarrior
 import unittest
 
 from .backends import TaskWarrior

-from .task import (Task, ReadOnlyDictView, LazyUUIDTask,
-                   LazyUUIDTaskSet, TaskQuerySet)
+from .task import Task, ReadOnlyDictView, TaskQuerySet
+from .lazy import LazyUUIDTask, LazyUUIDTaskSet

 from .serializing import DATE_FORMAT, local_zone
 
 # http://taskwarrior.org/docs/design/task.html , Section: The Attributes
 from .serializing import DATE_FORMAT, local_zone
 
 # http://taskwarrior.org/docs/design/task.html , Section: The Attributes


@@ -81,6 +81,39 @@ class TaskFilterTest(TasklibTest):
         self.tw.tasks.all()[0].done()
         self.assertEqual(len(self.tw.tasks.completed()), 1)
 
         self.tw.tasks.all()[0].done()
         self.assertEqual(len(self.tw.tasks.completed()), 1)
 

+    def test_deleted_empty(self):
+        Task(self.tw, description="test task").save()
+        self.assertEqual(len(self.tw.tasks.deleted()), 0)
+
+    def test_deleted_non_empty(self):
+        Task(self.tw, description="test task").save()
+        self.assertEqual(len(self.tw.tasks.deleted()), 0)
+        self.tw.tasks.all()[0].delete()
+        self.assertEqual(len(self.tw.tasks.deleted()), 1)
+
+    def test_waiting_empty(self):
+        Task(self.tw, description="test task").save()
+        self.assertEqual(len(self.tw.tasks.waiting()), 0)
+
+    def test_waiting_non_empty(self):
+        Task(self.tw, description="test task").save()
+        self.assertEqual(len(self.tw.tasks.waiting()), 0)
+
+        t = self.tw.tasks.all()[0]
+        t['wait'] = datetime.datetime.now() + datetime.timedelta(days=1)
+        t.save()
+
+        self.assertEqual(len(self.tw.tasks.waiting()), 1)
+
+    def test_recurring_empty(self):
+        Task(self.tw, description="test task").save()
+        self.assertEqual(len(self.tw.tasks.recurring()), 0)
+
+    def test_recurring_non_empty(self):
+        Task(self.tw, description="test task", recur="daily",
+             due=datetime.datetime.now()).save()
+        self.assertEqual(len(self.tw.tasks.recurring()), 1)
+

     def test_filtering_by_attribute(self):
         Task(self.tw, description="no priority task").save()
         Task(self.tw, priority="H", description="high priority task").save()
     def test_filtering_by_attribute(self):
         Task(self.tw, description="no priority task").save()
         Task(self.tw, priority="H", description="high priority task").save()


@@ -581,6 +614,23 @@ class TaskTest(TasklibTest):
         t2 = self.tw.tasks.get(uuid=t1['uuid'])
         self.assertEqual(t1.__hash__(), t2.__hash__())
 
         t2 = self.tw.tasks.get(uuid=t1['uuid'])
         self.assertEqual(t1.__hash__(), t2.__hash__())
 

+    def test_hash_unequal_unsaved_tasks(self):
+        # Compare the hash of the task using two different objects
+        t1 = Task(self.tw, description="test task 1")
+        t2 = Task(self.tw, description="test task 2")
+
+        self.assertNotEqual(t1.__hash__(), t2.__hash__())
+
+    def test_hash_unequal_saved_tasks(self):
+        # Compare the hash of the task using two different objects
+        t1 = Task(self.tw, description="test task 1")
+        t2 = Task(self.tw, description="test task 2")
+
+        t1.save()
+        t2.save()
+
+        self.assertNotEqual(t1.__hash__(), t2.__hash__())
+

     def test_adding_task_with_priority(self):
         t = Task(self.tw, description="test task", priority="M")
         t.save()
     def test_adding_task_with_priority(self):
         t = Task(self.tw, description="test task", priority="M")
         t.save()


@@ -696,16 +746,24 @@ class TaskTest(TasklibTest):
     def test_adding_tag_by_appending(self):
         t = Task(self.tw, description="test task", tags=['test1'])
         t.save()
     def test_adding_tag_by_appending(self):
         t = Task(self.tw, description="test task", tags=['test1'])
         t.save()

-        t['tags'].append('test2')
+        t['tags'].add('test2')
+        t.save()
+        self.assertEqual(t['tags'], set(['test1', 'test2']))
+
+    def test_adding_tag_twice(self):
+        t = Task(self.tw, description="test task", tags=['test1'])
+        t.save()
+        t['tags'].add('test2')
+        t['tags'].add('test2')

         t.save()
         t.save()

-        self.assertEqual(t['tags'], ['test1', 'test2'])
+        self.assertEqual(t['tags'], set(['test1', 'test2']))

 
     def test_adding_tag_by_appending_empty(self):
         t = Task(self.tw, description="test task")
         t.save()
 
     def test_adding_tag_by_appending_empty(self):
         t = Task(self.tw, description="test task")
         t.save()

-        t['tags'].append('test')
+        t['tags'].add('test')

         t.save()
         t.save()

-        self.assertEqual(t['tags'], ['test'])
+        self.assertEqual(t['tags'], set(['test']))

 
     def test_serializers_returning_empty_string_for_none(self):
         # Test that any serializer returns '' when passed None
 
     def test_serializers_returning_empty_string_for_none(self):
         # Test that any serializer returns '' when passed None


@@ -737,6 +795,15 @@ class TaskTest(TasklibTest):
         t.save()
         self.assertEqual(len(self.tw.tasks.pending()), 2)
 
         t.save()
         self.assertEqual(len(self.tw.tasks.pending()), 2)
 

+    def test_spawned_task_parent(self):
+        today = datetime.date.today()
+        t = Task(self.tw, description="brush teeth",
+                 due=today, recur="daily")
+        t.save()
+
+        spawned = self.tw.tasks.pending().get(due=today)
+        assert spawned['parent'] == t
+

     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()
     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()


@@ -764,6 +831,14 @@ class TaskFromHookTest(TasklibTest):
         '"start":"20141119T152233Z",'
         '"uuid":"a360fc44-315c-4366-b70c-ea7e7520b749"}')
 
         '"start":"20141119T152233Z",'
         '"uuid":"a360fc44-315c-4366-b70c-ea7e7520b749"}')
 

+    input_add_data_recurring = six.StringIO(
+        '{"description":"Mow the lawn",'
+        '"entry":"20160210T224304Z",'
+        '"parent":"62da6227-519c-42c2-915d-dccada926ad7",'
+        '"recur":"weekly",'
+        '"status":"pending",'
+        '"uuid":"81305335-0237-49ff-8e87-b3cdc2369cec"}')
+

     input_modify_data = six.StringIO(input_add_data.getvalue() + '\n' +
         '{"description":"Buy some milk finally",'
         '"entry":"20141118T050231Z",'
     input_modify_data = six.StringIO(input_add_data.getvalue() + '\n' +
         '{"description":"Buy some milk finally",'
         '"entry":"20141118T050231Z",'


@@ -780,6 +855,12 @@ class TaskFromHookTest(TasklibTest):
         self.assertEqual(t['description'], "Buy some milk")
         self.assertEqual(t.pending, True)
 
         self.assertEqual(t['description'], "Buy some milk")
         self.assertEqual(t.pending, True)
 

+    def test_setting_up_from_add_hook_input_recurring(self):
+        t = Task.from_input(input_file=self.input_add_data_recurring,
+                            backend=self.tw)
+        self.assertEqual(t['description'], "Mow the lawn")
+        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,
                             backend=self.tw)
     def test_setting_up_from_modified_hook_input(self):
         t = Task.from_input(input_file=self.input_modify_data, modify=True,
                             backend=self.tw)


@@ -1118,12 +1199,23 @@ class LazyUUIDTaskTest(TasklibTest):
         assert self.stored['uuid'] == self.lazy['uuid']
         assert type(self.lazy) is LazyUUIDTask
 
         assert self.stored['uuid'] == self.lazy['uuid']
         assert type(self.lazy) is LazyUUIDTask
 

-    def test_conversion(self):
+    def test_lazy_explicit_conversion(self):
+        assert type(self.lazy) is LazyUUIDTask
+        self.lazy.replace()
+        assert type(self.lazy) is Task
+
+    def test_conversion_key(self):

         assert self.stored['description'] == self.lazy['description']
         assert type(self.lazy) is Task
 
         assert self.stored['description'] == self.lazy['description']
         assert type(self.lazy) is Task
 

+    def test_conversion_attribute(self):
+        assert type(self.lazy) is LazyUUIDTask
+        assert self.lazy.completed is False
+        assert type(self.lazy) is Task
+

     def test_normal_to_lazy_equality(self):
         assert self.stored == self.lazy
     def test_normal_to_lazy_equality(self):
         assert self.stored == self.lazy

+        assert not self.stored != self.lazy

         assert type(self.lazy) is LazyUUIDTask
 
     def test_lazy_to_lazy_equality(self):
         assert type(self.lazy) is LazyUUIDTask
 
     def test_lazy_to_lazy_equality(self):


@@ -1131,20 +1223,54 @@ class LazyUUIDTaskTest(TasklibTest):
         lazy2 = LazyUUIDTask(self.tw, self.stored['uuid'])
 
         assert lazy1 == lazy2
         lazy2 = LazyUUIDTask(self.tw, self.stored['uuid'])
 
         assert lazy1 == lazy2

+        assert not lazy1 != lazy2
+        assert type(lazy1) is LazyUUIDTask
+        assert type(lazy2) is LazyUUIDTask
+
+    def test_normal_to_lazy_inequality(self):
+        # Create a different UUID by changing the last letter
+        wrong_uuid = self.stored['uuid']
+        wrong_uuid = wrong_uuid[:-1] + ('a' if wrong_uuid[-1] != 'a' else 'b')
+
+        wrong_lazy = LazyUUIDTask(self.tw, wrong_uuid)
+
+        assert not self.stored == wrong_lazy
+        assert self.stored != wrong_lazy
+        assert type(wrong_lazy) is LazyUUIDTask
+
+    def test_lazy_to_lazy_inequality(self):
+        # Create a different UUID by changing the last letter
+        wrong_uuid = self.stored['uuid']
+        wrong_uuid = wrong_uuid[:-1] + ('a' if wrong_uuid[-1] != 'a' else 'b')
+
+        lazy1 = LazyUUIDTask(self.tw, self.stored['uuid'])
+        lazy2 = LazyUUIDTask(self.tw, wrong_uuid)
+
+        assert not lazy1 == lazy2
+        assert lazy1 != lazy2

         assert type(lazy1) is LazyUUIDTask
         assert type(lazy2) is LazyUUIDTask
 
     def test_lazy_in_queryset(self):
         assert type(lazy1) is LazyUUIDTask
         assert type(lazy2) is LazyUUIDTask
 
     def test_lazy_in_queryset(self):

-        tasks = self.tw.tasks.tasks.filter(uuid=self.stored['uuid'])
+        tasks = self.tw.tasks.filter(uuid=self.stored['uuid'])

 
         assert self.lazy in tasks
         assert type(self.lazy) is LazyUUIDTask
 
 
         assert self.lazy in tasks
         assert type(self.lazy) is LazyUUIDTask
 

+    def test_lazy_saved(self):
+        assert self.lazy.saved is True
+
+    def test_lazy_modified(self):
+        assert self.lazy.modified is False
+
+    def test_lazy_modified_fields(self):
+        assert self.lazy._modified_fields == set()
+

 
 class LazyUUIDTaskSetTest(TasklibTest):
 
     def setUp(self):
 
 class LazyUUIDTaskSetTest(TasklibTest):
 
     def setUp(self):

-        super(LazyUUIDTaskTest, self).setUp()
+        super(LazyUUIDTaskSetTest, self).setUp()

 
         self.task1 = Task(self.tw, description="task 1")
         self.task2 = Task(self.tw, description="task 2")
 
         self.task1 = Task(self.tw, description="task 1")
         self.task2 = Task(self.tw, description="task 2")


@@ -1172,10 +1298,83 @@ class LazyUUIDTaskSetTest(TasklibTest):
         assert self.task3 in self.lazy
         assert type(self.lazy) is LazyUUIDTaskSet
 
         assert self.task3 in self.lazy
         assert type(self.lazy) is LazyUUIDTaskSet
 

-    def test_eq(self):
+    def test_eq_lazy(self):
+        new_lazy = LazyUUIDTaskSet(self.tw, self.uuids)
+        assert self.lazy == new_lazy
+        assert not self.lazy != new_lazy
+        assert type(self.lazy) is LazyUUIDTaskSet
+
+    def test_eq_real(self):

         assert self.lazy == self.tw.tasks.all()
         assert self.lazy == self.tw.tasks.all()

+        assert self.tw.tasks.all() == self.lazy
+        assert not self.lazy != self.tw.tasks.all()
+

         assert type(self.lazy) is LazyUUIDTaskSet
 
         assert type(self.lazy) is LazyUUIDTaskSet
 

-    def test_conversion(self):
-        assert set(self.lazy) == set(self.tw.tasks.all())
-        assert type(self.lazy) is TaskQuerySet
+    def test_union(self):
+        taskset = set([self.task1])
+        lazyset = LazyUUIDTaskSet(
+            self.tw,
+            (self.task2['uuid'], self.task3['uuid'])
+        )
+
+        assert taskset | lazyset == self.lazy
+        assert lazyset | taskset == self.lazy
+        assert taskset.union(lazyset) == self.lazy
+        assert lazyset.union(taskset) == self.lazy
+
+        lazyset |= taskset
+        assert lazyset == self.lazy
+
+    def test_difference(self):
+        taskset = set([self.task1, self.task2])
+        lazyset = LazyUUIDTaskSet(
+            self.tw,
+            (self.task2['uuid'], self.task3['uuid'])
+        )
+
+        assert taskset - lazyset == set([self.task1])
+        assert lazyset - taskset == set([self.task3])
+        assert taskset.difference(lazyset) == set([self.task1])
+        assert lazyset.difference(taskset) == set([self.task3])
+
+        lazyset -= taskset
+        assert lazyset == set([self.task3])
+
+    def test_symmetric_difference(self):
+        taskset = set([self.task1, self.task2])
+        lazyset = LazyUUIDTaskSet(
+            self.tw,
+            (self.task2['uuid'], self.task3['uuid'])
+        )
+
+        assert taskset ^ lazyset == set([self.task1, self.task3])
+        assert lazyset ^ taskset == set([self.task1, self.task3])
+        assert taskset.symmetric_difference(lazyset) == set([self.task1, self.task3])
+        assert lazyset.symmetric_difference(taskset) == set([self.task1, self.task3])
+
+        lazyset ^= taskset
+        assert lazyset == set([self.task1, self.task3])
+
+    def test_intersection(self):
+        taskset = set([self.task1, self.task2])
+        lazyset = LazyUUIDTaskSet(
+            self.tw,
+            (self.task2['uuid'], self.task3['uuid'])
+        )
+
+        assert taskset & lazyset == set([self.task2])
+        assert lazyset & taskset == set([self.task2])
+        assert taskset.intersection(lazyset) == set([self.task2])
+        assert lazyset.intersection(taskset) == set([self.task2])
+
+        lazyset &= taskset
+        assert lazyset == set([self.task2])
+
+
+class TaskWarriorBackendTest(TasklibTest):
+
+    def test_config(self):
+        assert self.tw.config['nag'] == "You have more urgent tasks."
+        assert self.tw.config['default.command'] == "next"
+        assert self.tw.config['dependency.indicator'] == "D"