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 test_send_mail_reporter_status_changed_afgehandeld(self):
# Prepare signal with status change from `BEHANDELING` to `AFGEHANDELD`.
StatusFactory.create(_signal=self.signal, state=workflow.BEHANDELING)
status = StatusFactory.create(_signal=self.signal, state=workflow.AFGEHANDELD)
self.signal.status = status
self.signal.save()
# Is the intended rule activated?
actions = self._get_mail_rules(['Send mail signal handled'])._get_actions(self.signal)
self.assertEqual(len(actions), 1)
# Is it the only one that activates?
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
activated = ma._get_actions(self.signal)
self.assertEqual(set(actions), set(activated))
# Check mail contents
ma.apply(signal_id=self.signal.id)
self.assertEqual(1, Feedback.objects.count())
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, f'Uw melding {self.signal.id}')
self.assertEqual(mail.outbox[0].to, [self.signal.reporter.email, ])
self.assertEqual(mail.outbox[0].from_email, settings.DEFAULT_FROM_EMAIL)
self.assertIn(settings.ORGANIZATION_NAME, mail.outbox[0].body)
# we want a history entry when a email was sent
self.assertEqual(Note.objects.count(), 1)
def test_signal_set_state_second_time_second_last_state_verzoek_tot_heropenen(
self):
"""
If the Signal status is set to AFGEHANDELD a second time and the previous state is VERZOEK_TOT_HEROPENEN the
action should not be triggered
"""
self.assertEqual(len(mail.outbox), 0)
signal = SignalFactory.create(status__state=workflow.GEMELD,
reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertTrue(self.action(signal, dry_run=False))
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(Note.objects.count(), 1)
self.assertTrue(Note.objects.filter(text=self.action.note).exists())
status = StatusFactory.create(_signal=signal,
state=workflow.VERZOEK_TOT_HEROPENEN)
signal.status = status
signal.save()
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertFalse(self.action(signal, dry_run=False))
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(Note.objects.count(), 1)
self.assertTrue(Note.objects.filter(text=self.action.note).exists())
def test_links_in_different_environments(self):
"""Test that generated feedback links contain the correct host."""
# Prepare signal with status change to `AFGEHANDELD`.
StatusFactory.create(_signal=self.signal, state=workflow.BEHANDELING)
status = StatusFactory.create(_signal=self.signal, state=workflow.AFGEHANDELD)
self.signal.status = status
self.signal.save()
# Check that generated emails contain the correct links for all
# configured environments:
env_fe_mapping = getattr(settings, 'FEEDBACK_ENV_FE_MAPPING', feedback_settings.FEEDBACK_ENV_FE_MAPPING)
self.assertEqual(len(env_fe_mapping), 3) # sanity check Amsterdam installation has three
for environment, fe_location in env_fe_mapping.items():
local_env = {'ENVIRONMENT': environment}
with mock.patch.dict('os.environ', local_env):
mail.outbox = []
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
ma.apply(signal_id=self.signal.id)
self.assertEqual(len(mail.outbox), 1)
message = mail.outbox[0]
self.assertIn(fe_location, message.body)
self.assertIn(fe_location, message.alternatives[0][0])
# we want a history entry when a email was sent
self.assertEqual(Note.objects.count(), len(env_fe_mapping))
def test_send_mail_reporter_status_changed_afgehandeld_no_email(self):
# Prepare signal with status change to `AFGEHANDELD`.
StatusFactory.create(_signal=self.signal_no_email,
state=workflow.BEHANDELING)
status = StatusFactory.create(_signal=self.signal_no_email,
state=workflow.AFGEHANDELD)
self.signal_no_email.status = status
self.signal_no_email.save()
self._apply_mail_actions(['Send mail signal handled'],
self.signal_no_email)
# no mail rule should activate
actions = self._get_mail_rules(['Send mail signal handled'
])._get_actions(self.signal_no_email)
self.assertEqual(len(actions), 0)
# Check mail contents
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
ma.apply(signal_id=self.signal_no_email.id)
self.assertEqual(0, Feedback.objects.count())
self.assertEqual(len(mail.outbox), 0)
# we want no history entry when no email was sent
self.assertEqual(Note.objects.count(), 0)
def test_links_in_different_environments_frontend_url_set(self):
"""Test that generated feedback links contain the correct host."""
# Prepare signal with status change to `AFGEHANDELD`.
StatusFactory.create(_signal=self.signal, state=workflow.BEHANDELING)
status = StatusFactory.create(_signal=self.signal,
state=workflow.AFGEHANDELD)
self.signal.status = status
self.signal.save()
test_frontend_urls = [
'https://acc.meldingen.amsterdam.nl',
'https://meldingen.amsterdam.nl',
'https://random.net',
]
for test_frontend_url in test_frontend_urls:
with override_settings(FRONTEND_URL=test_frontend_url):
mail.outbox = []
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
ma.apply(signal_id=self.signal.id)
self.assertEqual(len(mail.outbox), 1)
message = mail.outbox[0]
self.assertIn(test_frontend_url, message.body)
self.assertIn(test_frontend_url, message.alternatives[0][0])
# we want a history entry when a email was sent
self.assertEqual(Note.objects.count(), len(test_frontend_urls))
def test_optional_mail_GEANNULEERD(self):
# check normal signal
new_status = StatusFactory.create(_signal=self.signal,
state=workflow.GEANNULEERD,
send_email=False)
self.signal.status = new_status
self.signal.save()
rules = self._get_mail_rules(['Send mail optional'
])._get_actions(self.signal)
self.assertEqual(len(rules), 0)
new_status = StatusFactory.create(_signal=self.signal,
state=workflow.GEANNULEERD,
send_email=True)
self.signal.status = new_status
self.signal.save()
rules = self._get_mail_rules(['Send mail optional'
])._get_actions(self.signal)
self.assertEqual(len(rules), 1)
# ... not for child signal
new_status = StatusFactory.create(_signal=self.child_signal,
state=workflow.GEANNULEERD,
send_email=True)
self.child_signal.status = new_status
self.child_signal.save()
rules = self._get_mail_rules(['Send mail optional'
])._get_actions(self.child_signal)
self.assertEqual(len(rules), 0)
def test_send_mail_reporter_status_changed_afgehandeld_txt_and_html(self):
# Prepare signal with status change from `BEHANDELING` to `AFGEHANDELD`.
StatusFactory.create(_signal=self.signal, state=workflow.BEHANDELING)
status = StatusFactory.create(_signal=self.signal,
state=workflow.AFGEHANDELD)
self.signal.status = status
self.signal.save()
# Is the intended rule activated?
actions = self._get_mail_rules(['Send mail signal handled'
])._get_actions(self.signal)
self.assertEqual(len(actions), 1)
# Is it the only one that activates?
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
activated = ma._get_actions(self.signal)
self.assertEqual(set(actions), set(activated))
# Check mail contents
ma.apply(signal_id=self.signal.id)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(1, Feedback.objects.count())
feedback = Feedback.objects.get(_signal__id=self.signal.id)
message = mail.outbox[0]
self.assertEqual(message.subject,
f'Meer over uw melding {self.signal.id}')
self.assertEqual(message.to, [
self.signal.reporter.email,
])
self.assertEqual(mail.outbox[0].from_email,
settings.DEFAULT_FROM_EMAIL)
positive_feedback_url, negative_feedback_url = get_feedback_urls(
feedback)
context = {
'negative_feedback_url': negative_feedback_url,
'positive_feedback_url': positive_feedback_url,
'signal': self.signal,
'status': status,
'ORGANIZATION_NAME': settings.ORGANIZATION_NAME,
}
txt_message = loader.get_template(
'email/signal_status_changed_afgehandeld.txt').render(context)
html_message = loader.get_template(
'email/signal_status_changed_afgehandeld.html').render(context)
self.assertEqual(message.body, txt_message)
content, mime_type = message.alternatives[0]
self.assertEqual(mime_type, 'text/html')
self.assertEqual(content, html_message)
# we want a history entry when a email was sent
self.assertEqual(Note.objects.count(), 1)
def test_signal_set_state_second_time(self):
signal = SignalFactory.create(status__state=self.state,
reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal,
state=workflow.BEHANDELING)
signal.status = status
signal.save()
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertFalse(self.rule(signal))
def test_session_detail_reaction_requested(self):
questionnaire = QuestionnaireFactory.create(flow=Questionnaire.REACTION_REQUEST)
session = SessionFactory.create(questionnaire=questionnaire)
response = self.client.get(f'{self.base_endpoint}{session.uuid}')
self.assertEqual(response.status_code, 500)
self.assertEqual(response.json()['detail'], f'Session {session.uuid} is not associated with a Signal.')
signal = SignalFactory.create(status__state=GEMELD)
session._signal = signal
session.save()
response = self.client.get(f'{self.base_endpoint}{session.uuid}')
self.assertEqual(response.status_code, 500)
self.assertEqual(response.json()['detail'],
f'Session {session.uuid} is invalidated, associated signal not in state REACTIE_GEVRAAGD.')
status = StatusFactory(state=REACTIE_GEVRAAGD, _signal=signal)
signal.status = status
signal.save()
latest_session = SessionFactory.create(questionnaire=questionnaire, _signal=signal)
response = self.client.get(f'{self.base_endpoint}{session.uuid}')
self.assertEqual(response.status_code, 500)
self.assertEqual(response.json()['detail'],
f'Session {session.uuid} is invalidated, a newer reaction request was issued.')
response = self.client.get(f'{self.base_endpoint}{latest_session.uuid}')
self.assertEqual(response.status_code, 200)
def test_send_mail_reporter_created_only_once(self):
signal = SignalFactory.create(reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal, state=workflow.BEHANDELING)
signal.status = status
signal.save()
status = StatusFactory.create(_signal=signal, state=workflow.GEMELD)
signal.status = status
signal.save()
MailActions(mail_rules=SIGNAL_MAIL_RULES).apply(signal_id=signal.id, send_mail=True)
self.assertEqual(len(mail.outbox), 0)
# we want no history entry when no email was sent
self.assertEqual(Note.objects.count(), 0)
def test_send_mail_reporter_created(self, mocked_mail):
signal = SignalFactory.create()
signal.status = StatusFactory(_signal=signal, state=workflow.BEHANDELING)
signal.save()
tasks.send_mail_reporter(pk=signal.pk)
mocked_mail.assert_called_once_with(signal=signal.pk)
def test_statuses_not_allowed(self):
signal = SignalFactory.create(status__state=workflow.GEMELD,
reporter__email='*****@*****.**')
statuses = [
workflow.LEEG,
workflow.AFGEHANDELD,
workflow.GESPLITST,
workflow.HEROPEND,
workflow.INGEPLAND,
workflow.VERZOEK_TOT_HEROPENEN,
workflow.TE_VERZENDEN,
workflow.VERZONDEN,
workflow.VERZENDEN_MISLUKT,
workflow.AFGEHANDELD_EXTERN,
]
for state in statuses:
status = StatusFactory.create(_signal=signal,
state=state,
send_email=True)
signal.status = status
signal.save()
self.assertFalse(self.action(signal, dry_run=False))
def test_links_environment_env_var_not_set(self):
"""Deals with the case where nothing is overridden and `environment` not set."""
# Prepare signal with status change to `AFGEHANDELD`.
status = StatusFactory.create(_signal=self.signal, state=workflow.AFGEHANDELD)
self.signal.status = status
self.signal.save()
# Check that generated emails contain the correct links for all
# configured environments:
env_fe_mapping = feedback_settings.FEEDBACK_ENV_FE_MAPPING
self.assertEqual(len(env_fe_mapping), 1)
for environment, fe_location in env_fe_mapping.items():
with mock.patch.dict('os.environ', {}, clear=True):
mail.outbox = []
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
ma.apply(signal_id=self.signal.id)
self.assertEqual(len(mail.outbox), 1)
message = mail.outbox[0]
self.assertIn('http://dummy_link', message.body)
self.assertIn('http://dummy_link', message.alternatives[0][0])
# we want a history entry when a email was sent
self.assertEqual(Note.objects.count(), len(env_fe_mapping))
def test_apply_for_parent_signals(self):
status_text = FuzzyText(length=400)
parent_signal = SignalFactory.create(
status__state=self.prev_state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='*****@*****.**')
SignalFactory.create(status__state=self.state,
status__text=status_text,
reporter__email='*****@*****.**',
parent=parent_signal)
# create the new current state
status = StatusFactory.create(_signal=parent_signal, state=self.state)
parent_signal.status = status
parent_signal.save()
feedback = FeedbackFactory.create(
allows_contact=True,
_signal=parent_signal,
)
feedback.save()
self.assertTrue(self.rule(parent_signal))
def test_clean_up_reaction_request(self):
# Make sure that the Signals created in setUp() method do not affect
# this test:
status = StatusFactory.create(text='xyz',
state=workflow.BEHANDELING,
_signal=self.signal_reaction_requested)
self.signal_reaction_requested.status = status
self.signal_reaction_requested.save()
with freeze_time(now() -
timedelta(days=2 * REACTION_REQUEST_DAYS_OPEN)):
# Five signals that were in state REACTIE_GEVRAAGD and too old to
# still receive an update.
SignalFactory.create_batch(5,
status__state=workflow.REACTIE_GEVRAAGD)
with freeze_time(now() -
timedelta(days=REACTION_REQUEST_DAYS_OPEN // 2)):
# Five signals that were in state REACTIE_GEVRAAGD and may still
# get an update.
SignalFactory.create_batch(5,
status__state=workflow.REACTIE_GEVRAAGD)
self.assertEqual(Signal.objects.count(), 12)
n_updated = ReactionRequestService.clean_up_reaction_request()
self.assertEqual(n_updated, 5)
reactie_gevraagd = Signal.objects.filter(
status__state=workflow.REACTIE_GEVRAAGD)
reactie_ontvangen = Signal.objects.filter(
status__state=workflow.REACTIE_ONTVANGEN)
self.assertEqual(reactie_gevraagd.count(), 5)
self.assertEqual(reactie_ontvangen.count(), 5)
def test_get_session_reaction_request_flow_two_requests(self):
# A session for reaction request flow for a signal in a state other
# than REACTIE_GEVRAAGD should raise SessionInvalidated.
signal = SignalFactory.create(status__state=workflow.GEMELD)
session = SessionFactory.create(
_signal=signal, questionnaire__flow=Questionnaire.REACTION_REQUEST)
session_service = get_session_service(session.uuid)
with self.assertRaises(SessionInvalidated) as cm:
session_service.is_publicly_accessible()
self.assertIn('associated signal not in state REACTIE_GEVRAAGD',
str(cm.exception))
# A session for reaction request flow for a signal that also has a more
# recent session, should raise SessionInvalidated.
status = StatusFactory.create(state=workflow.REACTIE_GEVRAAGD)
signal.status = status
signal.save()
SessionFactory.create(
_signal=signal,
questionnaire__flow=Questionnaire.REACTION_REQUEST) # more recent
session_service.refresh_from_db()
with self.assertRaises(SessionInvalidated) as cm:
session_service.is_publicly_accessible()
self.assertIn('a newer reaction request was issued', str(cm.exception))
def test_only_send_feedback_negative_contact_mail(self):
"""
Test to see if when a status is changed from VERZOEK_TOT_AFHANDELING to AFGEHANDELD and has allows_contact on
the feedback to only send one email
"""
self.assertEqual(len(mail.outbox), 0)
signal = SignalFactory.create(
status__state=workflow.VERZOEK_TOT_AFHANDELING,
reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal,
state=workflow.AFGEHANDELD)
feedback = FeedbackFactory.create(
allows_contact=True,
_signal=signal,
)
feedback.save()
signal.status = status # change to new status AFGEHANDELD
signal.save()
self.assertTrue(MailService.status_mail(signal))
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject,
f'Meer over uw melding {signal.get_id_display()}')
self.assertEqual(mail.outbox[0].to, [
signal.reporter.email,
])
self.assertEqual(mail.outbox[0].from_email,
settings.DEFAULT_FROM_EMAIL)
self.assertEqual(Note.objects.count(), 1)
def test_get_session_reaction_request_flow(self):
# A session for reaction request flow with no associated Signal should
# raise an SessionInvalidated.
session_no_signal = SessionFactory.create(questionnaire__flow=Questionnaire.REACTION_REQUEST)
with self.assertRaises(SessionInvalidated):
QuestionnairesService.get_session(session_no_signal.uuid)
# A session for reaction request flow for a signal in a state other
# than REACTIE_GEVRAAGD should raise SessionInvalidated.
signal = SignalFactory.create()
session = SessionFactory.create(_signal=signal, questionnaire__flow=Questionnaire.REACTION_REQUEST)
with self.assertRaises(SessionInvalidated):
QuestionnairesService.get_session(session.uuid) # <-- !!! FAAL
# A session for reaction request flow for a signal that also has a more
# recent session, should raise SessionInvalidated.
status = StatusFactory.create(state=workflow.REACTIE_GEVRAAGD)
signal.status = status
signal.save()
SessionFactory.create(_signal=signal, questionnaire__flow=Questionnaire.REACTION_REQUEST) # more recent
with self.assertRaises(SessionInvalidated):
QuestionnairesService.get_session(session.uuid)
def test_triggered_on_update_status(self, patched_actions):
prev_status = self.signal.status
new_status = StatusFactory.create(_signal=self.signal, state=workflow.BEHANDELING)
self.signal.status = new_status
self.signal.save()
update_status.send_robust(sender=self.__class__, signal_obj=self.signal, status=new_status,
prev_status=prev_status)
def test_send_optional_mail_GEANNULEERD(self, patched_send_mail):
signal = self.signal
new_status = StatusFactory.create(_signal=signal, state=workflow.GEANNULEERD, send_email=True)
signal.status = new_status
signal.save()
self._get_mail_rules(['Send mail optional']).apply(signal_id=signal.pk, send_mail=True)
patched_send_mail.assert_called_once()
self.assertEqual(Note.objects.count(), 1)
def test_signal_set_state_second_time(self):
signal = SignalFactory.create(status__state=workflow.GEMELD,
reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertTrue(self.rule(signal))
status = StatusFactory.create(_signal=signal, state=workflow.HEROPEND)
signal.status = status
signal.save()
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertTrue(self.rule(signal))
def test_signal_set_state_multiple_times(self):
signal = SignalFactory.create(status__state=self.state,
reporter__email='*****@*****.**')
for x in range(5):
with freeze_time(timezone.now() + timedelta(hours=x)):
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertFalse(self.rule(signal))
def test_send_no_mail_reporter_status_changed_afgehandeld_after_verzoek_tot_heropenen(self):
# Prepare signal with status change from `VERZOEK_TOT_HEROPENEN` to `AFGEHANDELD`,
# this should not lead to an email being sent.
StatusFactory.create(_signal=self.signal, state=workflow.VERZOEK_TOT_HEROPENEN)
status = StatusFactory.create(_signal=self.signal, state=workflow.AFGEHANDELD)
self.signal.status = status
self.signal.save()
# no mail rule should activate
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
activated = ma._get_actions(self.signal)
self.assertEqual(len(activated), 0)
# Check mail contents
ma.apply(signal_id=self.signal.id)
self.assertEqual(0, Feedback.objects.count())
self.assertEqual(len(mail.outbox), 0)
# we want no history entry when no email was sent
self.assertEqual(Note.objects.count(), 0)
def test_signal_set_state_second_time_second_last_state_verzoek_tot_heropenen(
self):
signal = SignalFactory.create(status__state=workflow.GEMELD,
reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertTrue(self.rule(signal))
status = StatusFactory.create(_signal=signal,
state=workflow.VERZOEK_TOT_HEROPENEN)
signal.status = status
signal.save()
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertFalse(self.rule(signal))
def test_signals_reopen_requested_per_category_no_filter(self):
self.client.force_authenticate(user=self.superuser)
with freeze_time(timezone.now() - timezone.timedelta(weeks=3)):
SignalFactory.create_batch(
5,
status__state=GEMELD,
category_assignment__category=self.category_1)
SignalFactory.create_batch(
3,
status__state=BEHANDELING,
category_assignment__category=self.category_2)
with freeze_time(timezone.now() - timezone.timedelta(weeks=1)):
for signal in Signal.objects.all():
status = StatusFactory.create(_signal=signal,
state=VERZOEK_TOT_HEROPENEN)
signal.status = status
signal.save()
# Should not show up
SignalFactory.create_batch(
2,
status__state=AFGEHANDELD,
category_assignment__category=self.category_3)
self.assertEqual(Signal.objects.count(), 10)
response = self.client.get(
f'{self.base_endpoint}/signals/reopen-requested')
self.assertEqual(response.status_code, 200)
response_data = response.json()
self.assertEqual(response_data['total_signal_count'], 8)
self.assertEqual(len(response_data['results']), 2)
self.assertEqual(response_data['results'][0]['signal_count'], 5)
self.assertEqual(response_data['results'][0]['category']['name'],
self.category_1.name)
self.assertEqual(
len(response_data['results'][0]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][0]['category']['departments'])
self.assertEqual(response_data['results'][1]['signal_count'], 3)
self.assertEqual(response_data['results'][1]['category']['name'],
self.category_2.name)
self.assertEqual(
len(response_data['results'][1]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][1]['category']['departments'])
self.client.logout()
def test_signal_set_state_second_time(self):
"""
Check that if the status GEMELD is set for a second time the action is not triggered
"""
self.assertEqual(len(mail.outbox), 0)
signal = SignalFactory.create(status__state=self.state,
reporter__email='*****@*****.**')
status = StatusFactory.create(_signal=signal,
state=workflow.BEHANDELING)
signal.status = status
signal.save()
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertFalse(self.action(signal, dry_run=False))
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(Note.objects.count(), 0)
self.assertFalse(Note.objects.filter(text=self.action.note).exists())
def test_no_feedback(self):
status_text = FuzzyText(length=400)
# create signal in prev status
signal = SignalFactory.create(status__state=self.prev_state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='*****@*****.**')
# create the new current state
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
self.assertFalse(self.rule(signal))
def test_do_not_send_default_mail_template(self):
new_status = StatusFactory.create(_signal=self.signal, state=workflow.GEANNULEERD, send_email=False)
self.signal.status = new_status
self.signal.save()
actions = self._get_mail_rules(['Send mail optional'])._get_actions(self.signal)
self.assertEqual(len(actions), 0)
ma = MailActions(mail_rules=SIGNAL_MAIL_RULES)
activated = ma._get_actions(self.signal)
self.assertEqual(len(activated), 0)
# Check mail contents
ma.apply(signal_id=self.signal.id)
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(Note.objects.count(), 0)
def test_status_update_handler(self, mocked_tasks):
signal = SignalFactory.create()
prev_status = signal.status
new_status = StatusFactory.create(_signal=signal)
signal.status = new_status
signal.save()
update_status.send_robust(
sender=self.__class__,
signal_obj=signal,
status=new_status,
prev_status=prev_status,
)
mocked_tasks.push_to_sigmax.delay.assert_called_once_with(pk=signal.id)
