def test_filter_directing_department_null(self):
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
params = {'directing_department': 'null'}
result_ids = self._request_filter_signals(params)
self.assertEqual(1, len(result_ids))
def setUp(self):
self.signal_count = 5
self.created_at = timezone.now() - timezone.timedelta(days=1)
self.point_cityhall = Point(52.367640, 4.899527, srid=4326)
with freeze_time(self.created_at):
SignalFactory.create_batch(size=self.signal_count,
status__state=workflow.GEMELD)
def test_filter_kind_exclude_parent_signal(self):
"""
We expect only "normal" and "child" Signals
"""
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
parent_two = SignalFactory.create()
SignalFactory.create_batch(2, parent=parent_two)
params = {'kind': 'exclude_parent_signal'}
result_ids = self._request_filter_signals(params)
self.assertEqual(23, len(result_ids))
def test_filter_kind_child_signal(self):
"""
Filter Signals that are a child Signal (3 child Signals are created so we expect 3)
"""
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
parent_two = SignalFactory.create()
SignalFactory.create_batch(2, parent=parent_two)
params = {'kind': 'child_signal'}
result_ids = self._request_filter_signals(params)
self.assertEqual(3, len(result_ids))
def setUp(self):
now = timezone.now()
with (freeze_time(now)):
SignalFactory.create_batch(
5,
status__state=workflow.TE_VERZENDEN,
status__target_api=Status.TARGET_API_SIGMAX)
past = now - timedelta(hours=48)
with (freeze_time(past)):
SignalFactory.create_batch(
5,
status__state=workflow.TE_VERZENDEN,
status__target_api=Status.TARGET_API_SIGMAX)
def setUp(self):
self.signals = {
'SIG': SignalFactory.create_batch(5),
'REQ': SignalFactory.create_batch(3),
'QUE': SignalFactory.create_batch(1),
'COM': SignalFactory.create_batch(2),
'MAI': SignalFactory.create_batch(4),
}
hours = 1
for type_code in self.signals.keys():
with freeze_time(timezone.now() + timedelta(hours=hours)):
for signal in self.signals[type_code]:
TypeFactory.create(_signal=signal, name=type_code)
hours += 1
def test_filter_directing_department(self):
department = DepartmentFactory.create()
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
directing_departments = DirectingDepartments.objects.create(
_signal=parent_one, created_by='*****@*****.**')
directing_departments.departments.add(department)
parent_one.directing_departments_assignment = directing_departments
parent_one.save()
params = {'directing_department': department.code}
result_ids = self._request_filter_signals(params)
self.assertEqual(1, len(result_ids))
def test_filter_source_multiple_sources(self):
acc_signals = SignalFactory.create_batch(5, source='ACC')
result_ids = self._request_filter_signals({'source': 'online'})
self.assertEqual(len(self.signals), len(result_ids))
result_ids = self._request_filter_signals({'source': 'ACC'})
self.assertEqual(len(acc_signals), len(result_ids))
def test_anonymize_reporters_not_in_correct_state(self):
with freeze_time(timezone.now() - timezone.timedelta(days=1)):
SignalFactory.create_batch(5, status__state=BEHANDELING)
self.assertEqual(Reporter.objects.count(), 5)
anonymize_reporters(days=1)
self.assertEqual(Reporter.objects.count(), 5)
self.assertEqual(
Reporter.objects.filter(is_anonymized=True).count(), 0)
self.assertEqual(
Reporter.objects.filter(is_anonymized=False).count(), 5)
for reporter in Reporter.objects.all():
self.assertNotEqual(reporter.email, Reporter.ANONYMOUS_EMAIL)
self.assertNotEqual(reporter.phone, Reporter.ANONYMOUS_PHONE)
self.assertFalse(reporter.is_anonymized)
def test_anonymize_reporters_not_in_correct_state(self):
with freeze_time(timezone.now() - timezone.timedelta(days=1)):
SignalFactory.create_batch(5, status__state=BEHANDELING)
self.assertEqual(Reporter.objects.count(), 5)
anonymize_reporters(days=1)
self.assertEqual(Reporter.objects.count(), 5)
self.assertEqual(
Reporter.objects.filter(
Q(email_anonymized=True) | Q(phone_anonymized=True)).count(),
0)
self.assertEqual(
Reporter.objects.filter(email_anonymized=False,
phone_anonymized=False).count(), 5)
for reporter in Reporter.objects.all():
self.assertIsNotNone(reporter.email)
self.assertIsNotNone(reporter.phone)
self.assertFalse(reporter.email_anonymized)
self.assertFalse(reporter.phone_anonymized)
