X-Git-Url: https://git.madduck.net/etc/taskwarrior.git/blobdiff_plain/23116bed0b21d2e72a304fa9f653474c3679a1a8..070cab532ba353df0ac28a2a16659bde54e83d6d:/tasklib/tests.py diff --git a/tasklib/tests.py b/tasklib/tests.py index adcb3c8..53bc625 100644 --- a/tasklib/tests.py +++ b/tasklib/tests.py @@ -11,7 +11,10 @@ import sys import tempfile import unittest -from .task import TaskWarrior, Task, ReadOnlyDictView, local_zone, DATE_FORMAT +from .backends import TaskWarrior +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 TASK_STANDARD_ATTRS = ( @@ -284,6 +287,19 @@ class TaskTest(TasklibTest): self.assertRaises(Task.CompletedTask, t.start) + def test_add_completed_task(self): + t = Task(self.tw, description="test", status="completed", + end=datetime.datetime.now()) + t.save() + + def test_add_multiple_completed_tasks(self): + t1 = Task(self.tw, description="test1", status="completed", + end=datetime.datetime.now()) + t2 = Task(self.tw, description="test2", status="completed", + end=datetime.datetime.now()) + t1.save() + t2.save() + def test_complete_deleted_task(self): t = Task(self.tw, description="test task") t.save() @@ -760,13 +776,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, warrior=self.tw) + t = Task.from_input(input_file=self.input_add_data, backend=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, - warrior=self.tw) + backend=self.tw) self.assertEqual(t['description'], "Buy some milk finally") self.assertEqual(t.pending, False) self.assertEqual(t.completed, True) @@ -1086,3 +1102,164 @@ class ReadOnlyDictViewTest(unittest.TestCase): view_list_item.append(4) self.assertNotEqual(view_values, sample_values) self.assertEqual(self.sample, self.original_sample) + + +class LazyUUIDTaskTest(TasklibTest): + + def setUp(self): + super(LazyUUIDTaskTest, self).setUp() + + self.stored = Task(self.tw, description="this is test task") + self.stored.save() + + self.lazy = LazyUUIDTask(self.tw, self.stored['uuid']) + + def test_uuid_non_conversion(self): + assert self.stored['uuid'] == self.lazy['uuid'] + assert type(self.lazy) is LazyUUIDTask + + 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 + + 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 + assert type(self.lazy) is LazyUUIDTask + + def test_lazy_to_lazy_equality(self): + lazy1 = LazyUUIDTask(self.tw, self.stored['uuid']) + lazy2 = LazyUUIDTask(self.tw, self.stored['uuid']) + + assert lazy1 == lazy2 + assert type(lazy1) is LazyUUIDTask + assert type(lazy2) is LazyUUIDTask + + def test_lazy_in_queryset(self): + tasks = self.tw.tasks.filter(uuid=self.stored['uuid']) + + 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): + super(LazyUUIDTaskSetTest, self).setUp() + + self.task1 = Task(self.tw, description="task 1") + self.task2 = Task(self.tw, description="task 2") + self.task3 = Task(self.tw, description="task 3") + + self.task1.save() + self.task2.save() + self.task3.save() + + self.uuids = ( + self.task1['uuid'], + self.task2['uuid'], + self.task3['uuid'] + ) + + self.lazy = LazyUUIDTaskSet(self.tw, self.uuids) + + def test_length(self): + assert len(self.lazy) == 3 + assert type(self.lazy) is LazyUUIDTaskSet + + def test_contains(self): + assert self.task1 in self.lazy + assert self.task2 in self.lazy + assert self.task3 in self.lazy + assert type(self.lazy) is LazyUUIDTaskSet + + 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.tw.tasks.all() == self.lazy + assert not self.lazy != self.tw.tasks.all() + + assert type(self.lazy) is LazyUUIDTaskSet + + 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])