tasklib/tests.py

   1 # coding=utf-8
   2
   3 import datetime
   4 import shutil
   5 import tempfile
   6 import unittest
   7
   8 from .task import TaskWarrior, Task
   9
  10
  11 class TasklibTest(unittest.TestCase):
  12
  13     def setUp(self):
  14         self.tmp = tempfile.mkdtemp(dir='.')
  15         self.tw = TaskWarrior(data_location=self.tmp)
  16
  17     def tearDown(self):
  18         shutil.rmtree(self.tmp)
  19
  20
  21 class TaskFilterTest(TasklibTest):
  22
  23     def test_all_empty(self):
  24         self.assertEqual(len(self.tw.tasks.all()), 0)
  25
  26     def test_all_non_empty(self):
  27         Task(self.tw, description="test task").save()
  28         self.assertEqual(len(self.tw.tasks.all()), 1)
  29         self.assertEqual(self.tw.tasks.all()[0]['description'], 'test task')
  30         self.assertEqual(self.tw.tasks.all()[0]['status'], 'pending')
  31
  32     def test_pending_non_empty(self):
  33         Task(self.tw, description="test task").save()
  34         self.assertEqual(len(self.tw.tasks.pending()), 1)
  35         self.assertEqual(self.tw.tasks.pending()[0]['description'],
  36                          'test task')
  37         self.assertEqual(self.tw.tasks.pending()[0]['status'], 'pending')
  38
  39     def test_completed_empty(self):
  40         Task(self.tw, description="test task").save()
  41         self.assertEqual(len(self.tw.tasks.completed()), 0)
  42
  43     def test_completed_non_empty(self):
  44         Task(self.tw, description="test task").save()
  45         self.assertEqual(len(self.tw.tasks.completed()), 0)
  46         self.tw.tasks.all()[0].done()
  47         self.assertEqual(len(self.tw.tasks.completed()), 1)
  48
  49     def test_filtering_by_attribute(self):
  50         Task(self.tw, description="no priority task").save()
  51         Task(self.tw, priority="H", description="high priority task").save()
  52         self.assertEqual(len(self.tw.tasks.all()), 2)
  53
  54         # Assert that the correct number of tasks is returned
  55         self.assertEqual(len(self.tw.tasks.filter(priority="H")), 1)
  56
  57         # Assert that the correct tasks are returned
  58         high_priority_task = self.tw.tasks.get(priority="H")
  59         self.assertEqual(high_priority_task['description'], "high priority task")
  60
  61     def test_filtering_by_empty_attribute(self):
  62         Task(self.tw, description="no priority task").save()
  63         Task(self.tw, priority="H", description="high priority task").save()
  64         self.assertEqual(len(self.tw.tasks.all()), 2)
  65
  66         # Assert that the correct number of tasks is returned
  67         self.assertEqual(len(self.tw.tasks.filter(priority=None)), 1)
  68
  69         # Assert that the correct tasks are returned
  70         no_priority_task = self.tw.tasks.get(priority=None)
  71         self.assertEqual(no_priority_task['description'], "no priority task")
  72
  73     def test_filter_for_task_with_space_in_descripition(self):
  74         task = Task(self.tw, description="test task")
  75         task.save()
  76
  77         filtered_task = self.tw.tasks.get(description="test task")
  78         self.assertEqual(filtered_task['description'], "test task")
  79
  80     def test_filter_for_task_without_space_in_descripition(self):
  81         task = Task(self.tw, description="test")
  82         task.save()
  83
  84         filtered_task = self.tw.tasks.get(description="test")
  85         self.assertEqual(filtered_task['description'], "test")
  86
  87     def test_filter_for_task_with_space_in_project(self):
  88         task = Task(self.tw, description="test", project="random project")
  89         task.save()
  90
  91         filtered_task = self.tw.tasks.get(project="random project")
  92         self.assertEqual(filtered_task['project'], "random project")
  93
  94     def test_filter_for_task_without_space_in_project(self):
  95         task = Task(self.tw, description="test", project="random")
  96         task.save()
  97
  98         filtered_task = self.tw.tasks.get(project="random")
  99         self.assertEqual(filtered_task['project'], "random")
 100
 101
 102 class TaskTest(TasklibTest):
 103
 104     def test_create_unsaved_task(self):
 105         # Make sure a new task is not saved unless explicitly called for
 106         t = Task(self.tw, description="test task")
 107         self.assertEqual(len(self.tw.tasks.all()), 0)
 108
 109     # TODO: once python 2.6 compatiblity is over, use context managers here
 110     #       and in all subsequent tests for assertRaises
 111
 112     def test_delete_unsaved_task(self):
 113         t = Task(self.tw, description="test task")
 114         self.assertRaises(Task.NotSaved, t.delete)
 115
 116     def test_complete_unsaved_task(self):
 117         t = Task(self.tw, description="test task")
 118         self.assertRaises(Task.NotSaved, t.done)
 119
 120     def test_refresh_unsaved_task(self):
 121         t = Task(self.tw, description="test task")
 122         self.assertRaises(Task.NotSaved, t.refresh)
 123
 124     def test_delete_deleted_task(self):
 125         t = Task(self.tw, description="test task")
 126         t.save()
 127         t.delete()
 128
 129         self.assertRaises(Task.DeletedTask, t.delete)
 130
 131     def test_complete_completed_task(self):
 132         t = Task(self.tw, description="test task")
 133         t.save()
 134         t.done()
 135
 136         self.assertRaises(Task.CompletedTask, t.done)
 137
 138     def test_complete_deleted_task(self):
 139         t = Task(self.tw, description="test task")
 140         t.save()
 141         t.delete()
 142
 143         self.assertRaises(Task.DeletedTask, t.done)
 144
 145     def test_modify_simple_attribute_without_space(self):
 146         t = Task(self.tw, description="test")
 147         t.save()
 148
 149         self.assertEquals(t['description'], "test")
 150
 151         t['description'] = "test-modified"
 152         t.save()
 153
 154         self.assertEquals(t['description'], "test-modified")
 155
 156     def test_modify_simple_attribute_with_space(self):
 157         # Space can pose problems with parsing
 158         t = Task(self.tw, description="test task")
 159         t.save()
 160
 161         self.assertEquals(t['description'], "test task")
 162
 163         t['description'] = "test task modified"
 164         t.save()
 165
 166         self.assertEquals(t['description'], "test task modified")
 167
 168     def test_empty_dependency_set_of_unsaved_task(self):
 169         t = Task(self.tw, description="test task")
 170         self.assertEqual(t['depends'], set())
 171
 172     def test_empty_dependency_set_of_saved_task(self):
 173         t = Task(self.tw, description="test task")
 174         t.save()
 175         self.assertEqual(t['depends'], set())
 176
 177     def test_set_unsaved_task_as_dependency(self):
 178         # Adds only one dependency to task with no dependencies
 179         t = Task(self.tw, description="test task")
 180         dependency = Task(self.tw, description="needs to be done first")
 181
 182         # We only save the parent task, dependency task is unsaved
 183         t.save()
 184
 185         self.assertRaises(Task.NotSaved,
 186                           t.__setitem__, 'depends', set([dependency]))
 187
 188     def test_set_simple_dependency_set(self):
 189         # Adds only one dependency to task with no dependencies
 190         t = Task(self.tw, description="test task")
 191         dependency = Task(self.tw, description="needs to be done first")
 192
 193         t.save()
 194         dependency.save()
 195
 196         t['depends'] = set([dependency])
 197
 198         self.assertEqual(t['depends'], set([dependency]))
 199
 200     def test_set_complex_dependency_set(self):
 201         # Adds two dependencies to task with no dependencies
 202         t = Task(self.tw, description="test task")
 203         dependency1 = Task(self.tw, description="needs to be done first")
 204         dependency2 = Task(self.tw, description="needs to be done second")
 205
 206         t.save()
 207         dependency1.save()
 208         dependency2.save()
 209
 210         t['depends'] = set([dependency1, dependency2])
 211
 212         self.assertEqual(t['depends'], set([dependency1, dependency2]))
 213
 214     def test_remove_from_dependency_set(self):
 215         # Removes dependency from task with two dependencies
 216         t = Task(self.tw, description="test task")
 217         dependency1 = Task(self.tw, description="needs to be done first")
 218         dependency2 = Task(self.tw, description="needs to be done second")
 219
 220         dependency1.save()
 221         dependency2.save()
 222
 223         t['depends'] = set([dependency1, dependency2])
 224         t.save()
 225
 226         t['depends'] = t['depends'] - set([dependency2])
 227         t.save()
 228
 229         self.assertEqual(t['depends'], set([dependency1]))
 230
 231     def test_add_to_dependency_set(self):
 232         # Adds dependency to task with one dependencies
 233         t = Task(self.tw, description="test task")
 234         dependency1 = Task(self.tw, description="needs to be done first")
 235         dependency2 = Task(self.tw, description="needs to be done second")
 236
 237         dependency1.save()
 238         dependency2.save()
 239
 240         t['depends'] = set([dependency1])
 241         t.save()
 242
 243         t['depends'] = t['depends'] | set([dependency2])
 244         t.save()
 245
 246         self.assertEqual(t['depends'], set([dependency1, dependency2]))
 247
 248     def test_simple_dependency_set_save_repeatedly(self):
 249         # Adds only one dependency to task with no dependencies
 250         t = Task(self.tw, description="test task")
 251         dependency = Task(self.tw, description="needs to be done first")
 252         dependency.save()
 253
 254         t['depends'] = set([dependency])
 255         t.save()
 256
 257         # We taint the task, but keep depends intact
 258         t['description'] = "test task modified"
 259         t.save()
 260
 261         self.assertEqual(t['depends'], set([dependency]))
 262
 263         # We taint the task, but assign the same set to the depends
 264         t['depends'] = set([dependency])
 265         t['description'] = "test task modified again"
 266         t.save()
 267
 268         self.assertEqual(t['depends'], set([dependency]))
 269
 270     def test_compare_different_tasks(self):
 271         # Negative: compare two different tasks
 272         t1 = Task(self.tw, description="test task")
 273         t2 = Task(self.tw, description="test task")
 274
 275         t1.save()
 276         t2.save()
 277
 278         self.assertEqual(t1 == t2, False)
 279
 280     def test_compare_same_task_object(self):
 281         # Compare Task object wit itself
 282         t = Task(self.tw, description="test task")
 283         t.save()
 284
 285         self.assertEqual(t == t, True)
 286
 287     def test_compare_same_task(self):
 288         # Compare the same task using two different objects
 289         t1 = Task(self.tw, description="test task")
 290         t1.save()
 291
 292         t2 = self.tw.tasks.get(uuid=t1['uuid'])
 293         self.assertEqual(t1 == t2, True)
 294
 295     def test_compare_unsaved_tasks(self):
 296         # t1 and t2 are unsaved tasks, considered to be unequal
 297         # despite the content of data
 298         t1 = Task(self.tw, description="test task")
 299         t2 = Task(self.tw, description="test task")
 300
 301         self.assertEqual(t1 == t2, False)
 302
 303     def test_hash_unsaved_tasks(self):
 304         # Considered equal, it's the same object
 305         t1 = Task(self.tw, description="test task")
 306         t2 = t1
 307         self.assertEqual(hash(t1) == hash(t2), True)
 308
 309     def test_hash_same_task(self):
 310         # Compare the hash of the task using two different objects
 311         t1 = Task(self.tw, description="test task")
 312         t1.save()
 313
 314         t2 = self.tw.tasks.get(uuid=t1['uuid'])
 315         self.assertEqual(t1.__hash__(), t2.__hash__())
 316
 317     def test_adding_task_with_priority(self):
 318         t = Task(self.tw, description="test task", priority="M")
 319         t.save()
 320
 321     def test_removing_priority_with_none(self):
 322         t = Task(self.tw, description="test task", priority="L")
 323         t.save()
 324
 325         # Remove the priority mark
 326         t['priority'] = None
 327         t.save()
 328
 329         # Assert that priority is not there after saving
 330         self.assertEqual(t['priority'], None)
 331
 332     def test_adding_task_with_due_time(self):
 333         t = Task(self.tw, description="test task", due=datetime.datetime.now())
 334         t.save()
 335
 336     def test_removing_due_time_with_none(self):
 337         t = Task(self.tw, description="test task", due=datetime.datetime.now())
 338         t.save()
 339
 340         # Remove the due timestamp
 341         t['due'] = None
 342         t.save()
 343
 344         # Assert that due timestamp is no longer there
 345         self.assertEqual(t['due'], None)
 346
 347     def test_modified_fields_new_task(self):
 348         t = Task(self.tw)
 349
 350         # This should be empty with new task
 351         self.assertEqual(set(t._modified_fields), set())
 352
 353         # Modify the task
 354         t['description'] = "test task"
 355         self.assertEqual(set(t._modified_fields), set(['description']))
 356
 357         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 358         self.assertEqual(set(t._modified_fields), set(['description', 'due']))
 359
 360         t['project'] = "test project"
 361         self.assertEqual(set(t._modified_fields),
 362                          set(['description', 'due', 'project']))
 363
 364         # List of modified fields should clear out when saved
 365         t.save()
 366         self.assertEqual(set(t._modified_fields), set())
 367
 368         # Reassigning the fields with the same values now should not produce
 369         # modified fields
 370         t['description'] = "test task"
 371         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 372         t['project'] = "test project"
 373         self.assertEqual(set(t._modified_fields), set())
 374
 375     def test_modified_fields_loaded_task(self):
 376         t = Task(self.tw)
 377
 378         # Modify the task
 379         t['description'] = "test task"
 380         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 381         t['project'] = "test project"
 382
 383         dependency = Task(self.tw, description="dependency")
 384         dependency.save()
 385         t['depends'] = set([dependency])
 386
 387         # List of modified fields should clear out when saved
 388         t.save()
 389         self.assertEqual(set(t._modified_fields), set())
 390
 391         # Get the task by using a filter by UUID
 392         t2 = self.tw.tasks.get(uuid=t['uuid'])
 393
 394         # Reassigning the fields with the same values now should not produce
 395         # modified fields
 396         t['description'] = "test task"
 397         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 398         t['project'] = "test project"
 399         t['depends'] = set([dependency])
 400         self.assertEqual(set(t._modified_fields), set())
 401
 402     def test_setting_read_only_attrs_through_init(self):
 403         # Test that we are unable to set readonly attrs through __init__
 404         for readonly_key in Task.read_only_fields:
 405             kwargs = {'description': 'test task', readonly_key: 'value'}
 406             self.assertRaises(RuntimeError,
 407                               lambda: Task(self.tw, **kwargs))
 408
 409     def test_setting_read_only_attrs_through_setitem(self):
 410         # Test that we are unable to set readonly attrs through __init__
 411         for readonly_key in Task.read_only_fields:
 412             t = Task(self.tw, description='test task')
 413             self.assertRaises(RuntimeError,
 414                               lambda: t.__setitem__(readonly_key, 'value'))
 415
 416
 417 class AnnotationTest(TasklibTest):
 418
 419     def setUp(self):
 420         super(AnnotationTest, self).setUp()
 421         Task(self.tw, description="test task").save()
 422
 423     def test_adding_annotation(self):
 424         task = self.tw.tasks.get()
 425         task.add_annotation('test annotation')
 426         self.assertEqual(len(task['annotations']), 1)
 427         ann = task['annotations'][0]
 428         self.assertEqual(ann['description'], 'test annotation')
 429
 430     def test_removing_annotation(self):
 431         task = self.tw.tasks.get()
 432         task.add_annotation('test annotation')
 433         ann = task['annotations'][0]
 434         ann.remove()
 435         self.assertEqual(len(task['annotations']), 0)
 436
 437     def test_removing_annotation_by_description(self):
 438         task = self.tw.tasks.get()
 439         task.add_annotation('test annotation')
 440         task.remove_annotation('test annotation')
 441         self.assertEqual(len(task['annotations']), 0)
 442
 443     def test_removing_annotation_by_obj(self):
 444         task = self.tw.tasks.get()
 445         task.add_annotation('test annotation')
 446         ann = task['annotations'][0]
 447         task.remove_annotation(ann)
 448         self.assertEqual(len(task['annotations']), 0)
 449
 450
 451 class UnicodeTest(TasklibTest):
 452
 453     def test_unicode_task(self):
 454         Task(self.tw, description="†åßk").save()
 455         self.tw.tasks.get()
 456
 457     def test_non_unicode_task(self):
 458         Task(self.tw, description="test task").save()
 459         self.tw.tasks.get()