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_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_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 sync_objects(entity_type, fixture, sync_class):
created_objects = generate_objects(
entity_type, fixture
)
mocks.api_query_call(created_objects)
synchronizer = sync_class()
return synchronizer.sync()
def test_delete_stale_account(self):
account_qset = Account.objects.all()
self.assertEqual(account_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.AccountSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(account_qset.count(), 0)
def test_delete_stale_project(self):
project_qset = Project.objects.all()
self.assertGreater(project_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.ProjectSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(project_qset.count(), 0)
def test_delete_task_secondary_resource(self):
secondary_resources_qset = TaskSecondaryResource.objects.all()
self.assertEqual(secondary_resources_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.TaskSecondaryResourceSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(secondary_resources_qset.count(), 0)
def test_delete_allocation_code(self):
allocation_code_qset = AllocationCode.objects.all()
self.assertEqual(allocation_code_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.AllocationCodeSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(allocation_code_qset.count(), 0)
def test_delete_stale_phases(self):
"""
Local task should be deleted if not returned during a full sync
"""
qset = Phase.objects.all()
self.assertEqual(qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.PhaseSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(qset.count(), 0)
def test_delete_stale_departments(self):
"""
Local Departments should be deleted if not returned during a full sync
"""
department_id = fixtures.API_DEPARTMENT['id']
qs = Department.objects.filter(id=department_id)
self.assertEqual(qs.count(), 1)
mocks.api_query_call([])
synchronizer = sync.DepartmentSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(qs.count(), 0)
def test_delete_stale_ticket_notes(self):
"""
Local notes should be deleted if not returned during a full sync
"""
note_id = fixtures.API_TICKET_NOTE['id']
qs = TicketNote.objects.filter(id=note_id)
self.assertEqual(qs.count(), 1)
mocks.api_query_call([])
synchronizer = sync.TicketNoteSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(qs.count(), 0)
def test_delete_stale_tasks(self):
"""
Local task should be deleted if not returned during a full sync
"""
task_id = fixtures.API_TASK['id']
task_qset = Task.objects.filter(id=task_id)
self.assertEqual(task_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.TaskSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(task_qset.count(), 0)
def test_delete_stale_roles(self):
"""
Local Roles should be deleted if not returned during a full sync
"""
role_id = fixtures.API_ROLE['id']
qs = Role.objects.filter(id=role_id)
self.assertEqual(qs.count(), 1)
mocks.api_query_call([])
synchronizer = sync.RoleSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(qs.count(), 0)
def test_delete_stale_resources(self):
"""
Test that is removed if not fetched from the API during a
full sync.
"""
resource_qset = Resource.objects.all()
self.assertEqual(resource_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.ResourceSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(resource_qset.count(), 0)
def test_delete_stale_ticket_category(self):
"""
Test that ticket category is removed if not fetched from the API
during a full sync.
"""
ticket_category_qset = TicketCategory.objects.all()
self.assertEqual(ticket_category_qset.count(), 2)
mocks.api_query_call([])
synchronizer = sync.TicketCategorySynchronizer(full=True)
synchronizer.sync()
self.assertEqual(ticket_category_qset.count(), 0)
def test_delete_stale_tickets(self):
"""
Local ticket should be deleted if not returned during a full sync
"""
ticket_id = fixtures.API_TICKET['id']
ticket_qset = Ticket.objects.filter(id=ticket_id)
self.assertEqual(ticket_qset.count(), 1)
mocks.api_query_call([])
synchronizer = sync.TicketSynchronizer(full=True)
synchronizer.sync()
self.assertEqual(ticket_qset.count(), 0)
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)
