tasklib/tests.py

   1 # coding=utf-8
   2
   3 import copy
   4 import datetime
   5 import itertools
   6 import json
   7 import pytz
   8 import six
   9 import shutil
  10 import sys
  11 import tempfile
  12 import unittest
  13
  14 from .backends import TaskWarrior
  15 from .task import Task, ReadOnlyDictView, TaskQuerySet
  16 from .lazy import LazyUUIDTask, LazyUUIDTaskSet
  17 from .serializing import DATE_FORMAT, local_zone
  18
  19 # http://taskwarrior.org/docs/design/task.html , Section: The Attributes
  20 TASK_STANDARD_ATTRS = (
  21     'status',
  22     'uuid',
  23     'entry',
  24     'description',
  25     'start',
  26     'end',
  27     'due',
  28     'until',
  29     'wait',
  30     'modified',
  31     'scheduled',
  32     'recur',
  33     'mask',
  34     'imask',
  35     'parent',
  36     'project',
  37     'priority',
  38     'depends',
  39     'tags',
  40     'annotations',
  41 )
  42
  43 total_seconds_2_6 = lambda x: x.microseconds / 1e6 + x.seconds + x.days * 24 * 3600
  44
  45
  46 class TasklibTest(unittest.TestCase):
  47
  48     def setUp(self):
  49         self.tmp = tempfile.mkdtemp(dir='.')
  50         self.tw = TaskWarrior(data_location=self.tmp, taskrc_location='/')
  51
  52     def tearDown(self):
  53         shutil.rmtree(self.tmp)
  54
  55
  56 class TaskFilterTest(TasklibTest):
  57
  58     def test_all_empty(self):
  59         self.assertEqual(len(self.tw.tasks.all()), 0)
  60
  61     def test_all_non_empty(self):
  62         Task(self.tw, description="test task").save()
  63         self.assertEqual(len(self.tw.tasks.all()), 1)
  64         self.assertEqual(self.tw.tasks.all()[0]['description'], 'test task')
  65         self.assertEqual(self.tw.tasks.all()[0]['status'], 'pending')
  66
  67     def test_pending_non_empty(self):
  68         Task(self.tw, description="test task").save()
  69         self.assertEqual(len(self.tw.tasks.pending()), 1)
  70         self.assertEqual(self.tw.tasks.pending()[0]['description'],
  71                          'test task')
  72         self.assertEqual(self.tw.tasks.pending()[0]['status'], 'pending')
  73
  74     def test_completed_empty(self):
  75         Task(self.tw, description="test task").save()
  76         self.assertEqual(len(self.tw.tasks.completed()), 0)
  77
  78     def test_completed_non_empty(self):
  79         Task(self.tw, description="test task").save()
  80         self.assertEqual(len(self.tw.tasks.completed()), 0)
  81         self.tw.tasks.all()[0].done()
  82         self.assertEqual(len(self.tw.tasks.completed()), 1)
  83
  84     def test_deleted_empty(self):
  85         Task(self.tw, description="test task").save()
  86         self.assertEqual(len(self.tw.tasks.deleted()), 0)
  87
  88     def test_deleted_non_empty(self):
  89         Task(self.tw, description="test task").save()
  90         self.assertEqual(len(self.tw.tasks.deleted()), 0)
  91         self.tw.tasks.all()[0].delete()
  92         self.assertEqual(len(self.tw.tasks.deleted()), 1)
  93
  94     def test_waiting_empty(self):
  95         Task(self.tw, description="test task").save()
  96         self.assertEqual(len(self.tw.tasks.waiting()), 0)
  97
  98     def test_waiting_non_empty(self):
  99         Task(self.tw, description="test task").save()
 100         self.assertEqual(len(self.tw.tasks.waiting()), 0)
 101
 102         t = self.tw.tasks.all()[0]
 103         t['wait'] = datetime.datetime.now() + datetime.timedelta(days=1)
 104         t.save()
 105
 106         self.assertEqual(len(self.tw.tasks.waiting()), 1)
 107
 108     def test_recurring_empty(self):
 109         Task(self.tw, description="test task").save()
 110         self.assertEqual(len(self.tw.tasks.recurring()), 0)
 111
 112     def test_recurring_non_empty(self):
 113         Task(self.tw, description="test task", recur="daily",
 114              due=datetime.datetime.now()).save()
 115         self.assertEqual(len(self.tw.tasks.recurring()), 1)
 116
 117     def test_filtering_by_attribute(self):
 118         Task(self.tw, description="no priority task").save()
 119         Task(self.tw, priority="H", description="high priority task").save()
 120         self.assertEqual(len(self.tw.tasks.all()), 2)
 121
 122         # Assert that the correct number of tasks is returned
 123         self.assertEqual(len(self.tw.tasks.filter(priority="H")), 1)
 124
 125         # Assert that the correct tasks are returned
 126         high_priority_task = self.tw.tasks.get(priority="H")
 127         self.assertEqual(high_priority_task['description'], "high priority task")
 128
 129     def test_filtering_by_empty_attribute(self):
 130         Task(self.tw, description="no priority task").save()
 131         Task(self.tw, priority="H", description="high priority task").save()
 132         self.assertEqual(len(self.tw.tasks.all()), 2)
 133
 134         # Assert that the correct number of tasks is returned
 135         self.assertEqual(len(self.tw.tasks.filter(priority=None)), 1)
 136
 137         # Assert that the correct tasks are returned
 138         no_priority_task = self.tw.tasks.get(priority=None)
 139         self.assertEqual(no_priority_task['description'], "no priority task")
 140
 141     def test_filter_for_task_with_space_in_descripition(self):
 142         task = Task(self.tw, description="test task")
 143         task.save()
 144
 145         filtered_task = self.tw.tasks.get(description="test task")
 146         self.assertEqual(filtered_task['description'], "test task")
 147
 148     def test_filter_for_task_without_space_in_descripition(self):
 149         task = Task(self.tw, description="test")
 150         task.save()
 151
 152         filtered_task = self.tw.tasks.get(description="test")
 153         self.assertEqual(filtered_task['description'], "test")
 154
 155     def test_filter_for_task_with_space_in_project(self):
 156         task = Task(self.tw, description="test", project="random project")
 157         task.save()
 158
 159         filtered_task = self.tw.tasks.get(project="random project")
 160         self.assertEqual(filtered_task['project'], "random project")
 161
 162     def test_filter_for_task_without_space_in_project(self):
 163         task = Task(self.tw, description="test", project="random")
 164         task.save()
 165
 166         filtered_task = self.tw.tasks.get(project="random")
 167         self.assertEqual(filtered_task['project'], "random")
 168
 169     def test_filter_with_empty_uuid(self):
 170         self.assertRaises(ValueError, lambda: self.tw.tasks.get(uuid=''))
 171
 172     def test_filter_dummy_by_status(self):
 173         t = Task(self.tw, description="test")
 174         t.save()
 175
 176         tasks = self.tw.tasks.filter(status=t['status'])
 177         self.assertEqual(list(tasks), [t])
 178
 179     def test_filter_dummy_by_uuid(self):
 180         t = Task(self.tw, description="test")
 181         t.save()
 182
 183         tasks = self.tw.tasks.filter(uuid=t['uuid'])
 184         self.assertEqual(list(tasks), [t])
 185
 186     def test_filter_dummy_by_entry(self):
 187         t = Task(self.tw, description="test")
 188         t.save()
 189
 190         tasks = self.tw.tasks.filter(entry=t['entry'])
 191         self.assertEqual(list(tasks), [t])
 192
 193     def test_filter_dummy_by_description(self):
 194         t = Task(self.tw, description="test")
 195         t.save()
 196
 197         tasks = self.tw.tasks.filter(description=t['description'])
 198         self.assertEqual(list(tasks), [t])
 199
 200     def test_filter_dummy_by_start(self):
 201         t = Task(self.tw, description="test")
 202         t.save()
 203         t.start()
 204
 205         tasks = self.tw.tasks.filter(start=t['start'])
 206         self.assertEqual(list(tasks), [t])
 207
 208     def test_filter_dummy_by_end(self):
 209         t = Task(self.tw, description="test")
 210         t.save()
 211         t.done()
 212
 213         tasks = self.tw.tasks.filter(end=t['end'])
 214         self.assertEqual(list(tasks), [t])
 215
 216     def test_filter_dummy_by_due(self):
 217         t = Task(self.tw, description="test", due=datetime.datetime.now())
 218         t.save()
 219
 220         tasks = self.tw.tasks.filter(due=t['due'])
 221         self.assertEqual(list(tasks), [t])
 222
 223     def test_filter_dummy_by_until(self):
 224         t = Task(self.tw, description="test")
 225         t.save()
 226
 227         tasks = self.tw.tasks.filter(until=t['until'])
 228         self.assertEqual(list(tasks), [t])
 229
 230     def test_filter_dummy_by_modified(self):
 231         # Older TW version does not support bumping modified
 232         # on save
 233         if self.tw.version < six.text_type('2.2.0'):
 234             # Python2.6 does not support SkipTest. As a workaround
 235             # mark the test as passed by exiting.
 236             if getattr(unittest, 'SkipTest', None) is not None:
 237                 raise unittest.SkipTest()
 238             else:
 239                 return
 240
 241         t = Task(self.tw, description="test")
 242         t.save()
 243
 244         tasks = self.tw.tasks.filter(modified=t['modified'])
 245         self.assertEqual(list(tasks), [t])
 246
 247     def test_filter_dummy_by_scheduled(self):
 248         t = Task(self.tw, description="test")
 249         t.save()
 250
 251         tasks = self.tw.tasks.filter(scheduled=t['scheduled'])
 252         self.assertEqual(list(tasks), [t])
 253
 254     def test_filter_dummy_by_tags(self):
 255         t = Task(self.tw, description="test", tags=["home"])
 256         t.save()
 257
 258         tasks = self.tw.tasks.filter(tags=t['tags'])
 259         self.assertEqual(list(tasks), [t])
 260
 261     def test_filter_dummy_by_projects(self):
 262         t = Task(self.tw, description="test", project="random")
 263         t.save()
 264
 265         tasks = self.tw.tasks.filter(project=t['project'])
 266         self.assertEqual(list(tasks), [t])
 267
 268     def test_filter_by_priority(self):
 269         t = Task(self.tw, description="test", priority="H")
 270         t.save()
 271
 272         tasks = self.tw.tasks.filter(priority=t['priority'])
 273         self.assertEqual(list(tasks), [t])
 274
 275
 276 class TaskTest(TasklibTest):
 277
 278     def test_create_unsaved_task(self):
 279         # Make sure a new task is not saved unless explicitly called for
 280         t = Task(self.tw, description="test task")
 281         self.assertEqual(len(self.tw.tasks.all()), 0)
 282
 283     # TODO: once python 2.6 compatiblity is over, use context managers here
 284     #       and in all subsequent tests for assertRaises
 285
 286     def test_delete_unsaved_task(self):
 287         t = Task(self.tw, description="test task")
 288         self.assertRaises(Task.NotSaved, t.delete)
 289
 290     def test_complete_unsaved_task(self):
 291         t = Task(self.tw, description="test task")
 292         self.assertRaises(Task.NotSaved, t.done)
 293
 294     def test_refresh_unsaved_task(self):
 295         t = Task(self.tw, description="test task")
 296         self.assertRaises(Task.NotSaved, t.refresh)
 297
 298     def test_start_unsaved_task(self):
 299         t = Task(self.tw, description="test task")
 300         self.assertRaises(Task.NotSaved, t.start)
 301
 302     def test_delete_deleted_task(self):
 303         t = Task(self.tw, description="test task")
 304         t.save()
 305         t.delete()
 306
 307         self.assertRaises(Task.DeletedTask, t.delete)
 308
 309     def test_complete_completed_task(self):
 310         t = Task(self.tw, description="test task")
 311         t.save()
 312         t.done()
 313
 314         self.assertRaises(Task.CompletedTask, t.done)
 315
 316     def test_start_completed_task(self):
 317         t = Task(self.tw, description="test task")
 318         t.save()
 319         t.done()
 320
 321         self.assertRaises(Task.CompletedTask, t.start)
 322
 323     def test_add_completed_task(self):
 324         t = Task(self.tw, description="test", status="completed",
 325                  end=datetime.datetime.now())
 326         t.save()
 327
 328     def test_add_multiple_completed_tasks(self):
 329         t1 = Task(self.tw, description="test1", status="completed",
 330                  end=datetime.datetime.now())
 331         t2 = Task(self.tw, description="test2", status="completed",
 332                  end=datetime.datetime.now())
 333         t1.save()
 334         t2.save()
 335
 336     def test_complete_deleted_task(self):
 337         t = Task(self.tw, description="test task")
 338         t.save()
 339         t.delete()
 340
 341         self.assertRaises(Task.DeletedTask, t.done)
 342
 343     def test_starting_task(self):
 344         t = Task(self.tw, description="test task")
 345         now = t.datetime_normalizer(datetime.datetime.now())
 346         t.save()
 347         t.start()
 348
 349         self.assertTrue(now.replace(microsecond=0) <= t['start'])
 350         self.assertEqual(t['status'], 'pending')
 351
 352     def test_completing_task(self):
 353         t = Task(self.tw, description="test task")
 354         now = t.datetime_normalizer(datetime.datetime.now())
 355         t.save()
 356         t.done()
 357
 358         self.assertTrue(now.replace(microsecond=0) <= t['end'])
 359         self.assertEqual(t['status'], 'completed')
 360
 361     def test_deleting_task(self):
 362         t = Task(self.tw, description="test task")
 363         now = t.datetime_normalizer(datetime.datetime.now())
 364         t.save()
 365         t.delete()
 366
 367         self.assertTrue(now.replace(microsecond=0) <= t['end'])
 368         self.assertEqual(t['status'], 'deleted')
 369
 370     def test_started_task_active(self):
 371         t = Task(self.tw, description="test task")
 372         t.save()
 373         t.start()
 374         self.assertTrue(t.active)
 375
 376     def test_unstarted_task_inactive(self):
 377         t = Task(self.tw, description="test task")
 378         self.assertFalse(t.active)
 379         t.save()
 380         self.assertFalse(t.active)
 381
 382     def test_start_active_task(self):
 383         t = Task(self.tw, description="test task")
 384         t.save()
 385         t.start()
 386         self.assertRaises(Task.ActiveTask, t.start)
 387
 388     def test_stop_completed_task(self):
 389         t = Task(self.tw, description="test task")
 390         t.save()
 391         t.start()
 392         t.done()
 393
 394         self.assertRaises(Task.InactiveTask, t.stop)
 395
 396         t = Task(self.tw, description="test task")
 397         t.save()
 398         t.done()
 399
 400         self.assertRaises(Task.InactiveTask, t.stop)
 401
 402     def test_stop_deleted_task(self):
 403         t = Task(self.tw, description="test task")
 404         t.save()
 405         t.start()
 406         t.delete()
 407         t.stop()
 408
 409     def test_stop_inactive_task(self):
 410         t = Task(self.tw, description="test task")
 411         t.save()
 412
 413         self.assertRaises(Task.InactiveTask, t.stop)
 414
 415         t = Task(self.tw, description="test task")
 416         t.save()
 417         t.start()
 418         t.stop()
 419
 420         self.assertRaises(Task.InactiveTask, t.stop)
 421
 422     def test_stopping_task(self):
 423         t = Task(self.tw, description="test task")
 424         now = t.datetime_normalizer(datetime.datetime.now())
 425         t.save()
 426         t.start()
 427         t.stop()
 428
 429         self.assertEqual(t['end'], None)
 430         self.assertEqual(t['status'], 'pending')
 431         self.assertFalse(t.active)
 432
 433     def test_modify_simple_attribute_without_space(self):
 434         t = Task(self.tw, description="test")
 435         t.save()
 436
 437         self.assertEquals(t['description'], "test")
 438
 439         t['description'] = "test-modified"
 440         t.save()
 441
 442         self.assertEquals(t['description'], "test-modified")
 443
 444     def test_modify_simple_attribute_with_space(self):
 445         # Space can pose problems with parsing
 446         t = Task(self.tw, description="test task")
 447         t.save()
 448
 449         self.assertEquals(t['description'], "test task")
 450
 451         t['description'] = "test task modified"
 452         t.save()
 453
 454         self.assertEquals(t['description'], "test task modified")
 455
 456     def test_empty_dependency_set_of_unsaved_task(self):
 457         t = Task(self.tw, description="test task")
 458         self.assertEqual(t['depends'], set())
 459
 460     def test_empty_dependency_set_of_saved_task(self):
 461         t = Task(self.tw, description="test task")
 462         t.save()
 463         self.assertEqual(t['depends'], set())
 464
 465     def test_set_unsaved_task_as_dependency(self):
 466         # Adds only one dependency to task with no dependencies
 467         t = Task(self.tw, description="test task")
 468         dependency = Task(self.tw, description="needs to be done first")
 469
 470         # We only save the parent task, dependency task is unsaved
 471         t.save()
 472         t['depends'] = set([dependency])
 473
 474         self.assertRaises(Task.NotSaved, t.save)
 475
 476     def test_set_simple_dependency_set(self):
 477         # Adds only one dependency to task with no dependencies
 478         t = Task(self.tw, description="test task")
 479         dependency = Task(self.tw, description="needs to be done first")
 480
 481         t.save()
 482         dependency.save()
 483
 484         t['depends'] = set([dependency])
 485
 486         self.assertEqual(t['depends'], set([dependency]))
 487
 488     def test_set_complex_dependency_set(self):
 489         # Adds two dependencies to task with no dependencies
 490         t = Task(self.tw, description="test task")
 491         dependency1 = Task(self.tw, description="needs to be done first")
 492         dependency2 = Task(self.tw, description="needs to be done second")
 493
 494         t.save()
 495         dependency1.save()
 496         dependency2.save()
 497
 498         t['depends'] = set([dependency1, dependency2])
 499
 500         self.assertEqual(t['depends'], set([dependency1, dependency2]))
 501
 502     def test_remove_from_dependency_set(self):
 503         # Removes dependency from task with two dependencies
 504         t = Task(self.tw, description="test task")
 505         dependency1 = Task(self.tw, description="needs to be done first")
 506         dependency2 = Task(self.tw, description="needs to be done second")
 507
 508         dependency1.save()
 509         dependency2.save()
 510
 511         t['depends'] = set([dependency1, dependency2])
 512         t.save()
 513
 514         t['depends'].remove(dependency2)
 515         t.save()
 516
 517         self.assertEqual(t['depends'], set([dependency1]))
 518
 519     def test_add_to_dependency_set(self):
 520         # Adds dependency to task with one dependencies
 521         t = Task(self.tw, description="test task")
 522         dependency1 = Task(self.tw, description="needs to be done first")
 523         dependency2 = Task(self.tw, description="needs to be done second")
 524
 525         dependency1.save()
 526         dependency2.save()
 527
 528         t['depends'] = set([dependency1])
 529         t.save()
 530
 531         t['depends'].add(dependency2)
 532         t.save()
 533
 534         self.assertEqual(t['depends'], set([dependency1, dependency2]))
 535
 536     def test_add_to_empty_dependency_set(self):
 537         # Adds dependency to task with one dependencies
 538         t = Task(self.tw, description="test task")
 539         dependency = Task(self.tw, description="needs to be done first")
 540
 541         dependency.save()
 542
 543         t['depends'].add(dependency)
 544         t.save()
 545
 546         self.assertEqual(t['depends'], set([dependency]))
 547
 548     def test_simple_dependency_set_save_repeatedly(self):
 549         # Adds only one dependency to task with no dependencies
 550         t = Task(self.tw, description="test task")
 551         dependency = Task(self.tw, description="needs to be done first")
 552         dependency.save()
 553
 554         t['depends'] = set([dependency])
 555         t.save()
 556
 557         # We taint the task, but keep depends intact
 558         t['description'] = "test task modified"
 559         t.save()
 560
 561         self.assertEqual(t['depends'], set([dependency]))
 562
 563         # We taint the task, but assign the same set to the depends
 564         t['depends'] = set([dependency])
 565         t['description'] = "test task modified again"
 566         t.save()
 567
 568         self.assertEqual(t['depends'], set([dependency]))
 569
 570     def test_compare_different_tasks(self):
 571         # Negative: compare two different tasks
 572         t1 = Task(self.tw, description="test task")
 573         t2 = Task(self.tw, description="test task")
 574
 575         t1.save()
 576         t2.save()
 577
 578         self.assertEqual(t1 == t2, False)
 579
 580     def test_compare_same_task_object(self):
 581         # Compare Task object wit itself
 582         t = Task(self.tw, description="test task")
 583         t.save()
 584
 585         self.assertEqual(t == t, True)
 586
 587     def test_compare_same_task(self):
 588         # Compare the same task using two different objects
 589         t1 = Task(self.tw, description="test task")
 590         t1.save()
 591
 592         t2 = self.tw.tasks.get(uuid=t1['uuid'])
 593         self.assertEqual(t1 == t2, True)
 594
 595     def test_compare_unsaved_tasks(self):
 596         # t1 and t2 are unsaved tasks, considered to be unequal
 597         # despite the content of data
 598         t1 = Task(self.tw, description="test task")
 599         t2 = Task(self.tw, description="test task")
 600
 601         self.assertEqual(t1 == t2, False)
 602
 603     def test_hash_unsaved_tasks(self):
 604         # Considered equal, it's the same object
 605         t1 = Task(self.tw, description="test task")
 606         t2 = t1
 607         self.assertEqual(hash(t1) == hash(t2), True)
 608
 609     def test_hash_same_task(self):
 610         # Compare the hash of the task using two different objects
 611         t1 = Task(self.tw, description="test task")
 612         t1.save()
 613
 614         t2 = self.tw.tasks.get(uuid=t1['uuid'])
 615         self.assertEqual(t1.__hash__(), t2.__hash__())
 616
 617     def test_adding_task_with_priority(self):
 618         t = Task(self.tw, description="test task", priority="M")
 619         t.save()
 620
 621     def test_removing_priority_with_none(self):
 622         t = Task(self.tw, description="test task", priority="L")
 623         t.save()
 624
 625         # Remove the priority mark
 626         t['priority'] = None
 627         t.save()
 628
 629         # Assert that priority is not there after saving
 630         self.assertEqual(t['priority'], None)
 631
 632     def test_adding_task_with_due_time(self):
 633         t = Task(self.tw, description="test task", due=datetime.datetime.now())
 634         t.save()
 635
 636     def test_removing_due_time_with_none(self):
 637         t = Task(self.tw, description="test task", due=datetime.datetime.now())
 638         t.save()
 639
 640         # Remove the due timestamp
 641         t['due'] = None
 642         t.save()
 643
 644         # Assert that due timestamp is no longer there
 645         self.assertEqual(t['due'], None)
 646
 647     def test_modified_fields_new_task(self):
 648         t = Task(self.tw)
 649
 650         # This should be empty with new task
 651         self.assertEqual(set(t._modified_fields), set())
 652
 653         # Modify the task
 654         t['description'] = "test task"
 655         self.assertEqual(set(t._modified_fields), set(['description']))
 656
 657         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 658         self.assertEqual(set(t._modified_fields), set(['description', 'due']))
 659
 660         t['project'] = "test project"
 661         self.assertEqual(set(t._modified_fields),
 662                          set(['description', 'due', 'project']))
 663
 664         # List of modified fields should clear out when saved
 665         t.save()
 666         self.assertEqual(set(t._modified_fields), set())
 667
 668         # Reassigning the fields with the same values now should not produce
 669         # modified fields
 670         t['description'] = "test task"
 671         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 672         t['project'] = "test project"
 673         self.assertEqual(set(t._modified_fields), set())
 674
 675     def test_modified_fields_loaded_task(self):
 676         t = Task(self.tw)
 677
 678         # Modify the task
 679         t['description'] = "test task"
 680         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 681         t['project'] = "test project"
 682
 683         dependency = Task(self.tw, description="dependency")
 684         dependency.save()
 685         t['depends'] = set([dependency])
 686
 687         # List of modified fields should clear out when saved
 688         t.save()
 689         self.assertEqual(set(t._modified_fields), set())
 690
 691         # Get the task by using a filter by UUID
 692         t2 = self.tw.tasks.get(uuid=t['uuid'])
 693
 694         # Reassigning the fields with the same values now should not produce
 695         # modified fields
 696         t['description'] = "test task"
 697         t['due'] = datetime.datetime(2014, 2, 14, 14, 14, 14)  # <3
 698         t['project'] = "test project"
 699         t['depends'] = set([dependency])
 700         self.assertEqual(set(t._modified_fields), set())
 701
 702     def test_modified_fields_not_affected_by_reading(self):
 703         t = Task(self.tw)
 704
 705         for field in TASK_STANDARD_ATTRS:
 706             value = t[field]
 707
 708         self.assertEqual(set(t._modified_fields), set())
 709
 710     def test_setting_read_only_attrs_through_init(self):
 711         # Test that we are unable to set readonly attrs through __init__
 712         for readonly_key in Task.read_only_fields:
 713             kwargs = {'description': 'test task', readonly_key: 'value'}
 714             self.assertRaises(RuntimeError,
 715                               lambda: Task(self.tw, **kwargs))
 716
 717     def test_setting_read_only_attrs_through_setitem(self):
 718         # Test that we are unable to set readonly attrs through __init__
 719         for readonly_key in Task.read_only_fields:
 720             t = Task(self.tw, description='test task')
 721             self.assertRaises(RuntimeError,
 722                               lambda: t.__setitem__(readonly_key, 'value'))
 723
 724     def test_saving_unmodified_task(self):
 725         t = Task(self.tw, description="test task")
 726         t.save()
 727         t.save()
 728
 729     def test_adding_tag_by_appending(self):
 730         t = Task(self.tw, description="test task", tags=['test1'])
 731         t.save()
 732         t['tags'].add('test2')
 733         t.save()
 734         self.assertEqual(t['tags'], set(['test1', 'test2']))
 735
 736     def test_adding_tag_twice(self):
 737         t = Task(self.tw, description="test task", tags=['test1'])
 738         t.save()
 739         t['tags'].add('test2')
 740         t['tags'].add('test2')
 741         t.save()
 742         self.assertEqual(t['tags'], set(['test1', 'test2']))
 743
 744     def test_adding_tag_by_appending_empty(self):
 745         t = Task(self.tw, description="test task")
 746         t.save()
 747         t['tags'].add('test')
 748         t.save()
 749         self.assertEqual(t['tags'], set(['test']))
 750
 751     def test_serializers_returning_empty_string_for_none(self):
 752         # Test that any serializer returns '' when passed None
 753         t = Task(self.tw)
 754         serializers = [getattr(t, serializer_name) for serializer_name in
 755                        filter(lambda x: x.startswith('serialize_'), dir(t))]
 756         for serializer in serializers:
 757             self.assertEqual(serializer(None), '')
 758
 759     def test_deserializer_returning_empty_value_for_empty_string(self):
 760         # Test that any deserializer returns empty value when passed ''
 761         t = Task(self.tw)
 762         deserializers = [getattr(t, deserializer_name) for deserializer_name in
 763                         filter(lambda x: x.startswith('deserialize_'), dir(t))]
 764         for deserializer in deserializers:
 765             self.assertTrue(deserializer('') in (None, [], set()))
 766
 767     def test_normalizers_handling_none(self):
 768         # Test that any normalizer can handle None as a valid value
 769         t = Task(self.tw)
 770
 771         for key in TASK_STANDARD_ATTRS:
 772             t._normalize(key, None)
 773
 774     def test_recurrent_task_generation(self):
 775         today = datetime.date.today()
 776         t = Task(self.tw, description="brush teeth",
 777                  due=today, recur="daily")
 778         t.save()
 779         self.assertEqual(len(self.tw.tasks.pending()), 2)
 780
 781     def test_spawned_task_parent(self):
 782         today = datetime.date.today()
 783         t = Task(self.tw, description="brush teeth",
 784                  due=today, recur="daily")
 785         t.save()
 786
 787         spawned = self.tw.tasks.pending().get(due=today)
 788         assert spawned['parent'] == t
 789
 790     def test_modify_number_of_tasks_at_once(self):
 791         for i in range(1, 100):
 792             Task(self.tw, description="test task %d" % i, tags=['test']).save()
 793
 794         self.tw.execute_command(['+test', 'mod', 'unified', 'description'])
 795
 796     def test_return_all_from_executed_command(self):
 797         Task(self.tw, description="test task", tags=['test']).save()
 798         out, err, rc = self.tw.execute_command(['count'], return_all=True)
 799         self.assertEqual(rc, 0)
 800
 801     def test_return_all_from_failed_executed_command(self):
 802         Task(self.tw, description="test task", tags=['test']).save()
 803         out, err, rc = self.tw.execute_command(['countinvalid'],
 804             return_all=True, allow_failure=False)
 805         self.assertNotEqual(rc, 0)
 806
 807
 808 class TaskFromHookTest(TasklibTest):
 809
 810     input_add_data = six.StringIO(
 811         '{"description":"Buy some milk",'
 812         '"entry":"20141118T050231Z",'
 813         '"status":"pending",'
 814         '"start":"20141119T152233Z",'
 815         '"uuid":"a360fc44-315c-4366-b70c-ea7e7520b749"}')
 816
 817     input_add_data_recurring = six.StringIO(
 818         '{"description":"Mow the lawn",'
 819         '"entry":"20160210T224304Z",'
 820         '"parent":"62da6227-519c-42c2-915d-dccada926ad7",'
 821         '"recur":"weekly",'
 822         '"status":"pending",'
 823         '"uuid":"81305335-0237-49ff-8e87-b3cdc2369cec"}')
 824
 825     input_modify_data = six.StringIO(input_add_data.getvalue() + '\n' +
 826         '{"description":"Buy some milk finally",'
 827         '"entry":"20141118T050231Z",'
 828         '"status":"completed",'
 829         '"uuid":"a360fc44-315c-4366-b70c-ea7e7520b749"}')
 830
 831     exported_raw_data = (
 832         '{"project":"Home",'
 833          '"due":"20150101T232323Z",'
 834          '"description":"test task"}')
 835
 836     def test_setting_up_from_add_hook_input(self):
 837         t = Task.from_input(input_file=self.input_add_data, backend=self.tw)
 838         self.assertEqual(t['description'], "Buy some milk")
 839         self.assertEqual(t.pending, True)
 840
 841     def test_setting_up_from_add_hook_input_recurring(self):
 842         t = Task.from_input(input_file=self.input_add_data_recurring,
 843                             backend=self.tw)
 844         self.assertEqual(t['description'], "Mow the lawn")
 845         self.assertEqual(t.pending, True)
 846
 847     def test_setting_up_from_modified_hook_input(self):
 848         t = Task.from_input(input_file=self.input_modify_data, modify=True,
 849                             backend=self.tw)
 850         self.assertEqual(t['description'], "Buy some milk finally")
 851         self.assertEqual(t.pending, False)
 852         self.assertEqual(t.completed, True)
 853
 854         self.assertEqual(t._original_data['status'], "pending")
 855         self.assertEqual(t._original_data['description'], "Buy some milk")
 856         self.assertEqual(set(t._modified_fields),
 857                          set(['status', 'description', 'start']))
 858
 859     def test_export_data(self):
 860         t = Task(self.tw, description="test task",
 861             project="Home",
 862             due=pytz.utc.localize(datetime.datetime(2015,1,1,23,23,23)))
 863
 864         # Check that the output is a permutation of:
 865         # {"project":"Home","description":"test task","due":"20150101232323Z"}
 866         allowed_segments = self.exported_raw_data[1:-1].split(',')
 867         allowed_output = [
 868             '{' + ','.join(segments) + '}'
 869             for segments in itertools.permutations(allowed_segments)
 870         ]
 871
 872         self.assertTrue(any(t.export_data() == expected
 873                             for expected in allowed_output))
 874
 875 class TimezoneAwareDatetimeTest(TasklibTest):
 876
 877     def setUp(self):
 878         super(TimezoneAwareDatetimeTest, self).setUp()
 879         self.zone = local_zone
 880         self.localdate_naive = datetime.datetime(2015,2,2)
 881         self.localtime_naive = datetime.datetime(2015,2,2,0,0,0)
 882         self.localtime_aware = self.zone.localize(self.localtime_naive)
 883         self.utctime_aware = self.localtime_aware.astimezone(pytz.utc)
 884
 885     def test_timezone_naive_datetime_setitem(self):
 886         t = Task(self.tw, description="test task")
 887         t['due'] = self.localtime_naive
 888         self.assertEqual(t['due'], self.localtime_aware)
 889
 890     def test_timezone_naive_datetime_using_init(self):
 891         t = Task(self.tw, description="test task", due=self.localtime_naive)
 892         self.assertEqual(t['due'], self.localtime_aware)
 893
 894     def test_filter_by_naive_datetime(self):
 895         t = Task(self.tw, description="task1", due=self.localtime_naive)
 896         t.save()
 897         matching_tasks = self.tw.tasks.filter(due=self.localtime_naive)
 898         self.assertEqual(len(matching_tasks), 1)
 899
 900     def test_serialize_naive_datetime(self):
 901         t = Task(self.tw, description="task1", due=self.localtime_naive)
 902         self.assertEqual(json.loads(t.export_data())['due'],
 903                          self.utctime_aware.strftime(DATE_FORMAT))
 904
 905     def test_timezone_naive_date_setitem(self):
 906         t = Task(self.tw, description="test task")
 907         t['due'] = self.localdate_naive
 908         self.assertEqual(t['due'], self.localtime_aware)
 909
 910     def test_timezone_naive_date_using_init(self):
 911         t = Task(self.tw, description="test task", due=self.localdate_naive)
 912         self.assertEqual(t['due'], self.localtime_aware)
 913
 914     def test_filter_by_naive_date(self):
 915         t = Task(self.tw, description="task1", due=self.localdate_naive)
 916         t.save()
 917         matching_tasks = self.tw.tasks.filter(due=self.localdate_naive)
 918         self.assertEqual(len(matching_tasks), 1)
 919
 920     def test_serialize_naive_date(self):
 921         t = Task(self.tw, description="task1", due=self.localdate_naive)
 922         self.assertEqual(json.loads(t.export_data())['due'],
 923                          self.utctime_aware.strftime(DATE_FORMAT))
 924
 925     def test_timezone_aware_datetime_setitem(self):
 926         t = Task(self.tw, description="test task")
 927         t['due'] = self.localtime_aware
 928         self.assertEqual(t['due'], self.localtime_aware)
 929
 930     def test_timezone_aware_datetime_using_init(self):
 931         t = Task(self.tw, description="test task", due=self.localtime_aware)
 932         self.assertEqual(t['due'], self.localtime_aware)
 933
 934     def test_filter_by_aware_datetime(self):
 935         t = Task(self.tw, description="task1", due=self.localtime_aware)
 936         t.save()
 937         matching_tasks = self.tw.tasks.filter(due=self.localtime_aware)
 938         self.assertEqual(len(matching_tasks), 1)
 939
 940     def test_serialize_aware_datetime(self):
 941         t = Task(self.tw, description="task1", due=self.localtime_aware)
 942         self.assertEqual(json.loads(t.export_data())['due'],
 943                          self.utctime_aware.strftime(DATE_FORMAT))
 944
 945 class DatetimeStringTest(TasklibTest):
 946
 947     def test_simple_now_conversion(self):
 948         if self.tw.version < six.text_type('2.4.0'):
 949             # Python2.6 does not support SkipTest. As a workaround
 950             # mark the test as passed by exiting.
 951             if getattr(unittest, 'SkipTest', None) is not None:
 952                 raise unittest.SkipTest()
 953             else:
 954                 return
 955
 956         t = Task(self.tw, description="test task", due="now")
 957         now = local_zone.localize(datetime.datetime.now())
 958
 959         # Assert that both times are not more than 5 seconds apart
 960         if sys.version_info < (2,7):
 961             self.assertTrue(total_seconds_2_6(now - t['due']) < 5)
 962             self.assertTrue(total_seconds_2_6(t['due'] - now) < 5)
 963         else:
 964             self.assertTrue((now - t['due']).total_seconds() < 5)
 965             self.assertTrue((t['due'] - now).total_seconds() < 5)
 966
 967     def test_simple_eoy_conversion(self):
 968         if self.tw.version < six.text_type('2.4.0'):
 969             # Python2.6 does not support SkipTest. As a workaround
 970             # mark the test as passed by exiting.
 971             if getattr(unittest, 'SkipTest', None) is not None:
 972                 raise unittest.SkipTest()
 973             else:
 974                 return
 975
 976         t = Task(self.tw, description="test task", due="eoy")
 977         now = local_zone.localize(datetime.datetime.now())
 978         eoy = local_zone.localize(datetime.datetime(
 979             year=now.year,
 980             month=12,
 981             day=31,
 982             hour=23,
 983             minute=59,
 984             second=59
 985             ))
 986         self.assertEqual(eoy, t['due'])
 987
 988     def test_complex_eoy_conversion(self):
 989         if self.tw.version < six.text_type('2.4.0'):
 990             # Python2.6 does not support SkipTest. As a workaround
 991             # mark the test as passed by exiting.
 992             if getattr(unittest, 'SkipTest', None) is not None:
 993                 raise unittest.SkipTest()
 994             else:
 995                 return
 996
 997         t = Task(self.tw, description="test task", due="eoy - 4 months")
 998         now = local_zone.localize(datetime.datetime.now())
 999         due_date = local_zone.localize(datetime.datetime(
1000             year=now.year,
1001             month=12,
1002             day=31,
1003             hour=23,
1004             minute=59,
1005             second=59
1006             )) - datetime.timedelta(0,4 * 30 * 86400)
1007         self.assertEqual(due_date, t['due'])
1008
1009     def test_filtering_with_string_datetime(self):
1010         if self.tw.version < six.text_type('2.4.0'):
1011             # Python2.6 does not support SkipTest. As a workaround
1012             # mark the test as passed by exiting.
1013             if getattr(unittest, 'SkipTest', None) is not None:
1014                 raise unittest.SkipTest()
1015             else:
1016                 return
1017
1018         t = Task(self.tw, description="test task",
1019                  due=datetime.datetime.now() - datetime.timedelta(0,2))
1020         t.save()
1021         self.assertEqual(len(self.tw.tasks.filter(due__before="now")), 1)
1022
1023 class AnnotationTest(TasklibTest):
1024
1025     def setUp(self):
1026         super(AnnotationTest, self).setUp()
1027         Task(self.tw, description="test task").save()
1028
1029     def test_adding_annotation(self):
1030         task = self.tw.tasks.get()
1031         task.add_annotation('test annotation')
1032         self.assertEqual(len(task['annotations']), 1)
1033         ann = task['annotations'][0]
1034         self.assertEqual(ann['description'], 'test annotation')
1035
1036     def test_removing_annotation(self):
1037         task = self.tw.tasks.get()
1038         task.add_annotation('test annotation')
1039         ann = task['annotations'][0]
1040         ann.remove()
1041         self.assertEqual(len(task['annotations']), 0)
1042
1043     def test_removing_annotation_by_description(self):
1044         task = self.tw.tasks.get()
1045         task.add_annotation('test annotation')
1046         task.remove_annotation('test annotation')
1047         self.assertEqual(len(task['annotations']), 0)
1048
1049     def test_removing_annotation_by_obj(self):
1050         task = self.tw.tasks.get()
1051         task.add_annotation('test annotation')
1052         ann = task['annotations'][0]
1053         task.remove_annotation(ann)
1054         self.assertEqual(len(task['annotations']), 0)
1055
1056     def test_annotation_after_modification(self):
1057          task = self.tw.tasks.get()
1058          task['project'] = 'test'
1059          task.add_annotation('I should really do this task')
1060          self.assertEqual(task['project'], 'test')
1061          task.save()
1062          self.assertEqual(task['project'], 'test')
1063
1064     def test_serialize_annotations(self):
1065         # Test that serializing annotations is possible
1066         t = Task(self.tw, description="test")
1067         t.save()
1068
1069         t.add_annotation("annotation1")
1070         t.add_annotation("annotation2")
1071
1072         data = t._serialize('annotations', t._data['annotations'])
1073
1074         self.assertEqual(len(data), 2)
1075         self.assertEqual(type(data[0]), dict)
1076         self.assertEqual(type(data[1]), dict)
1077
1078         self.assertEqual(data[0]['description'], "annotation1")
1079         self.assertEqual(data[1]['description'], "annotation2")
1080
1081
1082 class UnicodeTest(TasklibTest):
1083
1084     def test_unicode_task(self):
1085         Task(self.tw, description=six.u("†åßk")).save()
1086         self.tw.tasks.get()
1087
1088     def test_filter_by_unicode_task(self):
1089         Task(self.tw, description=six.u("†åßk")).save()
1090         tasks = self.tw.tasks.filter(description=six.u("†åßk"))
1091         self.assertEqual(len(tasks), 1)
1092
1093     def test_non_unicode_task(self):
1094         Task(self.tw, description="test task").save()
1095         self.tw.tasks.get()
1096
1097 class ReadOnlyDictViewTest(unittest.TestCase):
1098
1099     def setUp(self):
1100         self.sample = dict(l=[1,2,3], d={'k':'v'})
1101         self.original_sample = copy.deepcopy(self.sample)
1102         self.view = ReadOnlyDictView(self.sample)
1103
1104     def test_readonlydictview_getitem(self):
1105         l = self.view['l']
1106         self.assertEqual(l, self.sample['l'])
1107
1108         # Assert that modification changed only copied value
1109         l.append(4)
1110         self.assertNotEqual(l, self.sample['l'])
1111
1112         # Assert that viewed dict is not changed
1113         self.assertEqual(self.sample, self.original_sample)
1114
1115     def test_readonlydictview_contains(self):
1116         self.assertEqual('l' in self.view, 'l' in self.sample)
1117         self.assertEqual('d' in self.view, 'd' in self.sample)
1118         self.assertEqual('k' in self.view, 'k' in self.sample)
1119
1120         # Assert that viewed dict is not changed
1121         self.assertEqual(self.sample, self.original_sample)
1122
1123     def test_readonlydictview_iter(self):
1124         self.assertEqual(list(k for k in self.view),
1125                          list(k for k in self.sample))
1126
1127         # Assert the view is correct after modification
1128         self.sample['new'] = 'value'
1129         self.assertEqual(list(k for k in self.view),
1130                          list(k for k in self.sample))
1131
1132     def test_readonlydictview_len(self):
1133         self.assertEqual(len(self.view), len(self.sample))
1134
1135         # Assert the view is correct after modification
1136         self.sample['new'] = 'value'
1137         self.assertEqual(len(self.view), len(self.sample))
1138
1139     def test_readonlydictview_get(self):
1140         l = self.view.get('l')
1141         self.assertEqual(l, self.sample.get('l'))
1142
1143         # Assert that modification changed only copied value
1144         l.append(4)
1145         self.assertNotEqual(l, self.sample.get('l'))
1146
1147         # Assert that viewed dict is not changed
1148         self.assertEqual(self.sample, self.original_sample)
1149
1150     def test_readonlydict_items(self):
1151         view_items = self.view.items()
1152         sample_items = list(self.sample.items())
1153         self.assertEqual(view_items, sample_items)
1154
1155         view_items.append('newkey')
1156         self.assertNotEqual(view_items, sample_items)
1157         self.assertEqual(self.sample, self.original_sample)
1158
1159     def test_readonlydict_values(self):
1160         view_values = self.view.values()
1161         sample_values = list(self.sample.values())
1162         self.assertEqual(view_values, sample_values)
1163
1164         view_list_item = list(filter(lambda x: type(x) is list,
1165                                      view_values))[0]
1166         view_list_item.append(4)
1167         self.assertNotEqual(view_values, sample_values)
1168         self.assertEqual(self.sample, self.original_sample)
1169
1170
1171 class LazyUUIDTaskTest(TasklibTest):
1172
1173     def setUp(self):
1174         super(LazyUUIDTaskTest, self).setUp()
1175
1176         self.stored = Task(self.tw, description="this is test task")
1177         self.stored.save()
1178
1179         self.lazy = LazyUUIDTask(self.tw, self.stored['uuid'])
1180
1181     def test_uuid_non_conversion(self):
1182         assert self.stored['uuid'] == self.lazy['uuid']
1183         assert type(self.lazy) is LazyUUIDTask
1184
1185     def test_lazy_explicit_conversion(self):
1186         assert type(self.lazy) is LazyUUIDTask
1187         self.lazy.replace()
1188         assert type(self.lazy) is Task
1189
1190     def test_conversion_key(self):
1191         assert self.stored['description'] == self.lazy['description']
1192         assert type(self.lazy) is Task
1193
1194     def test_conversion_attribute(self):
1195         assert type(self.lazy) is LazyUUIDTask
1196         assert self.lazy.completed is False
1197         assert type(self.lazy) is Task
1198
1199     def test_normal_to_lazy_equality(self):
1200         assert self.stored == self.lazy
1201         assert not self.stored != self.lazy
1202         assert type(self.lazy) is LazyUUIDTask
1203
1204     def test_lazy_to_lazy_equality(self):
1205         lazy1 = LazyUUIDTask(self.tw, self.stored['uuid'])
1206         lazy2 = LazyUUIDTask(self.tw, self.stored['uuid'])
1207
1208         assert lazy1 == lazy2
1209         assert not lazy1 != lazy2
1210         assert type(lazy1) is LazyUUIDTask
1211         assert type(lazy2) is LazyUUIDTask
1212
1213     def test_normal_to_lazy_inequality(self):
1214         # Create a different UUID by changing the last letter
1215         wrong_uuid = self.stored['uuid']
1216         wrong_uuid = wrong_uuid[:-1] + ('a' if wrong_uuid[-1] != 'a' else 'b')
1217
1218         wrong_lazy = LazyUUIDTask(self.tw, wrong_uuid)
1219
1220         assert not self.stored == wrong_lazy
1221         assert self.stored != wrong_lazy
1222         assert type(wrong_lazy) is LazyUUIDTask
1223
1224     def test_lazy_to_lazy_inequality(self):
1225         # Create a different UUID by changing the last letter
1226         wrong_uuid = self.stored['uuid']
1227         wrong_uuid = wrong_uuid[:-1] + ('a' if wrong_uuid[-1] != 'a' else 'b')
1228
1229         lazy1 = LazyUUIDTask(self.tw, self.stored['uuid'])
1230         lazy2 = LazyUUIDTask(self.tw, wrong_uuid)
1231
1232         assert not lazy1 == lazy2
1233         assert lazy1 != lazy2
1234         assert type(lazy1) is LazyUUIDTask
1235         assert type(lazy2) is LazyUUIDTask
1236
1237     def test_lazy_in_queryset(self):
1238         tasks = self.tw.tasks.filter(uuid=self.stored['uuid'])
1239
1240         assert self.lazy in tasks
1241         assert type(self.lazy) is LazyUUIDTask
1242
1243     def test_lazy_saved(self):
1244         assert self.lazy.saved is True
1245
1246     def test_lazy_modified(self):
1247         assert self.lazy.modified is False
1248
1249     def test_lazy_modified_fields(self):
1250         assert self.lazy._modified_fields == set()
1251
1252
1253 class LazyUUIDTaskSetTest(TasklibTest):
1254
1255     def setUp(self):
1256         super(LazyUUIDTaskSetTest, self).setUp()
1257
1258         self.task1 = Task(self.tw, description="task 1")
1259         self.task2 = Task(self.tw, description="task 2")
1260         self.task3 = Task(self.tw, description="task 3")
1261
1262         self.task1.save()
1263         self.task2.save()
1264         self.task3.save()
1265
1266         self.uuids = (
1267             self.task1['uuid'],
1268             self.task2['uuid'],
1269             self.task3['uuid']
1270         )
1271
1272         self.lazy = LazyUUIDTaskSet(self.tw, self.uuids)
1273
1274     def test_length(self):
1275         assert len(self.lazy) == 3
1276         assert type(self.lazy) is LazyUUIDTaskSet
1277
1278     def test_contains(self):
1279         assert self.task1 in self.lazy
1280         assert self.task2 in self.lazy
1281         assert self.task3 in self.lazy
1282         assert type(self.lazy) is LazyUUIDTaskSet
1283
1284     def test_eq_lazy(self):
1285         new_lazy = LazyUUIDTaskSet(self.tw, self.uuids)
1286         assert self.lazy == new_lazy
1287         assert not self.lazy != new_lazy
1288         assert type(self.lazy) is LazyUUIDTaskSet
1289
1290     def test_eq_real(self):
1291         assert self.lazy == self.tw.tasks.all()
1292         assert self.tw.tasks.all() == self.lazy
1293         assert not self.lazy != self.tw.tasks.all()
1294
1295         assert type(self.lazy) is LazyUUIDTaskSet
1296
1297     def test_union(self):
1298         taskset = set([self.task1])
1299         lazyset = LazyUUIDTaskSet(
1300             self.tw,
1301             (self.task2['uuid'], self.task3['uuid'])
1302         )
1303
1304         assert taskset | lazyset == self.lazy
1305         assert lazyset | taskset == self.lazy
1306         assert taskset.union(lazyset) == self.lazy
1307         assert lazyset.union(taskset) == self.lazy
1308
1309         lazyset |= taskset
1310         assert lazyset == self.lazy
1311
1312     def test_difference(self):
1313         taskset = set([self.task1, self.task2])
1314         lazyset = LazyUUIDTaskSet(
1315             self.tw,
1316             (self.task2['uuid'], self.task3['uuid'])
1317         )
1318
1319         assert taskset - lazyset == set([self.task1])
1320         assert lazyset - taskset == set([self.task3])
1321         assert taskset.difference(lazyset) == set([self.task1])
1322         assert lazyset.difference(taskset) == set([self.task3])
1323
1324         lazyset -= taskset
1325         assert lazyset == set([self.task3])
1326
1327     def test_symmetric_difference(self):
1328         taskset = set([self.task1, self.task2])
1329         lazyset = LazyUUIDTaskSet(
1330             self.tw,
1331             (self.task2['uuid'], self.task3['uuid'])
1332         )
1333
1334         assert taskset ^ lazyset == set([self.task1, self.task3])
1335         assert lazyset ^ taskset == set([self.task1, self.task3])
1336         assert taskset.symmetric_difference(lazyset) == set([self.task1, self.task3])
1337         assert lazyset.symmetric_difference(taskset) == set([self.task1, self.task3])
1338
1339         lazyset ^= taskset
1340         assert lazyset == set([self.task1, self.task3])
1341
1342     def test_intersection(self):
1343         taskset = set([self.task1, self.task2])
1344         lazyset = LazyUUIDTaskSet(
1345             self.tw,
1346             (self.task2['uuid'], self.task3['uuid'])
1347         )
1348
1349         assert taskset & lazyset == set([self.task2])
1350         assert lazyset & taskset == set([self.task2])
1351         assert taskset.intersection(lazyset) == set([self.task2])
1352         assert lazyset.intersection(taskset) == set([self.task2])
1353
1354         lazyset &= taskset
1355         assert lazyset == set([self.task2])
1356
1357
1358 class TaskWarriorBackendTest(TasklibTest):
1359
1360     def test_config(self):
1361         assert self.tw.config['nag'] == "You have more urgent tasks."
1362         assert self.tw.config['debug'] == "no"