def setUp(self):
disconnect_signals()
# Create two separate timeslots
user = PersonUserFactory()
timeslot1 = TimeslotFactory(user=user)
MaximalTimeRecurrenceFactory(timeslot=timeslot1)
timeslot2 = TimeslotFactory(user=user)
MinimalTimeRecurrenceFactory(timeslot=timeslot2)
# Create a filter that matches your test incident
(_, _, argus_source) = get_or_create_default_instances()
filter_dict = {"sourceSystemIds": [argus_source.id], "tags": []}
filter_string = json.dumps(filter_dict)
filter = FilterFactory(user=user, filter_string=filter_string)
# Create two notification profiles that match this filter, but attached to each their timeslot
self.np1 = NotificationProfileFactory(user=user,
timeslot=timeslot1,
active=True)
self.np1.filters.add(filter)
self.np2 = NotificationProfileFactory(user=user,
timeslot=timeslot2,
active=True)
self.np2.filters.add(filter)
def setUp(self):
disconnect_signals()
# Create two separate timeslots
user = PersonUserFactory()
timeslot1 = factories.TimeslotFactory(user=user)
factories.MaximalTimeRecurrenceFactory(timeslot=timeslot1)
timeslot2 = factories.TimeslotFactory(user=user)
factories.MinimalTimeRecurrenceFactory(timeslot=timeslot2)
# Create a filter that matches your test incident
(_, _, argus_source) = get_or_create_default_instances()
filter_dict = {"sourceSystemIds": [argus_source.id], "tags": []}
filter_string = json.dumps(filter_dict)
filter = factories.FilterFactory(user=user,
filter_string=filter_string)
# Get user related destinations
destinations = user.destinations.all()
# Create two notification profiles that match this filter,
# but attached to different timeslots
self.np1 = factories.NotificationProfileFactory(user=user,
timeslot=timeslot1,
active=True)
self.np1.filters.add(filter)
self.np1.destinations.set(destinations)
self.np2 = factories.NotificationProfileFactory(user=user,
timeslot=timeslot2,
active=True)
self.np2.filters.add(filter)
self.np2.destinations.set(destinations)
def test_not_acked(self):
incident_acked = StatefulIncidentFactory()
user = PersonUserFactory()
# Create an expired ack
incident_acked.create_ack(user, expiration=self.timestamp)
result = Incident.objects.not_acked()
self.assertEqual(set(result), set(Incident.objects.all()))
def setUp(self):
if not "sms" in MEDIA_CLASSES_DICT.keys():
return
self.user = PersonUserFactory()
self.profile = NotificationProfileFactory(user=self.user)
self.destination = DestinationConfigFactory(
user=self.user,
media_id="sms",
settings={"phone_number": "+4747474746"},
)
self.profile.destinations.add(self.destination)
self.new_phone_number = PhoneNumber.from_string("+4747474747")
def setUp(self):
self.superuser1_password = "******"
self.superuser1 = AdminUserFactory(username="******",
password=self.superuser1_password)
self.normal_user1_password = "******"
self.normal_user1 = PersonUserFactory(
username="******", password=self.normal_user1_password)
self.superuser1_client = APIClient()
self.superuser1_token = Token.objects.create(user=self.superuser1)
self.superuser1_client.credentials(
**self.assemble_token_auth_kwarg(self.superuser1_token.key))
self.normal_user1_client = APIClient()
self.normal_user1_token = Token.objects.create(user=self.normal_user1)
self.normal_user1_client.credentials(
**self.assemble_token_auth_kwarg(self.normal_user1_token.key))
class SignalTests(APITestCase):
def setUp(self):
disconnect_signals()
self.user1 = PersonUserFactory()
self.user2 = PersonUserFactory(email="")
def teardown(self):
connect_signals()
def test_default_email_destination_should_be_created_if_user_has_email(
self):
default_destination = self.user1.destinations.first()
self.assertTrue(default_destination)
self.assertTrue(default_destination.settings["synced"])
def test_default_email_destination_should_not_be_created_if_user_has_no_email(
self):
self.assertFalse(self.user2.destinations.first())
def test_default_email_destination_should_be_added_if_email_is_added_to_user(
self):
self.user2.email = self.user2.username
self.user2.save(update_fields=["email"])
default_destination = self.user2.destinations.first()
self.assertTrue(default_destination)
self.assertTrue(default_destination.settings["synced"])
def test_default_email_destination_should_be_updated_if_user_email_changes(
self):
self.user2.email = "*****@*****.**"
self.user2.save(update_fields=["email"])
default_destination = self.user2.destinations.filter(
settings__synced=True).first()
self.assertEqual(self.user2.email,
default_destination.settings["email_address"])
def test_default_email_destination_should_be_deleted_if_user_email_is_deleted(
self):
self.user1.email = ""
self.user1.save(update_fields=["email"])
self.assertFalse(self.user1.destinations.filter(settings__synced=True))
def test_acked(self):
incident_acked = StatefulIncidentFactory()
user = PersonUserFactory()
incident_acked.create_ack(user)
result = Incident.objects.acked()
self.assertEqual(result.get(), incident_acked)
def setUp(self):
disconnect_signals()
self.user = PersonUserFactory()
def setUp(self):
disconnect_signals()
self.user = PersonUserFactory()
self.request_factory = APIRequestFactory()
def setUp(self):
disconnect_signals()
self.user1 = PersonUserFactory()
self.user2 = PersonUserFactory(email="")
def setUp(self):
self.user = PersonUserFactory()
# When creating a User which is a person, we also create a default Timeslot
self.default_timeslot = Timeslot.objects.get(user=self.user)
self.request_factory = APIRequestFactory()
def setUp(self):
self.user = PersonUserFactory()
self.request_factory = APIRequestFactory()