def test_only_category_filter(self): """ unit test to only filter items with the category create 3 signals and only 2 signals with the category 'plastic_trash" """ cat1 = ParentCategoryFactory.create(name='trash') plastic = CategoryFactory.create(parent=cat1, public_name='plastic_trash', is_public_accessible=True) compost = CategoryFactory.create(parent=cat1, public_name='compost_trash', is_public_accessible=True) SignalFactoryValidLocation.create( category_assignment__category=plastic) SignalFactoryValidLocation.create( category_assignment__category=plastic) SignalFactoryValidLocation.create( category_assignment__category=compost) response = self.client.get( f'{self.geography_endpoint}/?bbox=4.700000,52.200000,5.000000,52.500000&' f'category_slug={plastic.slug}') data = response.json() self.assertEqual(2, len(data['features']))
def setUp(self): user_model = get_user_model() self.superuser, _ = user_model.objects.get_or_create( email='*****@*****.**', is_superuser=True, defaults={ 'first_name': 'John', 'last_name': 'Doe', 'is_staff': True }) self.department = DepartmentFactory.create() parent_category = ParentCategoryFactory.create() self.category_1 = CategoryFactory.create(parent=parent_category, departments=[self.department]) ServiceLevelObjectiveFactory.create(category=self.category_1, n_days=2, use_calendar_days=True) self.category_2 = CategoryFactory.create(parent=parent_category, departments=[self.department]) ServiceLevelObjectiveFactory.create(category=self.category_2, n_days=3, use_calendar_days=False) self.category_3 = CategoryFactory.create(parent=parent_category, departments=[self.department]) ServiceLevelObjectiveFactory.create(category=self.category_3, n_days=4, use_calendar_days=False)
def test_only_main_category_filter(self): """ unit test to only filter items with the main category create 5 signals and only 3 under the main category 'trash' that should be returned """ parent_cat = ParentCategoryFactory.create(name='trash') child_category = CategoryFactory.create(parent=parent_cat, public_name='', is_public_accessible=True) child_category_2 = CategoryFactory.create(parent=parent_cat, public_name='', is_public_accessible=True) SignalFactoryValidLocation.create( category_assignment__category=child_category) SignalFactoryValidLocation.create( category_assignment__category=child_category) SignalFactoryValidLocation.create( category_assignment__category=child_category_2) parent_cat_2 = ParentCategoryFactory.create(name='animal') child_animal = CategoryFactory.create(parent=parent_cat_2, public_name='', is_public_accessible=True) SignalFactoryValidLocation.create( category_assignment__category=child_animal) SignalFactoryValidLocation.create( category_assignment__category=child_animal) response = self.client.get( f'{self.geography_endpoint}/?bbox=4.700000,52.200000,5.000000,52.500000&' f'maincategory_slug={parent_cat.slug}') data = response.json() self.assertEqual(3, len(data['features']))
def setUp(self): self.test_parentcategory_overig = Category.objects.get( slug='overig', parent__isnull=True) self.test_subcategory_overig = Category.objects.get( parent=self.test_parentcategory_overig, slug='overig', parent__isnull=False) self.link_test_subcategory_overig = f'{self.test_host}/signals/v1/public/terms/categories/' \ f'{self.test_subcategory_overig.parent.slug}/sub_categories/' \ f'{self.test_subcategory_overig.slug,}' self.test_subcategory = CategoryFactory.create() self.link_test_subcategory = f'{self.test_host}/signals/v1/public/terms/categories/' \ f'{self.test_subcategory.parent.slug}/sub_categories/{self.test_subcategory.slug}' self.test_subcategory_translated = CategoryFactory.create( is_active=False) self.link_test_subcategory_translated = f'{self.test_host}/signals/v1/public/terms/categories/' \ f'{self.test_subcategory_translated.parent.slug}/sub_categories/' \ f'{self.test_subcategory_translated.slug}' self.link_test_subcategory_translation = CategoryTranslation.objects.create( old_category=self.test_subcategory_translated, new_category=self.test_subcategory, text='For testing purposes we translate this category', created_by='*****@*****.**', )
def setUp(self): SourceFactory.create(name='online', is_active=True) SourceFactory.create(name='Telefoon – ASC', is_active=True) self.main_category = ParentCategoryFactory.create(name='main', slug='main') self.link_main_category = '/signals/v1/public/terms/categories/main' self.sub_category_1 = CategoryFactory.create(name='sub1', slug='sub1', parent=self.main_category) self.link_sub_category_1 = f'{self.link_main_category}/sub_categories/sub1' self.sub_category_2 = CategoryFactory.create(name='sub2', slug='sub2', parent=self.main_category) self.link_sub_category_2 = f'{self.link_main_category}/sub_categories/sub2' self.sia_read_write_user.user_permissions.add( Permission.objects.get(codename='sia_can_view_all_categories')) self.client.force_authenticate(user=self.sia_read_write_user) self.initial_data_base = dict( text='Mensen in het cafe maken erg veel herrie', location=dict(geometrie=dict( type='point', coordinates=[4.90022563, 52.36768424])), category=dict(category_url=self.link_sub_category_1), reporter=dict(email='*****@*****.**'), incident_date_start=timezone.now().strftime('%Y-%m-%dT%H:%M'), source='Telefoon – ASC', ) self.retrieve_signal_schema = self.load_json_schema( os.path.join(THIS_DIR, 'json_schema', 'get_signals_v1_private_signals_{pk}.json'))
def test_make_email_context_for_category_with_or_without_public_name(self): # Check categories with public names. main_cat_with_public_name = ParentCategoryFactory.create( parent=None, name='PRIVATE_MAIN_I', public_name='PUBLIC_MAIN_I') sub_cat_with_public_name = CategoryFactory.create( parent=main_cat_with_public_name, name='PRIVATE_SUB', public_name='PUBLIC_SUB_I') signal_with_public_name = SignalFactory.create( category_assignment__category=sub_cat_with_public_name) context_with = make_email_context(signal=signal_with_public_name) self.assertEqual(context_with['main_category_public_name'], 'PUBLIC_MAIN_I') self.assertEqual(context_with['sub_category_public_name'], 'PUBLIC_SUB_I') # Check categories without public names. main_cat_no_public_name = ParentCategoryFactory.create( parent=None, name='PRIVATE_MAIN_II', public_name=None) sub_cat_no_public_name = CategoryFactory.create( parent=main_cat_no_public_name, name='PRIVATE_SUB_II', public_name=None) signal_no_public_name = SignalFactory.create( category_assignment__category=sub_cat_no_public_name) context_without = make_email_context(signal=signal_no_public_name) self.assertEqual(context_without['main_category_public_name'], 'PRIVATE_MAIN_II') self.assertEqual(context_without['sub_category_public_name'], 'PRIVATE_SUB_II')
def test_command_with_parameters(self): CategoryFactory.create() db_cnt = Signal.objects.count() out = StringIO() err = StringIO() call_command('dummy_signals', to_create=5, stdout=out, stderr=err) self.assertEqual(Signal.objects.count(), db_cnt + 5)
def setUp(self): email = '*****@*****.**' self.department_yes = DepartmentFactory.create(name='department_yes') self.department_no = DepartmentFactory.create(name='department_no') self.category_yes = CategoryFactory.create(departments=[self.department_yes]) self.category_no = CategoryFactory.create(departments=[self.department_no]) self.signal_yes = SignalFactory.create(category_assignment__category=self.category_yes, reporter__email=email) self.signal_no = SignalFactory.create(category_assignment__category=self.category_no, reporter__email=email) self.sia_read_write_user.profile.departments.add(self.department_yes)
def test_handling_message_in_history_is_constant(self): # SIG-3555 because history is not tracked for the Category model and its # handling_message. Changing the handling_message will also change the # history of every Signal that has that Category associated with. # This test demonstrates the problem. message_1 = 'MESSAGE 1' message_2 = 'MESSAGE 2' cat1 = CategoryFactory.create(name='cat1', handling_message=message_1) cat2 = CategoryFactory.create(name='cat2') signal = SignalFactoryValidLocation(category_assignment__category=cat1) self.sia_read_write_user.user_permissions.add( Permission.objects.get(codename='sia_can_view_all_categories')) self.client.force_authenticate(user=self.sia_read_write_user) # Retrieve signal history before changing the Category handling message. response = self.client.get( f'/signals/v1/private/signals/{signal.id}/history' + '?what=UPDATE_SLA') self.assertEqual(response.status_code, 200) response_json = response.json() self.assertEqual(len(response_json), 1) self.assertEqual(response_json[0]['description'], message_1) # Change handling message on category cat1.handling_message = message_2 cat1.save() cat1.refresh_from_db() # Assign different category and then the same again, check handling messages. Signal.actions.update_category_assignment({'category': cat2}, signal) signal.refresh_from_db() Signal.actions.update_category_assignment({'category': cat1}, signal) response = self.client.get( f'/signals/v1/private/signals/{signal.id}/history' + '?what=UPDATE_SLA') self.assertEqual(response.status_code, 200) response_json = response.json() self.assertEqual(len(response_json), 1) self.assertEqual(response_json[0]['description'], message_1) # check that the correct handling messages are stored: category_assignments = list( CategoryAssignment.objects.filter( _signal_id=signal.id).order_by('id')) self.assertEqual(category_assignments[0].stored_handling_message, message_1) self.assertEqual(category_assignments[2].stored_handling_message, message_2)
def setUp(self): # We use a category without no deadlines to create signals/complaints that # will have deadline set to None. test_cat = CategoryFactory.create(name='testcategory') with freeze_time(self.NOW - datetime.timedelta(days=4 * 7)): self.signal_late_open = SignalFactory.create( status__state=workflow.GEMELD, category_assignment__category=test_cat) self.signal_late_closed = SignalFactory.create( status__state=workflow.AFGEHANDELD, category_assignment__category=test_cat) # We now set a Service Level Objective for the category, so that we can # create some signals/complaints with a deadline set to some value other # than None. ServiceLevelObjectiveFactory.create( category=test_cat, n_days=5, use_calendar_days=False, ) with freeze_time(self.NOW - datetime.timedelta(hours=1)): self.signal_punctual_open = SignalFactory.create( status__state=workflow.GEMELD, category_assignment__category=test_cat) self.signal_punctual_closed = SignalFactory.create( status__state=workflow.AFGEHANDELD, category_assignment__category=test_cat)
def test_public_name_isset(self): """ An empty public_name (None) must fallback to the name """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create(parent=parent_category, public_name='test', is_public_accessible=True) SignalFactoryValidLocation.create( category_assignment__category=child_category) response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}&bbox=4.700000,52.200000,5.000000,52.500000' ) self.assertEqual(200, response.status_code) self.assertEqual(1, int(response.headers['X-Total-Count'])) data = response.json() self.assertEqual(1, len(data['features'])) self.assertEqual(child_category.public_name, data['features'][0]['properties']['category']['name']) self.assertNotEqual( child_category.name, data['features'][0]['properties']['category']['name'])
def test_lon_lat_parameters(self): """ Return the GEOJson containing all signals in the child category """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create( parent=parent_category, public_name='Public category for testing', is_public_accessible=True) signal = SignalFactoryValidLocation.create( category_assignment__category=child_category) lon = signal.location.geometrie.x lat = signal.location.geometrie.y response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}&lon={lon}&lat={lat}') self.assertEqual(200, response.status_code) self.assertEqual(1, int(response.headers['X-Total-Count'])) data = response.json() self.assertEqual(1, len(data['features'])) for feature in data['features']: self.assertEqual(feature['properties']['category']['name'], child_category.public_name)
def test_get_geojson(self): """ Return the GEOJson containing all signals in the child category """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create( parent=parent_category, public_name='Public category for testing', is_public_accessible=True) now = timezone.now() for x in range(5): with (freeze_time(now - timedelta(days=x))): SignalFactoryValidLocation.create( category_assignment__category=child_category) response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}&bbox=4.700000,52.200000,5.000000,52.500000' ) self.assertEqual(200, response.status_code) self.assertEqual(5, int(response.headers['X-Total-Count'])) data = response.json() self.assertEqual(5, len(data['features'])) for feature in data['features']: self.assertEqual(feature['properties']['category']['name'], child_category.public_name)
def setUp(self): with open(self.fixture_file, 'r') as f: self.create_initial_data = json.load(f) self.subcategory = CategoryFactory.create() self.link_test_cat_sub = '/signals/v1/public/terms/categories/{}/sub_categories/{}'.format( self.subcategory.parent.slug, self.subcategory.slug ) self.create_initial_data['category'] = {'sub_category': self.link_test_cat_sub} self.retrieve_schema = self.load_json_schema( os.path.join( THIS_DIR, 'json_schema', 'get_signals_v1_public_signals_{uuid}.json' ) ) self.create_schema = self.load_json_schema( os.path.join( THIS_DIR, 'json_schema', 'post_signals_v1_public_signals.json' ) ) self.create_attachment_schema = self.load_json_schema( os.path.join( THIS_DIR, 'json_schema', 'post_signals_v1_public_signals_attachment.json' ) )
def test_get_group_by(self): """ Return the GEOJson containing the first created_at in a BBOX grouped by a category """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create( parent=parent_category, public_name='Public category for testing', is_public_accessible=True) now = timezone.now() for x in range(5): with (freeze_time(now - timedelta(days=x))): # Should appear in the response SignalFactory.create( location__geometrie=Point(STADHUIS['lon'], STADHUIS['lat']), location__buurt_code=STADHUIS['buurt_code'], category_assignment__category=child_category) response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}&bbox=4.875759,52.360656,4.921221,52.37942' '&group_by=category') self.assertEqual(200, response.status_code) self.assertEqual(1, int(response.headers['X-Total-Count'])) data = response.json() self.assertEqual(1, len(data['features'])) self.assertEqual(data['features'][0]['properties']['category']['name'], child_category.public_name)
def setUp(self): self.parent_category = ParentCategoryFactory.create( name='PARENT-CATEGORY') self.child_category = CategoryFactory.create( name='CHILD-CATEGORY', parent=self.parent_category) self.signal = SignalFactoryWithImage.create( text='BLAH BLAH BLAH', incident_date_start=timezone.now(), category_assignment__category=self.child_category, reporter__email='*****@*****.**', reporter__phone='0612345678') StatusFactory.create(_signal=self.signal, state=workflow.AFWACHTING, text='waiting') StatusFactory.create(_signal=self.signal, state=workflow.ON_HOLD, text='please hold') status = StatusFactory.create(_signal=self.signal, state=workflow.AFGEHANDELD, text='Consider it done') self.signal.status = status self.signal.save() self.user = SuperUserFactory.create()
def setUp(self): self.test_parentcategory_overig = Category.objects.get(slug='overig', parent__isnull=True) self.test_subcategory_overig = Category.objects.get(parent=self.test_parentcategory_overig, slug='overig', parent__isnull=False) self.link_test_subcategory_overig = f'{self.test_host}/signals/v1/public/terms/categories/' \ f'{self.test_subcategory_overig.parent.slug}/sub_categories/' \ f'{self.test_subcategory_overig.slug,}' self.test_subcategory = CategoryFactory.create() self.link_test_subcategory = f'{self.test_host}/signals/v1/public/terms/categories/' \ f'{self.test_subcategory.parent.slug}/sub_categories/{self.test_subcategory.slug}'
def setUp(self): self.department_read = Permission.objects.get( codename='sia_department_read') self.department_write = Permission.objects.get( codename='sia_department_write') self.sia_read_write_user.user_permissions.add(self.department_read) self.sia_read_write_user.user_permissions.add(self.department_write) self.department = DepartmentFactory.create() self.maincategory = ParentCategoryFactory.create() self.subcategory = CategoryFactory.create(parent=self.maincategory)
def setUp(self): statusmessagetemplate_write_permission = Permission.objects.get( codename='sia_statusmessagetemplate_write') self.sia_read_write_user.user_permissions.add( statusmessagetemplate_write_permission) self.sia_read_write_user.save() self.client.force_authenticate(user=self.sia_read_write_user) self.subcategory = CategoryFactory.create() self.link_cat_sub_templates = '/signals/v1/private/terms/categories/{}/sub_categories/{}/status-message-templates'.format( # noqa self.subcategory.parent.slug, self.subcategory.slug) self.link_cat_parent_templates = '/signals/v1/private/terms/categories/{}/status-message-templates'.format( # noqa self.subcategory.parent.slug)
def test_missing_bbox_and_lonlat(self): """ Validate that when neither bbox or lon/lat is filled in to return a non_field_error """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create(parent=parent_category, is_public_accessible=False) response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}') data = response.json() self.assertEqual(400, response.status_code) self.assertIn('non_field_errors', data.keys()) self.assertEqual(1, len(data['non_field_errors'])) self.assertEqual('Either bbox or lon/lat must be filled in', data['non_field_errors'][0])
def test_missing_lon(self): """ Validate that both lat /lon parameters have to be filled in if lons parameter is missing """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create(parent=parent_category, is_public_accessible=False) response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}&lat=5') data = response.json() self.assertEqual(400, response.status_code) self.assertIn('non_field_errors', data.keys()) self.assertEqual(1, len(data['non_field_errors'])) self.assertEqual('Either bbox or lon/lat must be filled in', data['non_field_errors'][0])
def test_sub_category_detail_questionnaire(self): questionnaire = QuestionnaireFactory.create() parent_category = ParentCategoryFactory.create() sub_category = CategoryFactory.create(parent=parent_category, questionnaire=questionnaire) url = f'/signals/v1/public/terms/categories/{sub_category.parent.slug}/sub_categories/{sub_category.slug}' response = self.client.get(url) self.assertEqual(response.status_code, 200) data = response.json() # JSONSchema validation self.assertJsonSchema(self.retrieve_sub_category_schema, data) self.assertIsNotNone(data['_links']['sia:questionnaire']) self.assertEqual(data['questionnaire'], str(sub_category.questionnaire.uuid))
def test_filter_maincategory_and_category_slugs_not_a_unique_slug(self): parent_category = ParentCategoryFactory.create(name='not_unique') category = CategoryFactory.create(name='not_unique', parent=parent_category) SignalFactory.create(category_assignment__category=category) params = { 'maincategory_slug': [ parent_category.slug, ], 'category_slug': [ category.slug, ] } result_ids = self._request_filter_signals(params) self.assertEqual(1, len(result_ids))
def test_get_geojson_no_signals(self): """ Return an empty FeatureCollection because there are no signals at all """ parent_category = ParentCategoryFactory.create() child_category = CategoryFactory.create( parent=parent_category, public_name='Public category for testing', is_public_accessible=True) response = self.client.get( f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}' f'&category_slug={child_category.slug}&bbox=4.700000,52.200000,5.000000,52.500000' ) self.assertEqual(200, response.status_code) self.assertEqual(0, int(response.headers['X-Total-Count'])) data = response.json() self.assertIsNone(data['features'])
def setUp(self): self.department = DepartmentFactory.create() self.category = CategoryFactory.create(departments=[self.department]) self.signal = SignalFactory.create( category_assignment__category=self.category) self.attachment = ImageAttachmentFactory.create( _signal=self.signal, created_by='*****@*****.**') # Various Attachment delete permissions self.permission_delete_other = Permission.objects.get( codename='sia_delete_attachment_of_other_user') self.permission_delete_anonymous_user = Permission.objects.get( codename='sia_delete_attachment_of_anonymous_user') self.permission_delete_normal = Permission.objects.get( codename='sia_delete_attachment_of_normal_signal') self.permission_delete_parent = Permission.objects.get( codename='sia_delete_attachment_of_parent_signal') self.permission_delete_child = Permission.objects.get( codename='sia_delete_attachment_of_child_signal')
def test_child_category_public_name_and_is_public_accessible_true(self): """ Parent category has a public name and is_public_accessible set to False Child category has a public name and is_public_accessible set to True The is_public_accessible of the parent category should be True because there is at least one child category that has the is_public_accessible set to True. The is_public_accessible of the child category should be True in the response. """ parent_category = ParentCategoryFactory.create( public_name='Publieke naam hoofdcategorie', is_public_accessible=False) sub_category = CategoryFactory.create( parent=parent_category, public_name='Publieke naam kindcategorie', is_public_accessible=True) url = f'/signals/v1/public/terms/categories/{parent_category.slug}' response = self.client.get(url) self.assertEqual(response.status_code, 200) data = response.json() # JSONSchema validation self.assertJsonSchema(self.retrieve_category_schema, data) self.assertEqual(data['public_name'], parent_category.public_name) self.assertTrue(data['is_public_accessible']) self.assertEqual(data['sub_categories'][0]['public_name'], sub_category.public_name) self.assertTrue(data['sub_categories'][0]['is_public_accessible']) url = f'/signals/v1/public/terms/categories/{parent_category.slug}/sub_categories/{sub_category.slug}' response = self.client.get(url) self.assertEqual(response.status_code, 200) data = response.json() # JSONSchema validation self.assertJsonSchema(self.retrieve_sub_category_schema, data) self.assertEqual(data['public_name'], sub_category.public_name) self.assertTrue(data['is_public_accessible'])
def test_null_stored_handling_message(self): # SIG-3555 old complaints/Signals will have no stored handling messages on their associated CategoryAssignments. # This test fakes that by setting one category's handling message to null and checks that the correct # placeholder is returned. message_1 = None cat1 = CategoryFactory.create(name='cat1', handling_message=message_1) signal = SignalFactoryValidLocation(category_assignment__category=cat1) self.sia_read_write_user.user_permissions.add( Permission.objects.get(codename='sia_can_view_all_categories')) self.client.force_authenticate(user=self.sia_read_write_user) response = self.client.get( f'/signals/v1/private/signals/{signal.id}/history' + '?what=UPDATE_SLA') self.assertEqual(response.status_code, 200) response_json = response.json() self.assertEqual(response_json[0]['description'], EMPTY_HANDLING_MESSAGE_PLACEHOLDER_MESSAGE)
def test_category_assignment_model(self): """ CategoryAssignmentFactory.save() calls the deadline calculations, check that mechanism here. """ tzinfo = get_default_timezone() start = datetime(2021, 2, 19, 12, 0, 0, tzinfo=tzinfo) true_deadline = datetime(2021, 2, 22, 12, 0, 0, tzinfo=tzinfo) true_deadline_factor_3 = datetime(2021, 2, 24, 12, 0, 0, tzinfo=tzinfo) cat = CategoryFactory.create() ServiceLevelObjectiveFactory.create(n_days=1, use_calendar_days=False, category=cat) with freeze_time(start): cas = CategoryAssignmentFactory(category=cat) self.assertEqual(cas._signal.created_at, start) self.assertEqual(cas.deadline, true_deadline) self.assertEqual(cas.deadline_factor_3, true_deadline_factor_3) self.assertTrue(is_aware(cas.deadline)) self.assertTrue(is_aware(cas.deadline_factor_3))
def _create_signals(cls): """ Creates SIGNALS_DISTRIBUTE_DAYS_CNT signals. One per day backwards starting from yesterday current time. Creates SIGNALS_DISTRIBUTE_HOURS_CNT signals every hour backwards from now If today is Friday 16:00, and SIGNALS_DISTRIBUTE_DAYS_CNT and SIGNALS_DISTRIBUTE_HOURS_CNT are both set to 3, we will generate the following signals: - Per day: Thursday (yesterday) 16:00, Wednesday (day before yesterday) 16:00, Tuesday 16:00 - Per hour: Friday 16:00 (now), Friday 15:00 (now minus 1 hour), Friday 14:00 (now minus 2h) """ now = timezone.now() # Generate created/updated times for new signals. times = [now - timedelta(days=idx + 1) for idx in range(cls.SIGNALS_DISTRIBUTE_DAYS_CNT)] + \ [now - timedelta(hours=idx) for idx in range(cls.SIGNALS_DISTRIBUTE_HOURS_CNT)] cls.states = 3 * [BEHANDELING ] + 2 * [ON_HOLD] + (len(times) - 3 - 2) * [GEMELD] shuffle(cls.states) cls.sub_categories = [ CategoryFactory.create() for _ in range(cls.SUBCATEGORY_CNT) ] for idx, time in enumerate(times): with freeze_time(time): signal = SignalFactory.create() StatusFactory(_signal=signal, state=cls.states[idx]) category_assignment = CategoryAssignmentFactory( _signal=signal, category=cls.sub_categories[idx % len(cls.sub_categories)]) signal.category_assignment = category_assignment signal.save() cls.signals.append(signal)
def test_from_signal_and_category(self): """ Call into the deadline calculation service using Django ORM objects. """ tzinfo = get_default_timezone() start = datetime(2021, 2, 19, 12, 0, 0, tzinfo=tzinfo) true_deadline = datetime(2021, 2, 22, 12, 0, 0, tzinfo=tzinfo) true_deadline_factor_3 = datetime(2021, 2, 24, 12, 0, 0, tzinfo=tzinfo) cat = CategoryFactory.create() ServiceLevelObjectiveFactory.create(n_days=1, use_calendar_days=False, category=cat) with freeze_time(start): signal = SignalFactory(category_assignment__category=cat) deadline, deadline_factor_3 = DeadlineCalculationService.from_signal_and_category( signal, cat) self.assertEqual(deadline, true_deadline) self.assertEqual(deadline_factor_3, true_deadline_factor_3) self.assertTrue(is_aware(deadline)) self.assertTrue(is_aware(deadline_factor_3))