def test_make_shift_smaller(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
self.storage_task.save_task(task1)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) +
datetime.timedelta(days=10))
plan1.exclude = [0, 1, 3, 4]
plan1.tid = 1
self.storage_plan.save_plan(plan1)
new_shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=3))
args = {Plan.Field.plan_id: 1, Plan.Field.shift: new_shift}
success = self.storage_plan.edit_plan(args)
self.assertEqual(success, True)
plans = self.storage_plan.get_plans(plan_id=1)[0]
plan1.plan_id = 1
plan1.shift = new_shift
plan1.exclude = [0, 10]
self.assertEqual(plans, plan1)
def test_recalculate_exclude_when_start_time_shifted_backward(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
task1.supposed_start_time = utils.datetime_to_milliseconds(
datetime.datetime.today())
self.storage_task.save_task(task1)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=2))
plan1.exclude = [0, 1, 3, 4]
plan1.tid = 1
self.storage_plan.save_plan(plan1)
new_time = utils.datetime_to_milliseconds(datetime.datetime.today() -
datetime.timedelta(days=4))
self.storage_task.edit_task({
Task.Field.tid: 1,
Task.Field.supposed_start_time: new_time
})
start_time_shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=4))
success = self.storage_plan.recalculate_exclude_when_start_time_shifted(
1, -start_time_shift)
self.assertEqual(success, True)
plan = self.storage_plan.get_plans(plan_id=1)[0]
plan1.plan_id = 1
plan1.exclude = [2, 3, 5, 6]
self.assertEqual(plan, plan1)
def test_get_plan_tasks_by_time_range(self):
class PlanStorageAdapterMock():
def get_plans(self, plan_id):
plan = Plan()
plan.tid = 1
plan.plan_id = 1
plan.shift = 3000
plan.exclude = [5]
return [plan]
class TaskStorageAdapterMock():
class Filter():
def tid(self, tid):
pass
def get_tasks(self, filter):
task = Task()
task.tid = 1
task.supposed_start_time = 0
task.supposed_end_time = 2000
return [task]
class ProjectStorageAdapterMock():
def get_projects(self, uid, name=None, pid=None):
project = Project()
project.creator = 1
project.name = Project.default_project_name
return [project]
class UserStorageAdapterMock():
def get_users(self, uid):
user = User()
return [user]
Controller.init_storage_adapters(PlanStorageAdapterMock,
TaskStorageAdapterMock,
UserStorageAdapterMock,
ProjectStorageAdapterMock)
Controller.authentication(1)
time_range = (10000, 17000)
tasks = self.controller.get_plan_tasks_by_time_range(1, time_range)
self.assertEqual(len(tasks), 2)
task1 = Task()
task1.tid = 1
task1.supposed_start_time = 9000
task1.supposed_end_time = 11000
self.assertEqual(task1.__dict__, tasks[0].__dict__)
task2 = Task()
task2.tid = 1
task2.supposed_start_time = 12000
task2.supposed_end_time = 14000
self.assertEqual(task2, tasks[1])
def test_get_plans_for_common_tid(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
task2 = Task()
task2.pid = 1
task2.title = 'Title 2'
self.storage_task.save_task(task1)
self.storage_task.save_task(task2)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=3))
plan1.exclude = [3, 5]
plan1.tid = 2
plan2 = Plan()
plan2.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=4))
plan2.exclude = [2, 8]
plan2.tid = 1
self.storage_plan.save_plan(plan1)
self.storage_plan.save_plan(plan2)
plans = self.storage_plan.get_plans(common_tid=1)
self.assertEqual(len(plans), 1)
plan2.plan_id = 2
self.assertEqual(plans[0], plan2)
def test_plans_edit_repeat(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
self.storage_task.save_task(task1)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=3))
plan1.exclude = []
plan1.tid = 1
self.storage_plan.save_plan(plan1)
task2 = Task()
task2.pid = 1
task2.title = 'Title 2'
self.storage_task.save_task(task2)
success = self.storage_plan.edit_plan_repeat(1, 8, 2)
self.assertEqual(success, True)
plan_in_db = self.storage_plan.get_plans(1)[0]
plan1.plan_id = 1
plan1.exclude.append(8)
self.assertEqual(plan_in_db, plan1)
def test_is_before_time(self):
task = Task()
task.supposed_start_time = utils.datetime_to_milliseconds(
datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=3))
time_range = (utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=5)),
utils.shift_datetime_in_millis(
datetime.datetime.today(),
datetime.timedelta(days=8)))
is_before = task.is_before_time(time_range)
self.assertEqual(is_before, True)
def test_is_after_time(self):
task = Task()
task.supposed_start_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=9))
task.supposed_end_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=10))
time_range = (utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=5)),
utils.shift_datetime_in_millis(
datetime.datetime.today(),
datetime.timedelta(days=8)))
is_after = task.is_after_time(time_range)
self.assertEqual(is_after, True)
def test_is_time_overlap_fully(self):
task = Task()
task.supposed_start_time = utils.datetime_to_milliseconds(
datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=6))
time_range = (utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=0)),
utils.shift_datetime_in_millis(
datetime.datetime.today(),
datetime.timedelta(days=6)))
is_overlap = task.is_time_overlap_fully(time_range)
self.assertEqual(is_overlap, True)
def test_exclude_delete_type(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
self.storage_task.save_task(task1)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=3))
plan1.exclude = []
plan1.tid = 1
self.storage_plan.save_plan(plan1)
self.storage_plan.delete_plan_repeat(1, 8)
exclude_type = self.storage_plan.get_exclude_type(1, 8)
self.assertEqual(exclude_type, Plan.PlanExcludeKind.DELETED)
def get_tasks(self, filter):
task = Task()
task.tid = 1
task.status = Status.PENDING
task.supposed_start_time = utils.datetime_to_milliseconds(datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=2))
task.notificate_supposed_start=False
return [task]
def test_remove_plan(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
self.storage_task.save_task(task1)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) +
datetime.timedelta(days=10))
plan1.exclude = [0, 1, 3, 4]
plan1.tid = 1
self.storage_plan.save_plan(plan1)
success = self.storage_plan.remove_plan(1)
self.assertEqual(success, True)
plans = self.storage_plan.get_plans(plan_id=1)
self.assertEqual(plans, [])
def test_plans_restore_repeat(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
self.storage_task.save_task(task1)
plan1 = Plan()
plan1.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=3))
plan1.exclude = [3, 5]
plan1.tid = 1
self.storage_plan.save_plan(plan1)
self.storage_plan.delete_plan_repeat(1, 8)
success = self.storage_plan.restore_plan_repeat(1, 8)
self.assertEqual(success, True)
plan_in_database = self.storage_plan.get_plans(plan_id=1)[0]
plan1.plan_id = 1
self.assertEqual(plan_in_database, plan1)
def test_save_remove_get_tasks(self):
test_task = Task()
test_task.pid = 1
test_task.title = 'flkmerfkl'
test_task.description = 'lkfmelkf'
test_task.supposed_start_time = 232332
test_task.supposed_end_time = 3423
test_task.deadline_time = 2442324
test_task.notificate_deadline = True
self.storage.save_task(test_task)
self.storage.save_task(test_task)
tasks_in_db = self.storage.get_tasks()
success = self.storage.remove_task(tasks_in_db[0].tid)
self.assertEqual(success, True)
tasks_in_db_after_delete = self.storage.get_tasks()
self.assertEqual(len(tasks_in_db_after_delete), 1)
self.assertEqual(tasks_in_db_after_delete[0], tasks_in_db[1])
def test_save_get_tasks(self):
test_task = Task()
test_task.pid = 1
test_task.title = 'vfdmk'
test_task.description = 'vvkjndk'
test_task.deadline_time = 23233
success = self.storage.save_task(test_task)
self.assertEqual(success, True)
success = self.storage.save_task(test_task)
self.assertEqual(success, True)
tasks_in_sqlite = self.storage.get_tasks()
self.assertEqual(len(tasks_in_sqlite), 2)
test_task.tid = 1
self.assertEqual(tasks_in_sqlite[0], test_task)
test_task.tid = 2
self.assertEqual(tasks_in_sqlite[1], test_task)
def test_save_plan(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
task2 = Task()
task2.pid = 1
task2.title = 'Title 2'
self.storage_task.save_task(task1)
self.storage_task.save_task(task2)
plan = Plan()
plan.shift = utils.datetime_to_milliseconds(
datetime.datetime.utcfromtimestamp(0) + datetime.timedelta(days=3))
plan.exclude = [3, 5]
plan.tid = 2
success = self.storage_plan.save_plan(plan)
self.assertEqual(success, True)
def test_save_get_all_filtered_tasks(self):
test_task_1 = Task()
test_task_1.pid = 1
test_task_1.title = 'vfdmk'
test_task_1.description = 'vvkjndk'
test_task_1.deadline_time = 23233
success = self.storage.save_task(test_task_1)
self.assertEqual(success, True)
success = self.storage.save_task(test_task_1)
self.assertEqual(success, True)
filter = TaskStorageAdapter.Filter()
filter.title('2344243')
tasks_in_sqlite = self.storage.get_tasks(filter)
self.assertEqual(len(tasks_in_sqlite), 0)
def test_save_get_user_task(self):
test_task = Task()
test_task.pid = 1
test_task.title = 'title 1'
test_task.description = 'description 1'
test_task.deadline_time = 23233
test_user = User()
test_user.login = '******'
test_user.password = '******'
test_user.online = True
self.storage_user.save_user(test_user)
test_user.uid = self.storage_user.get_users()[0].uid
test_task.uid = test_user.uid
self.storage_task.save_task(test_task)
filter = TaskStorageAdapter.Filter()
filter.uid(test_user.uid)
tasks_in_db = self.storage_task.get_tasks(filter)
self.assertEqual(len(tasks_in_db), 1)
test_task.tid = tasks_in_db[0].tid
self.assertEqual(test_task, tasks_in_db[0])
def test_shift_task_forward(self):
task = Task()
task.supposed_start_time = utils.datetime_to_milliseconds(
datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=4))
shift_time = utils.create_shift_in_millis(datetime.timedelta(days=4))
task.shift_time(shift_time)
test_start_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=4))
test_end_time = utils.shift_datetime_in_millis(
datetime.datetime.today(), datetime.timedelta(days=8))
if test_start_time - task.supposed_start_time == 1:
test_start_time -= 1
if test_end_time - task.supposed_end_time == 1:
test_end_time -= 1
self.assertEqual(task.supposed_start_time, test_start_time)
self.assertEqual(task.supposed_end_time, test_end_time)
self.assertEqual(task.deadline_time, None)
def test_save_edit_get_tasks(self):
test_task = Task()
test_task.pid = 1
test_task.title = 'flkmerfkl'
test_task.description = 'lkfmelkf'
test_task.supposed_start_time = 232332
test_task.supposed_end_time = 3423
test_task.deadline_time = 2442324
test_task.notificate_deadline = True
edited_test_task = Task()
edited_test_task.pid = 1
edited_test_task.title = 'efnkrjf'
edited_test_task.description = '23323223'
edited_test_task.supposed_start_time = 232332
edited_test_task.supposed_end_time = 23443
edited_test_task.deadline_time = 2442324
edited_test_task.notificate_deadline = False
success = self.storage.save_task(test_task)
self.assertEqual(success, True)
success = self.storage.save_task(test_task)
self.assertEqual(success, True)
tasks_in_db = self.storage.get_tasks()
edited_test_task.tid = tasks_in_db[0].tid
success = self.storage.edit_task({
Task.Field.tid: tasks_in_db[0].tid,
Task.Field.title: 'efnkrjf',
Task.Field.description: '23323223',
Task.Field.supposed_start_time: 232332,
Task.Field.supposed_end_time: 23443,
Task.Field.deadline_time: 2442324,
Task.Field.notificate_deadline: False
})
self.assertEqual(success, True)
tasks_in_db_after_edit = self.storage.get_tasks()
self.assertEqual(len(tasks_in_db_after_edit), 2)
self.assertEqual(tasks_in_db_after_edit[0], edited_test_task)
self.assertEqual(tasks_in_db_after_edit[1], tasks_in_db[1])
def test_save_get_title_descr_filtered_tasks(self):
test_task_1 = Task()
test_task_1.pid = 1
test_task_1.title = 'vfdmk'
test_task_1.description = 'vvkjndk'
test_task_1.deadline_time = 23233
test_task_2 = Task()
test_task_2.pid = 1
test_task_2.title = 'lmlkmlkml'
test_task_2.description = 'vvkjndk'
test_task_2.deadline_time = 23233
test_task_3 = Task()
test_task_3.pid = 1
test_task_3.title = 'vfdmk'
test_task_3.description = 'vvkjndk232332'
test_task_3.deadline_time = 23233
success = self.storage.save_task(test_task_1)
self.assertEqual(success, True)
success = self.storage.save_task(test_task_2)
self.assertEqual(success, True)
success = self.storage.save_task(test_task_3)
self.assertEqual(success, True)
filter = TaskStorageAdapter.Filter()
filter.title('vfdmk')
filter.description('vvkjndk232332')
tasks_in_sqlite = self.storage.get_tasks(filter)
self.assertEqual(len(tasks_in_sqlite), 1)
test_task_3.tid = 3
self.assertEqual(tasks_in_sqlite[0], test_task_3)
def test_edit_repeat_by_number(self):
class PlanStorageAdapterMock():
_plan_id = None
_number = None
_tid = None
def get_plans(self, plan_id=None, common_tid=None):
plan = Plan()
plan.tid = 1
plan.plan_id = 1
plan.shift = utils.create_shift_in_millis(datetime.timedelta(days=3))
plan.exclude = [5]
return [plan]
def edit_plan_repeat(self, plan_id, number, tid):
self.__class__._plan_id = plan_id
self.__class__._number = number
self.__class__._tid = tid
return True
def get_tid_for_edit_repeat(self, plan_id, number):
return 2
class TaskStorageAdapterMock():
_saved_task = None
_removed_tid = None
class Filter():
def tid(self, tid):
self._tid = tid
def uid(self, uid):
self._uid = uid
def get_tasks(self, filter):
tid = getattr(filter, '_tid', None)
if tid is not None and tid == 1:
task = Task()
task.tid = 1
task.status = Status.PENDING
task.supposed_start_time = utils.datetime_to_milliseconds(datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=2))
task.notificate_supposed_start=False
return [task]
if tid is not None and tid == 2:
task = Task()
task.tid = 2
task.status = Status.PENDING
task.supposed_start_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=9))
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=11))
task.notificate_deadline=True
return [task]
return []
def remove_task(self, tid):
self.__class__._removed_tid = tid
return True
def save_task(self, task):
self.__class__._saved_task = task
return True
def get_last_saved_task(self):
self._saved_task.tid = 3
return self._saved_task
class ProjectStorageAdapterMock():
def get_projects(self, uid, name=None, pid=None):
project = Project()
project.creator = 1
project.name = Project.default_project_name
return [project]
class UserStorageAdapterMock():
def get_users(self, uid):
user = User()
return [user]
Controller.init_storage_adapters(PlanStorageAdapterMock,
TaskStorageAdapterMock, UserStorageAdapterMock, ProjectStorageAdapterMock)
Controller.authentication(1)
success = self.controller.edit_repeat_by_number(1, 3, status=Status.COMPLETED,
notificate_supposed_start=True)
self.assertEqual(success, True)
task = Task()
task.tid = 3
task.status = Status.COMPLETED
task.supposed_start_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=9))
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=11))
task.notificate_supposed_start=True
if task.supposed_start_time - TaskStorageAdapterMock._saved_task.supposed_start_time == 1:
task.supposed_start_time -= 1
if task.supposed_end_time - TaskStorageAdapterMock._saved_task.supposed_end_time == 1:
task.supposed_end_time -= 1
self.assertEqual(TaskStorageAdapterMock._saved_task.__dict__, task.__dict__)
self.assertEqual(TaskStorageAdapterMock._removed_tid, 2)
self.assertEqual(PlanStorageAdapterMock._plan_id, 1)
self.assertEqual(PlanStorageAdapterMock._number, 3)
self.assertEqual(PlanStorageAdapterMock._tid, 3)
def get_tasks(self, filter):
tid = getattr(filter, '_tid', None)
if tid is not None and tid == 1:
task = Task()
task.tid = 1
task.status = Status.PENDING
task.supposed_start_time = utils.datetime_to_milliseconds(datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=2))
task.notificate_supposed_start=False
return [task]
if tid is not None and tid == 2:
task = Task()
task.tid = 2
task.status = Status.PENDING
task.supposed_start_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=9))
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=11))
task.notificate_deadline=True
return [task]
return []
def get_tasks(self, filter):
task = Task()
task.tid = 1
task.supposed_start_time = utils.datetime_to_milliseconds(datetime.datetime.today())
task.supposed_end_time = utils.shift_datetime_in_millis(datetime.datetime.today(), datetime.timedelta(days=3))
return [task]
def test_save_task_remove_user(self):
test_task_1 = Task()
test_task_1.pid = 1
test_task_1.title = 'title 1'
test_task_1.description = 'description 1'
test_task_1.deadline_time = 23233
test_task_2 = Task()
test_task_2.pid = 1
test_task_2.title = 'title 2'
test_task_2.description = 'description 1'
test_task_2.deadline_time = 23233
test_user = User()
test_user.login = '******'
test_user.password = '******'
test_user.online = True
self.storage_user.save_user(test_user)
test_user.uid = self.storage_user.get_users()[0].uid
test_task_1.uid = test_user.uid
self.storage_task.save_task(test_task_1)
self.storage_task.save_task(test_task_2)
self.storage_user.delete_user(test_user.uid)
tasks_in_db = self.storage_task.get_tasks()
self.assertEqual(len(tasks_in_db), 1)
test_task_2.tid = tasks_in_db[0].tid
self.assertEqual(test_task_2, tasks_in_db[0])
def test_save_remove_get_multi_parent_tid(self):
test_task_1 = Task()
test_task_1.pid = 1
test_task_1.title = 'vfdmk'
test_task_1.description = 'vvkjndk'
test_task_1.deadline_time = 23233
test_task_2 = Task()
test_task_2.pid = 1
test_task_2.title = 'lmlkmlkml'
test_task_2.description = 'vvkjndk'
test_task_2.deadline_time = 23233
test_task_3 = Task()
test_task_3.pid = 1
test_task_3.title = 'vfdmk'
test_task_3.description = 'vvkjndk232332'
test_task_3.deadline_time = 23233
test_task_4 = Task()
test_task_4.pid = 1
test_task_4.title = 'vfdmk'
test_task_4.description = 'vvkjndk232332'
test_task_4.deadline_time = 23233
self.storage.save_task(test_task_1)
test_task_2.parent_tid = 1
test_task_3.parent_tid = 2
test_task_4.parent_tid = 2
self.storage.save_task(test_task_2)
self.storage.save_task(test_task_3)
self.storage.save_task(test_task_4)
success = self.storage.remove_task(1)
self.assertEqual(success, True)
tasks_in_db = self.storage.get_tasks()
self.assertEqual(len(tasks_in_db), 0)
def get_tasks(self, filter):
task = Task()
task.tid = 1
task.supposed_start_time = 0
task.supposed_end_time = 2000
return [task]
def to_task(self):
task = Task()
task.tid = self.tid
project_table_model = self.pid
if project_table_model is not None:
task.pid = project_table_model.pid
task.parent_tid = self.parent_tid
user_table_model = self.uid
if user_table_model is not None:
task.uid = user_table_model.uid
task.title = self.title
task.description = self.description
task.supposed_start_time = self.supposed_start_time
task.supposed_end_time = self.supposed_end_time
task.deadline_time = self.deadline_time
task.priority = self.priority
task.status = self.status
task.notificate_supposed_start = self.notificate_supposed_start
task.notificate_supposed_end = self.notificate_supposed_end
task.notificate_deadline = self.notificate_deadline
return task
def test_remove_task_when_its_common_for_plan(self):
task1 = Task()
task1.pid = 1
task1.title = 'Title 1'
task1.supposed_start_time = utils.datetime_to_milliseconds(
datetime.datetime.today())
task2 = Task()
task2.pid = 1
task2.title = 'Title 2'
task2.supposed_start_time = utils.datetime_to_milliseconds(
datetime.datetime.today())
self.storage_task.save_task(task1)
self.storage_task.save_task(task2)
plan1 = Plan()
plan1.shift = utils.create_shift_in_millis(datetime.timedelta(days=2))
plan1.exclude = [0, 1, 3, 4]
plan1.tid = 1
self.storage_plan.save_plan(plan1)
success = self.storage_task.remove_task(1)
self.assertEqual(success, True)
tasks = self.storage_task.get_tasks()
self.assertEqual(len(tasks), 1)
task2.tid = 2
self.assertEqual(tasks[0], task2)
plans = self.storage_plan.get_plans()
self.assertEqual(len(plans), 0)
def test_save_get_single_parent_tid(self):
test_task_1 = Task()
test_task_1.pid = 1
test_task_1.title = 'vfdmk'
test_task_1.description = 'vvkjndk'
test_task_1.deadline_time = 23233
test_task_2 = Task()
test_task_2.pid = 1
test_task_2.title = 'lmlkmlkml'
test_task_2.description = 'vvkjndk'
test_task_2.deadline_time = 23233
test_task_3 = Task()
test_task_3.pid = 1
test_task_3.title = 'vfdmk'
test_task_3.description = 'vvkjndk232332'
test_task_3.deadline_time = 23233
test_task_4 = Task()
test_task_4.pid = 1
test_task_4.title = 'vfdmk'
test_task_4.description = 'vvkjndk232332'
test_task_4.deadline_time = 23233
self.storage.save_task(test_task_1)
test_task_2.parent_tid = 1
test_task_3.parent_tid = 1
self.storage.save_task(test_task_2)
self.storage.save_task(test_task_3)
self.storage.save_task(test_task_4)
filter = TaskStorageAdapter.Filter()
filter.parent_tid(1)
tasks_with_parent_1 = self.storage.get_tasks(filter)
self.assertEqual(len(tasks_with_parent_1), 2)
test_task_2.tid = 2
test_task_3.tid = 3
self.assertEqual(tasks_with_parent_1[0], test_task_2)
self.assertEqual(tasks_with_parent_1[1], test_task_3)
