def test_sync_time_entry(self):
"""
Test to ensure synchronizer saves a time entry instance locally.
"""
time_entries = fixture_utils.generate_objects(
'TimeEntry', fixtures.API_TIME_ENTRY_LIST)
mocks.api_query_call(time_entries)
synchronizer = sync.TimeEntrySynchronizer()
synchronizer.sync()
self.assertGreater(TimeEntry.objects.all().count(), 0)
object_data = fixtures.API_TIME_ENTRY_TICKET
instance = TimeEntry.objects.get(id=object_data['id'])
ticket = Ticket.objects.first()
ticket.id = object_data['TicketID']
instance.ticket = ticket
resource = Resource.objects.first()
resource.id = object_data['ResourceID']
instance.resource = resource
self._assert_sync(instance, object_data)
assert_sync_job(TimeEntry)
def test_sync_resource_service_desk_role(self):
"""
Test to ensure synchronizer saves an instance locally.
"""
resource_service_desk_role = fixture_utils.generate_objects(
'ResourceServiceDeskRole',
fixtures.API_RESOURCE_SERVICE_DESK_ROLE_LIST)
mocks.api_query_call(resource_service_desk_role)
synchronizer = sync.ResourceServiceDeskRoleSynchronizer()
synchronizer.sync()
self.assertGreater(ResourceServiceDeskRole.objects.all().count(), 0)
object_data = fixtures.API_RESOURCE_SERVICE_DESK_ROLE
instance = ResourceServiceDeskRole.objects.get(id=object_data['id'])
role = Role.objects.first()
role.id = object_data['RoleID']
instance.role = role
resource = Resource.objects.first()
resource.id = object_data['ResourceID']
instance.resource = resource
self._assert_sync(instance, object_data)
assert_sync_job(ResourceServiceDeskRole)
def test_sync_resource_role_department(self):
"""
Test to ensure synchronizer saves an instance locally.
"""
resource_role_department = fixture_utils.generate_objects(
'ResourceRoleDepartment',
fixtures.API_RESOURCE_ROLE_DEPARTMENT_LIST)
mocks.api_query_call(resource_role_department)
synchronizer = sync.ResourceRoleDepartmentSynchronizer()
synchronizer.sync()
self.assertGreater(ResourceRoleDepartment.objects.all().count(), 0)
object_data = fixtures.API_RESOURCE_ROLE_DEPARTMENT
instance = ResourceRoleDepartment.objects.get(id=object_data['id'])
role = Role.objects.first()
role.id = object_data['RoleID']
instance.role = role
resource = Resource.objects.first()
resource.id = object_data['ResourceID']
instance.resource = resource
department = Department.objects.first()
department.id = object_data['DepartmentID']
instance.department = department
self._assert_sync(instance, object_data)
assert_sync_job(ResourceRoleDepartment)
def test_fetch_sync_by_id(self):
test_instance = fixture_utils.generate_objects(
'Ticket', fixtures.API_TICKET_LIST)
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
test_instance)
result = self.synchronizer.fetch_sync_by_id(fixtures.API_TICKET['id'])
self._assert_sync(result, fixtures.API_TICKET)
patch.stop()
def test_add(self):
self.assertEqual(Ticket.objects.count(), 0)
test_instance = fixture_utils.generate_objects(
'Ticket', fixtures.API_TICKET_LIST)
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
test_instance)
self._test_synced(fixtures.API_TICKET)
patch.stop()
def test_update(self):
fixture_utils.init_tickets()
self.assertEqual(Ticket.objects.count(), 1)
# Change the description of the local record to make our test
# meaningful.
t = Ticket.objects.get(id=7688)
t.description = 'foobar'
t.save()
test_instance = fixture_utils.generate_objects(
'Ticket', fixtures.API_TICKET_LIST)
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
test_instance)
self._test_synced(fixtures.API_TICKET)
patch.stop()
def test_delete_stale_time_entries(self):
"""
Verify that time entry is deleted if not returned during a full sync
"""
time_entries = fixture_utils.generate_objects(
'TimeEntry', fixtures.API_TIME_ENTRY_LIST)
mocks.api_query_call(time_entries)
synchronizer = sync.TimeEntrySynchronizer()
synchronizer.sync()
qset = TimeEntry.objects.all()
self.assertEqual(qset.count(), len(fixtures.API_TIME_ENTRY_LIST))
mocks.api_query_call([])
synchronizer = sync.TimeEntrySynchronizer(full=True)
synchronizer.sync()
qset = TimeEntry.objects.all()
self.assertEqual(qset.count(), 0)
def test_sync_filters_tasks_on_inactive_project(self):
# Add copied task to project in 'Complete' status to ensure it is
# filtered out during the sync.
task_fixture = deepcopy(fixtures.API_TASK)
task_fixture['id'] = '7740'
task_fixture['ProjectID'] = self.inactive_project.id
task_instance = fixture_utils.generate_objects(
'Task', [task_fixture, fixtures.API_TASK])
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
task_instance)
synchronizer = sync.TaskSynchronizer(full=True)
synchronizer.sync()
synced_task_ids = Task.objects.values_list('id', flat=True)
self.assertGreater(Task.objects.all().count(), 0)
self.assertNotIn(task_fixture['id'], synced_task_ids)
self.assertIn(fixtures.API_TASK['id'], synced_task_ids)
patch.stop()
def test_sync_assigns_null_relation(self):
model_type = self.model_class.__name__
model_object = self.model_class.objects.first()
self.assertIsNotNone(model_object.assigned_resource)
fixture_instance = deepcopy(
getattr(fixtures, 'API_{}'.format(model_type.upper())))
fixture_instance.pop('AssignedResourceID')
object_instance = fixture_utils.generate_objects(
model_type, [fixture_instance])
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
object_instance)
synchronizer = self.sync_class(full=True)
synchronizer.sync()
model_object = self.model_class.objects.get(id=model_object.id)
self.assertIsNone(model_object.assigned_resource)
patch.stop()
def test_sync_filters_projects_in_complete_status(self):
"""
Test to ensure that sync does not persist projects in an
inactive project status.
"""
project_in_complete_status = fixtures.API_PROJECT_LIST[0]
project_fixture = deepcopy(project_in_complete_status)
project_fixture['id'] = '6'
project_fixture['Status'] = self.complete_status.id
project_instance = fixture_utils.generate_objects(
'Project', [project_fixture, fixtures.API_PROJECT_LIST[0]])
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
project_instance)
synchronizer = sync.ProjectSynchronizer(full=True)
synchronizer.sync()
synced_project_ids = Project.objects.values_list('id', flat=True)
self.assertGreater(Project.objects.all().count(), 0)
self.assertNotIn(project_fixture['id'], synced_project_ids)
self.assertIn(project_in_complete_status['id'], synced_project_ids)
patch.stop()
def test_sync_filters_tasks_on_complete_project(self):
"""
Test to ensure that sync does not persist tasks on a complete project.
"""
project = Project.objects.create(name='Complete Project')
project.status = self.complete_status
project.save()
task_fixture = deepcopy(fixtures.API_TASK)
task_fixture['id'] = '7741'
task_fixture['ProjectID'] = project.id
task_instance = fixture_utils.generate_objects(
'Task', [task_fixture, fixtures.API_TASK])
_, patch = mocks.create_mock_call(mocks.WRAPPER_QUERY_METHOD,
task_instance)
synchronizer = sync.TaskSynchronizer(full=True)
synchronizer.sync()
synced_task_ids = Task.objects.values_list('id', flat=True)
self.assertGreater(Task.objects.all().count(), 0)
self.assertNotIn(task_fixture['id'], synced_task_ids)
self.assertIn(fixtures.API_TASK['id'], synced_task_ids)
patch.stop()
def get_return_value(self, at_object, fixture_list):
return fixture_utils.generate_objects(
at_object.title().replace('_', ''), fixture_list)