def test_missed_call_trigger(self):
self.login(self.admin)
flow = self.create_flow()
trigger_url = reverse("triggers.trigger_missed_call")
response = self.client.get(trigger_url)
self.assertEqual(response.status_code, 200)
response = self.client.post(trigger_url, {"flow": flow.id})
self.assertEqual(response.status_code, 200)
trigger = Trigger.objects.order_by("id").last()
self.assertEqual(trigger.trigger_type, Trigger.TYPE_MISSED_CALL)
self.assertEqual(trigger.flow, flow)
other_flow = Flow.copy(flow, self.admin)
response = self.client.post(
reverse("triggers.trigger_update", args=[trigger.id]),
{"flow": other_flow.id})
self.assertEqual(response.status_code, 302)
trigger.refresh_from_db()
self.assertEqual(trigger.flow, other_flow)
# create ten missed call triggers
for i in range(10):
response = self.client.get(trigger_url)
self.assertEqual(response.status_code, 200)
self.client.post(trigger_url, {"flow": flow.id})
self.assertEqual(Trigger.objects.all().count(), i + 2)
self.assertEqual(
Trigger.objects.filter(
is_archived=False,
trigger_type=Trigger.TYPE_MISSED_CALL).count(), 1)
# even unarchiving we only have one active trigger at a time
triggers = Trigger.objects.filter(
trigger_type=Trigger.TYPE_MISSED_CALL, is_archived=True)
active_trigger = Trigger.objects.get(
trigger_type=Trigger.TYPE_MISSED_CALL, is_archived=False)
response = self.client.post(reverse("triggers.trigger_archived"), {
"action": "restore",
"objects": [t.id for t in triggers]
})
self.assertEqual(response.status_code, 200)
self.assertEqual(
Trigger.objects.filter(
is_archived=False,
trigger_type=Trigger.TYPE_MISSED_CALL).count(), 1)
self.assertNotEqual(
active_trigger,
Trigger.objects.filter(is_archived=False,
trigger_type=Trigger.TYPE_MISSED_CALL)[0])
def test_catch_all_trigger(self):
self.login(self.admin)
catch_all_trigger = Trigger.get_triggers_of_type(self.org, Trigger.TYPE_CATCH_ALL).first()
flow = self.create_flow()
contact = self.create_contact("Ali", "250788739305")
# make our first message echo back the original message
action_set = ActionSet.objects.get(uuid=flow.entry_uuid)
actions = action_set.as_json()['actions']
actions[0]['msg']['base'] = 'Echo: @step.value'
action_set.set_actions_dict(actions)
action_set.save()
self.assertFalse(catch_all_trigger)
Msg.create_incoming(self.channel, contact.get_urn().urn, "Hi")
self.assertEquals(1, Msg.objects.all().count())
self.assertEquals(0, flow.runs.all().count())
trigger_url = reverse("triggers.trigger_catchall")
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
trigger = Trigger.objects.all().order_by('-pk')[0]
self.assertEquals(trigger.trigger_type, Trigger.TYPE_CATCH_ALL)
self.assertEquals(trigger.flow.pk, flow.pk)
catch_all_trigger = Trigger.get_triggers_of_type(self.org, Trigger.TYPE_CATCH_ALL).first()
self.assertEquals(catch_all_trigger.pk, trigger.pk)
incoming = Msg.create_incoming(self.channel, contact.get_urn().urn, "Hi")
self.assertEquals(1, flow.runs.all().count())
self.assertEquals(flow.runs.all()[0].contact.pk, contact.pk)
reply = Msg.objects.get(response_to=incoming)
self.assertEquals('Echo: Hi', reply.text)
other_flow = Flow.copy(flow, self.admin)
post_data = dict(flow=other_flow.pk)
self.client.post(reverse("triggers.trigger_update", args=[trigger.pk]), post_data)
trigger = Trigger.objects.get(pk=trigger.pk)
self.assertEquals(trigger.flow.pk, other_flow.pk)
# try to create another catch all trigger
response = self.client.post(trigger_url, post_data)
# shouldn't have succeeded as we already have a catch-all trigger
self.assertTrue(len(response.context['form'].errors))
# archive the previous one
trigger.is_archived = True
trigger.save()
old_catch_all = trigger
# try again
self.client.post(trigger_url, post_data)
# this time we are a go
new_catch_all = Trigger.objects.get(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL)
# now add a new trigger based on a group
group = self.create_group("Trigger Group", [])
post_data['groups'] = [group.pk]
response = self.client.post(trigger_url, post_data)
# should now have two catch all triggers
self.assertEquals(2, Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL).count())
group_catch_all = Trigger.objects.get(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL, groups=group)
# try to add another catchall trigger with a few different groups
group2 = self.create_group("Trigger Group 2", [])
post_data['groups'] = [group.pk, group2.pk]
response = self.client.post(trigger_url, post_data)
# should have failed
self.assertTrue(len(response.context['form'].errors))
post_data = dict()
post_data['action'] = 'restore'
post_data['objects'] = [old_catch_all.pk]
response = self.client.post(reverse("triggers.trigger_archived"), post_data)
old_catch_all.refresh_from_db()
new_catch_all.refresh_from_db()
# our new triggers should have been auto-archived, our old one is now active
self.assertEquals(2, Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL).count())
self.assertTrue(new_catch_all.is_archived)
self.assertFalse(old_catch_all.is_archived)
# ok, archive our old one too, leaving only our group specific trigger
old_catch_all.is_archived = True
old_catch_all.save()
# try a message again, this shouldn't cause anything since the contact isn't part of our group
FlowRun.objects.all().delete()
Msg.objects.all().delete()
incoming = Msg.create_incoming(self.channel, contact.get_urn().urn, "Hi")
self.assertEquals(0, FlowRun.objects.all().count())
self.assertFalse(Msg.objects.filter(response_to=incoming))
# now add the contact to the group
group.contacts.add(contact)
# this time should trigger the flow
incoming = Msg.create_incoming(self.channel, contact.get_urn().urn, "Hi")
self.assertEquals(1, FlowRun.objects.all().count())
self.assertEquals(other_flow.runs.all()[0].contact.pk, contact.pk)
reply = Msg.objects.get(response_to=incoming)
self.assertEquals('Echo: Hi', reply.text)
# delete the group
group.release()
# trigger should no longer be active
group_catch_all.refresh_from_db()
self.assertFalse(group_catch_all.is_active)
def test_missed_call_trigger(self):
self.login(self.admin)
missed_call_trigger = Trigger.get_triggers_of_type(self.org, Trigger.TYPE_MISSED_CALL).first()
flow = self.create_flow()
contact = self.create_contact("Ali", "250788739305")
self.assertFalse(missed_call_trigger)
ChannelEvent.create(self.channel, contact.get_urn(TEL_SCHEME).urn, ChannelEvent.TYPE_CALL_IN_MISSED, timezone.now(), 0)
self.assertEqual(ChannelEvent.objects.all().count(), 1)
self.assertEqual(flow.runs.all().count(), 0)
trigger_url = reverse("triggers.trigger_missed_call")
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
trigger = Trigger.objects.all().order_by('-pk')[0]
self.assertEquals(trigger.trigger_type, Trigger.TYPE_MISSED_CALL)
self.assertEquals(trigger.flow.pk, flow.pk)
missed_call_trigger = Trigger.get_triggers_of_type(self.org, Trigger.TYPE_MISSED_CALL).first()
self.assertEquals(missed_call_trigger.pk, trigger.pk)
ChannelEvent.create(self.channel, contact.get_urn(TEL_SCHEME).urn, ChannelEvent.TYPE_CALL_IN_MISSED, timezone.now(), 0)
self.assertEqual(ChannelEvent.objects.all().count(), 2)
self.assertEqual(flow.runs.all().count(), 1)
self.assertEqual(flow.runs.all()[0].contact.pk, contact.pk)
other_flow = Flow.copy(flow, self.admin)
post_data = dict(flow=other_flow.pk)
response = self.client.post(reverse("triggers.trigger_update", args=[trigger.pk]), post_data)
trigger = Trigger.objects.get(pk=trigger.pk)
self.assertEquals(trigger.flow.pk, other_flow.pk)
# create ten missed call triggers
for i in range(10):
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
self.assertEqual(i + 2, Trigger.objects.all().count())
self.assertEqual(1, Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_MISSED_CALL).count())
# even unarchiving we only have one acive trigger at a time
triggers = Trigger.objects.filter(trigger_type=Trigger.TYPE_MISSED_CALL, is_archived=True)
active_trigger = Trigger.objects.get(trigger_type=Trigger.TYPE_MISSED_CALL, is_archived=False)
post_data = dict()
post_data['action'] = 'restore'
post_data['objects'] = [t.pk for t in triggers]
response = self.client.post(reverse("triggers.trigger_archived"), post_data)
self.assertEquals(1, Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_MISSED_CALL).count())
self.assertFalse(active_trigger.pk == Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_MISSED_CALL)[0].pk)
def test_runs(self):
url = reverse('api.v2.runs')
self.assertEndpointAccess(url)
flow1 = self.create_flow(uuid_start=0)
flow2 = Flow.copy(flow1, self.user)
joe_run1, = flow1.start([], [self.joe])
frank_run1, = flow1.start([], [self.frank])
self.create_msg(direction='I', contact=self.joe, text="it is blue").handle()
self.create_msg(direction='I', contact=self.frank, text="Indigo").handle()
joe_run2, = flow1.start([], [self.joe], restart_participants=True)
frank_run2, = flow1.start([], [self.frank], restart_participants=True)
joe_run3, = flow2.start([], [self.joe], restart_participants=True)
# add a test contact run
Contact.set_simulation(True)
flow2.start([], [self.test_contact])
Contact.set_simulation(False)
# add a run for another org
flow3 = self.create_flow(org=self.org2, user=self.admin2, uuid_start=10000)
flow3.start([], [self.hans])
# refresh runs which will have been modified by being interrupted
joe_run1.refresh_from_db()
joe_run2.refresh_from_db()
frank_run1.refresh_from_db()
# no filtering
with self.assertNumQueries(NUM_BASE_REQUEST_QUERIES + 6):
response = self.fetchJSON(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json['next'], None)
self.assertResultsById(response, [joe_run3, frank_run2, frank_run1, joe_run2, joe_run1])
joe_run1_steps = list(joe_run1.steps.order_by('pk'))
frank_run2_steps = list(frank_run2.steps.order_by('pk'))
self.assertEqual(response.json['results'][1], {
'id': frank_run2.pk,
'flow': {'uuid': flow1.uuid, 'name': "Color Flow"},
'contact': {'uuid': self.frank.uuid, 'name': self.frank.name},
'responded': False,
'steps': [
{
'node': "00000000-00000000-00000000-00000001",
'arrived_on': format_datetime(frank_run2_steps[0].arrived_on),
'left_on': format_datetime(frank_run2_steps[0].left_on),
'text': "What is your favorite color?",
'value': None,
'category': None,
'type': 'actionset'
},
{
'node': "00000000-00000000-00000000-00000005",
'arrived_on': format_datetime(frank_run2_steps[1].arrived_on),
'left_on': None,
'text': None,
'value': None,
'category': None,
'type': 'ruleset'
}
],
'created_on': format_datetime(frank_run2.created_on),
'modified_on': format_datetime(frank_run2.modified_on),
'exited_on': None,
'exit_type': None
})
self.assertEqual(response.json['results'][4], {
'id': joe_run1.pk,
'flow': {'uuid': flow1.uuid, 'name': "Color Flow"},
'contact': {'uuid': self.joe.uuid, 'name': self.joe.name},
'responded': True,
'steps': [
{
'node': "00000000-00000000-00000000-00000001",
'arrived_on': format_datetime(joe_run1_steps[0].arrived_on),
'left_on': format_datetime(joe_run1_steps[0].left_on),
'text': "What is your favorite color?",
'value': None,
'category': None,
'type': 'actionset'
},
{
'node': "00000000-00000000-00000000-00000005",
'arrived_on': format_datetime(joe_run1_steps[1].arrived_on),
'left_on': format_datetime(joe_run1_steps[1].left_on),
'text': 'it is blue',
'value': 'blue',
'category': "Blue",
'type': 'ruleset'
},
{
'node': "00000000-00000000-00000000-00000003",
'arrived_on': format_datetime(joe_run1_steps[2].arrived_on),
'left_on': format_datetime(joe_run1_steps[2].left_on),
'text': 'Blue is sad. :(',
'value': None,
'category': None,
'type': 'actionset'
}
],
'created_on': format_datetime(joe_run1.created_on),
'modified_on': format_datetime(joe_run1.modified_on),
'exited_on': format_datetime(joe_run1.exited_on),
'exit_type': 'completed'
})
# filter by id
response = self.fetchJSON(url, 'id=%d' % frank_run2.pk)
self.assertResultsById(response, [frank_run2])
# filter by flow
response = self.fetchJSON(url, 'flow=%s' % flow1.uuid)
self.assertResultsById(response, [frank_run2, frank_run1, joe_run2, joe_run1])
# doesn't work if flow is inactive
flow1.is_active = False
flow1.save()
response = self.fetchJSON(url, 'flow=%s' % flow1.uuid)
self.assertResultsById(response, [])
# restore to active
flow1.is_active = True
flow1.save()
# filter by invalid flow
response = self.fetchJSON(url, 'flow=invalid')
self.assertResultsById(response, [])
# filter by flow + responded
response = self.fetchJSON(url, 'flow=%s&responded=TrUe' % flow1.uuid)
self.assertResultsById(response, [frank_run1, joe_run1])
# filter by contact
response = self.fetchJSON(url, 'contact=%s' % self.joe.uuid)
self.assertResultsById(response, [joe_run3, joe_run2, joe_run1])
# filter by invalid contact
response = self.fetchJSON(url, 'contact=invalid')
self.assertResultsById(response, [])
# filter by contact + responded
response = self.fetchJSON(url, 'contact=%s&responded=yes' % self.joe.uuid)
self.assertResultsById(response, [joe_run1])
# filter by after
response = self.fetchJSON(url, 'after=%s' % format_datetime(frank_run1.modified_on))
self.assertResultsById(response, [joe_run3, frank_run2, frank_run1])
# filter by before
response = self.fetchJSON(url, 'before=%s' % format_datetime(frank_run1.modified_on))
self.assertResultsById(response, [frank_run1, joe_run2, joe_run1])
# filter by invalid before
response = self.fetchJSON(url, 'before=longago')
self.assertResultsById(response, [])
# filter by invalid after
response = self.fetchJSON(url, 'before=%s&after=thefuture' % format_datetime(frank_run1.modified_on))
self.assertResultsById(response, [])
# can't filter by both contact and flow together
response = self.fetchJSON(url, 'contact=%s&flow=%s' % (self.joe.uuid, flow1.uuid))
self.assertResponseError(response, None,
"You may only specify one of the contact, flow parameters")
def test_catch_all_trigger(self):
self.login(self.admin)
catch_all_trigger = Trigger.get_triggers_of_type(self.org, CATCH_ALL_TRIGGER).first()
flow = self.create_flow()
contact = self.create_contact("Ali", "250788739305")
# make our first message echo back the original message
action_set = ActionSet.objects.get(uuid=flow.entry_uuid)
actions = action_set.as_json()['actions']
actions[0]['msg'] = 'Echo: @step.value'
action_set.set_actions_dict(actions)
action_set.save()
self.assertFalse(catch_all_trigger)
Msg.create_incoming(self.channel, (TEL_SCHEME, contact.get_urn().path), "Hi")
self.assertEquals(1, Msg.objects.all().count())
self.assertEquals(0, flow.runs.all().count())
trigger_url = reverse("triggers.trigger_catchall")
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
trigger = Trigger.objects.all().order_by('-pk')[0]
self.assertEquals(trigger.trigger_type, CATCH_ALL_TRIGGER)
self.assertEquals(trigger.flow.pk, flow.pk)
catch_all_trigger = Trigger.get_triggers_of_type(self.org, CATCH_ALL_TRIGGER).first()
self.assertEquals(catch_all_trigger.pk, trigger.pk)
incoming = Msg.create_incoming(self.channel, (TEL_SCHEME, contact.get_urn().path), "Hi")
self.assertEquals(1, flow.runs.all().count())
self.assertEquals(flow.runs.all()[0].contact.pk, contact.pk)
reply = Msg.objects.get(response_to=incoming)
self.assertEquals('Echo: Hi', reply.text)
other_flow = Flow.copy(flow, self.admin)
post_data = dict(flow=other_flow.pk)
response = self.client.post(reverse("triggers.trigger_update", args=[trigger.pk]), post_data)
trigger = Trigger.objects.get(pk=trigger.pk)
self.assertEquals(trigger.flow.pk, other_flow.pk)
# create a bunch of catch all triggers
for i in range(3):
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
self.assertEquals(i+2, Trigger.objects.all().count())
self.assertEquals(1, Trigger.objects.filter(is_archived=False, trigger_type=CATCH_ALL_TRIGGER).count())
# even unarchiving we only have one acive trigger at a time
triggers = Trigger.objects.filter(trigger_type=CATCH_ALL_TRIGGER, is_archived=True)
active_trigger = Trigger.objects.get(trigger_type=CATCH_ALL_TRIGGER, is_archived=False)
post_data = dict()
post_data['action'] = 'restore'
post_data['objects'] = [_.pk for _ in triggers]
response = self.client.post(reverse("triggers.trigger_archived"), post_data)
self.assertEquals(1, Trigger.objects.filter(is_archived=False, trigger_type=CATCH_ALL_TRIGGER).count())
self.assertFalse(active_trigger.pk == Trigger.objects.filter(is_archived=False, trigger_type=CATCH_ALL_TRIGGER)[0].pk)
def test_missed_call_trigger(self):
self.login(self.admin)
missed_call_trigger = Trigger.get_triggers_of_type(self.org, MISSED_CALL_TRIGGER).first()
flow = self.create_flow()
contact = self.create_contact("Ali", "250788739305")
self.assertFalse(missed_call_trigger)
Call.create_call(self.channel, contact.get_urn(TEL_SCHEME).path, timezone.now(), 0, CALL_IN_MISSED)
self.assertEquals(1, Call.objects.all().count())
self.assertEquals(0, flow.runs.all().count())
trigger_url = reverse("triggers.trigger_missed_call")
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
trigger = Trigger.objects.all().order_by('-pk')[0]
self.assertEquals(trigger.trigger_type, MISSED_CALL_TRIGGER)
self.assertEquals(trigger.flow.pk, flow.pk)
missed_call_trigger = Trigger.get_triggers_of_type(self.org, MISSED_CALL_TRIGGER).first()
self.assertEquals(missed_call_trigger.pk, trigger.pk)
Call.create_call(self.channel, contact.get_urn(TEL_SCHEME).path, timezone.now(), 0, CALL_IN_MISSED)
self.assertEquals(2, Call.objects.all().count())
self.assertEquals(1, flow.runs.all().count())
self.assertEquals(flow.runs.all()[0].contact.pk, contact.pk)
other_flow = Flow.copy(flow, self.admin)
post_data = dict(flow=other_flow.pk)
response = self.client.post(reverse("triggers.trigger_update", args=[trigger.pk]), post_data)
trigger = Trigger.objects.get(pk=trigger.pk)
self.assertEquals(trigger.flow.pk, other_flow.pk)
# create ten missed call triggers
for i in range(10):
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
self.assertEquals(i+2, Trigger.objects.all().count())
self.assertEquals(1, Trigger.objects.filter(is_archived=False, trigger_type=MISSED_CALL_TRIGGER).count())
# even unarchiving we only have one acive trigger at a time
triggers = Trigger.objects.filter(trigger_type=MISSED_CALL_TRIGGER, is_archived=True)
active_trigger = Trigger.objects.get(trigger_type=MISSED_CALL_TRIGGER, is_archived=False)
post_data = dict()
post_data['action'] = 'restore'
post_data['objects'] = [_.pk for _ in triggers]
response = self.client.post(reverse("triggers.trigger_archived"), post_data)
self.assertEquals(1, Trigger.objects.filter(is_archived=False, trigger_type=MISSED_CALL_TRIGGER).count())
self.assertFalse(active_trigger.pk == Trigger.objects.filter(is_archived=False, trigger_type=MISSED_CALL_TRIGGER)[0].pk)
def test_catch_all_trigger(self):
self.login(self.admin)
catch_all_trigger = Trigger.get_triggers_of_type(self.org, Trigger.TYPE_CATCH_ALL).first()
flow = self.create_flow()
contact = self.create_contact("Ali", "250788739305")
# make our first message echo back the original message
action_set = ActionSet.objects.get(uuid=flow.entry_uuid)
actions = action_set.as_json()['actions']
actions[0]['msg']['base'] = 'Echo: @step.value'
action_set.set_actions_dict(actions)
action_set.save()
self.assertFalse(catch_all_trigger)
Msg.create_incoming(self.channel, (TEL_SCHEME, contact.get_urn().path), "Hi")
self.assertEquals(1, Msg.all_messages.all().count())
self.assertEquals(0, flow.runs.all().count())
trigger_url = reverse("triggers.trigger_catchall")
response = self.client.get(trigger_url)
self.assertEquals(response.status_code, 200)
post_data = dict(flow=flow.pk)
response = self.client.post(trigger_url, post_data)
trigger = Trigger.objects.all().order_by('-pk')[0]
self.assertEquals(trigger.trigger_type, Trigger.TYPE_CATCH_ALL)
self.assertEquals(trigger.flow.pk, flow.pk)
catch_all_trigger = Trigger.get_triggers_of_type(self.org, Trigger.TYPE_CATCH_ALL).first()
self.assertEquals(catch_all_trigger.pk, trigger.pk)
incoming = Msg.create_incoming(self.channel, (TEL_SCHEME, contact.get_urn().path), "Hi")
self.assertEquals(1, flow.runs.all().count())
self.assertEquals(flow.runs.all()[0].contact.pk, contact.pk)
reply = Msg.all_messages.get(response_to=incoming)
self.assertEquals('Echo: Hi', reply.text)
other_flow = Flow.copy(flow, self.admin)
post_data = dict(flow=other_flow.pk)
self.client.post(reverse("triggers.trigger_update", args=[trigger.pk]), post_data)
trigger = Trigger.objects.get(pk=trigger.pk)
self.assertEquals(trigger.flow.pk, other_flow.pk)
# try to create another catch all trigger
response = self.client.post(trigger_url, post_data)
# shouldn't have succeeded as we already have a catch-all trigger
self.assertTrue(len(response.context['form'].errors))
# archive the previous one
trigger.is_archived = True
trigger.save()
old_catch_all = trigger
# try again
self.client.post(trigger_url, post_data)
# this time we are a go
new_catch_all = Trigger.objects.get(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL)
# now add a new trigger based on a group
group = self.create_group("Trigger Group", [])
post_data['groups'] = [group.pk]
response = self.client.post(trigger_url, post_data)
# should now have two catch all triggers
self.assertEquals(2, Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL).count())
group_catch_all = Trigger.objects.get(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL, groups=group)
# try to add another catchall trigger with a few different groups
group2 = self.create_group("Trigger Group 2", [])
post_data['groups'] = [group.pk, group2.pk]
response = self.client.post(trigger_url, post_data)
# should have failed
self.assertTrue(len(response.context['form'].errors))
post_data = dict()
post_data['action'] = 'restore'
post_data['objects'] = [old_catch_all.pk]
response = self.client.post(reverse("triggers.trigger_archived"), post_data)
old_catch_all.refresh_from_db()
new_catch_all.refresh_from_db()
# our new triggers should have been auto-archived, our old one is now active
self.assertEquals(2, Trigger.objects.filter(is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL).count())
self.assertTrue(new_catch_all.is_archived)
self.assertFalse(old_catch_all.is_archived)
# ok, archive our old one too, leaving only our group specific trigger
old_catch_all.is_archived = True
old_catch_all.save()
# try a message again, this shouldn't cause anything since the contact isn't part of our group
FlowRun.objects.all().delete()
Msg.all_messages.all().delete()
incoming = Msg.create_incoming(self.channel, (TEL_SCHEME, contact.get_urn().path), "Hi")
self.assertEquals(0, FlowRun.objects.all().count())
self.assertFalse(Msg.all_messages.filter(response_to=incoming))
# now add the contact to the group
group.contacts.add(contact)
# this time should trigger the flow
incoming = Msg.create_incoming(self.channel, (TEL_SCHEME, contact.get_urn().path), "Hi")
self.assertEquals(1, FlowRun.objects.all().count())
self.assertEquals(other_flow.runs.all()[0].contact.pk, contact.pk)
reply = Msg.all_messages.get(response_to=incoming)
self.assertEquals('Echo: Hi', reply.text)
# delete the group
group.release()
# trigger should no longer be active
group_catch_all.refresh_from_db()
self.assertFalse(group_catch_all.is_active)
def test_catch_all_trigger(self):
self.login(self.admin)
flow = self.get_flow("color")
trigger_url = reverse("triggers.trigger_catchall")
response = self.client.get(trigger_url)
self.assertEqual(response.status_code, 200)
self.client.post(trigger_url, {"flow": flow.id})
trigger = Trigger.objects.order_by("id").last()
self.assertEqual(trigger.trigger_type, Trigger.TYPE_CATCH_ALL)
self.assertEqual(trigger.flow, flow)
# update trigger to point to different flow
other_flow = Flow.copy(flow, self.admin)
self.client.post(reverse("triggers.trigger_update", args=[trigger.pk]),
{"flow": other_flow.id})
trigger.refresh_from_db()
self.assertEqual(trigger.flow, other_flow)
# try to create another catch all trigger
response = self.client.post(trigger_url, {"flow": other_flow.id})
# shouldn't have succeeded as we already have a catch-all trigger
self.assertTrue(len(response.context["form"].errors))
# archive the previous one
old_catch_all = trigger
trigger.is_archived = True
trigger.save(update_fields=("is_archived", ))
# try again
self.client.post(trigger_url, {"flow": other_flow.id})
# this time we are a go
new_catch_all = Trigger.objects.get(
is_archived=False, trigger_type=Trigger.TYPE_CATCH_ALL)
# now add a new trigger based on a group
group = self.create_group("Trigger Group", [])
self.client.post(trigger_url, {
"flow": other_flow.id,
"groups": group.id
})
# should now have two catch all triggers
self.assertEqual(
2,
Trigger.objects.filter(
is_archived=False,
trigger_type=Trigger.TYPE_CATCH_ALL).count())
group_catch_all = Trigger.objects.get(
is_archived=False,
trigger_type=Trigger.TYPE_CATCH_ALL,
groups=group)
# try to add another catchall trigger with a few different groups
group2 = self.create_group("Trigger Group 2", [])
response = self.client.post(trigger_url, {
"flow": other_flow.id,
"groups": [group.id, group2.id]
})
# should have failed
self.assertTrue(len(response.context["form"].errors))
self.client.post(reverse("triggers.trigger_archived"), {
"action": "restore",
"objects": [old_catch_all.id]
})
old_catch_all.refresh_from_db()
new_catch_all.refresh_from_db()
# our new triggers should have been auto-archived, our old one is now active
self.assertEqual(
Trigger.objects.filter(
is_archived=False,
trigger_type=Trigger.TYPE_CATCH_ALL).count(), 2)
self.assertTrue(new_catch_all.is_archived)
self.assertFalse(old_catch_all.is_archived)
# ok, archive our old one too, leaving only our group specific trigger
old_catch_all.is_archived = True
old_catch_all.save(update_fields=("is_archived", ))
# delete a group attached to a trigger
group.release()
# trigger should no longer be active
group_catch_all.refresh_from_db()
self.assertFalse(group_catch_all.is_active)
