def notify(request: Request):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: notify")
# リクエストがSNSからであるかを検証する
use_case = ControlNotificationUseCase(log)
body_data = json.loads(request.body)
logger.info(body_data)
use_case.verify_sns_notification(body_data)
# SNSの種別ごとに分岐
sns_type = body_data.get("Type")
logger.info("Message Type is {}.".format(sns_type))
if sns_type == "Notification":
# 通知：アラームの内容に従って通知処理を実施する
alarm_message = json.loads(body_data["Message"])
use_case.notify(
NotificationDestinationModel.NotificationMessage(alarm_message))
elif sns_type == "SubscriptionConfirmation":
# 購読開始：SNSトピック登録時に初期検証を実施する
use_case.confirm_subscription(body_data)
elif sns_type == "UnsubscribeConfirmation":
# 購読解除：SNSトピック購読解除
logger.info("UnsubscribeConfirmation. {}".format(body_data["Message"]))
else:
# 存在しない種別
logger.warning("UnknownSnsMessageType.")
logger.warning(body_data)
logger.info("END: notify")
return Response(status=status.HTTP_200_OK)
def create(self, request, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
try:
with transaction.atomic():
# バリデーション
data_dest = request.data
data_dest["tenant"] = tenant_pk
dest_serializer = get_serializer(data_dest)
dest_serializer.is_valid(raise_exception=True)
# 作成
destination = ControlNotificationUseCase(
log).create_destination(request.user,
dest_serializer.save())
data = serialize_destination(destination)
except (TypeError, ValueError, TenantModel.DoesNotExist) as e:
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: create")
return Response(data=data, status=status.HTTP_201_CREATED)
def test_fetch_groups_user_role(self, mock_group):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = False
mock_tenant = mock.Mock()
with self.assertRaises(PermissionDenied):
ControlNotificationUseCase(mock.Mock()).fetch_groups(
mock_user, mock_tenant)
def test_notify(self):
mock_message = mock.Mock()
mock_group = mock.Mock()
mock_dest = mock.Mock()
mock_group.destinations.filter.return_value = [mock_dest]
mock_message.aws.notification_groups.filter.return_value = [mock_group]
ControlNotificationUseCase(mock.Mock()).notify(mock_message)
def test_verify_sns_notification_fail(self, mock_sns):
mock_sns.verify_notification.return_value = False
data = dict()
with self.assertRaises(InvalidNotificationException):
ControlNotificationUseCase(
mock.Mock()).verify_sns_notification(data)
mock_sns.verify_notification.assert_called_with(data)
def test_delete_group(self):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = True
mock_group = mock.Mock()
ControlNotificationUseCase(mock.Mock()).delete_group(
mock_user, mock_group)
mock_group.delete.assert_called_once()
def test_create_group(self):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = True
mock_group = mock.Mock()
res = ControlNotificationUseCase(mock.Mock()).save_group(
mock_user, mock_group)
mock_group.save.assert_called_once()
self.assertEqual(res, mock_group)
def test_create_destination_not_belong_to_tenant(self):
mock_user = mock.Mock()
mock_user.is_belong_to_tenant.return_value = False
mock_dest = mock.Mock()
with self.assertRaises(PermissionDenied):
ControlNotificationUseCase(mock.Mock()).create_destination(
mock_user, mock_dest)
mock_dest.save.assert_not_called()
def test_create_destination(self):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = True
mock_dest = mock.Mock()
res = ControlNotificationUseCase(mock.Mock()).create_destination(
mock_user, mock_dest)
self.assertEqual(res, mock_dest)
mock_dest.save.assert_called_once()
def test_delete_group_user_role(self):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = False
mock_group = mock.Mock()
with self.assertRaises(PermissionDenied):
ControlNotificationUseCase(mock.Mock()).delete_group(
mock_user, mock_group)
mock_group.delete.assert_not_called()
def test_fetch_destinations_user_role(self, mock_dest):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = False
mock_user.is_belong_to_tenant.return_value = False
with self.assertRaises(PermissionDenied):
ControlNotificationUseCase(mock.Mock()).fetch_destinations(
mock_user, mock.Mock())
mock_dest.assert_not_called()
def test_create_group_no_tenant(self):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = True
mock_user.is_belong_to_tenant.return_value = False
mock_group = mock.Mock()
with self.assertRaises(PermissionDenied):
ControlNotificationUseCase(mock.Mock()).save_group(
mock_user, mock_group)
mock_group.save.assert_not_called()
def test_fetch_groups(self, mock_group):
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = True
mock_tenant = mock.Mock()
mock_group1 = mock.Mock()
mock_group2 = mock.Mock()
mock_group3 = mock.Mock()
expected_value = [mock_group1, mock_group2, mock_group3]
objects_filter = mock_group.objects.filter
objects_filter.return_value = expected_value
res = ControlNotificationUseCase(mock.Mock()).fetch_groups(
mock_user, mock_tenant)
objects_filter.assert_called_once_with(tenant=mock_tenant)
self.assertEqual(res, expected_value)
def destroy(self, request, tenant_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: destroy")
try:
with transaction.atomic():
notification_group = NotificationGroupModel.objects.get(id=pk, tenant_id=tenant_pk)
ControlNotificationUseCase(log).delete_group(request.user, notification_group)
except (TypeError, ValueError, ObjectDoesNotExist) as e:
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: destroy")
return Response(status=status.HTTP_204_NO_CONTENT)
def list(self, request, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
try:
tenant = TenantModel.objects.get(id=tenant_pk)
groups = ControlNotificationUseCase(log).fetch_groups(request.user, tenant)
data = [NotificationGroupModelDetailSerializer(group).data for group in groups]
except (TypeError, ValueError, ObjectDoesNotExist) as e:
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: list")
return Response(data=data, status=status.HTTP_200_OK)
def test_fetch_destinations(self, mock_dest):
mock_dest1 = mock.Mock()
mock_dest2 = mock.Mock()
mock_dest3 = mock.Mock()
expected_value = [mock_dest1, mock_dest2, mock_dest3]
mock_tenant = mock.Mock()
value_filter = mock_dest.all.return_value.filter
value_filter.return_value = expected_value
mock_user = mock.Mock()
mock_user.can_control_notification.return_value = True
response = ControlNotificationUseCase(mock.Mock()).fetch_destinations(
mock_user, mock_tenant)
value_filter.assert_called_once_with(tenant=mock_tenant)
self.assertEqual(response, expected_value)
def create(self, request, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
try:
with transaction.atomic():
# バリデーション
data_group = request.data
data_group["tenant"] = tenant_pk
serializer = NotificationGroupModelSerializer(data=data_group)
serializer.is_valid(raise_exception=True)
data = ControlNotificationUseCase(log).save_group(request.user, serializer.save())
except (TypeError, ValueError, ObjectDoesNotExist) as e:
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: create")
return Response(data=NotificationGroupModelSerializer(data).data, status=status.HTTP_201_CREATED)
def update(self, request, tenant_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: update")
try:
with transaction.atomic():
# バリデーション
notification_group_model = NotificationGroupModel.objects.get(id=pk, tenant_id=tenant_pk)
serializer = NotificationGroupModelSerializer(
instance=notification_group_model,
data=request.data,
partial=True)
serializer.is_valid(raise_exception=True)
data = ControlNotificationUseCase(log).save_group(request.user, serializer.save())
except (TypeError, ValueError, ObjectDoesNotExist) as e:
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: update")
return Response(data=NotificationGroupModelSerializer(data).data, status=status.HTTP_200_OK)
def test_verify_sns_notification(self, mock_sns):
mock_sns.return_value.verify_notification.return_value = True
data = dict()
ControlNotificationUseCase(mock.Mock()).verify_sns_notification(data)
mock_sns.verify_notification.assert_called_with(data)
def test_confirm_subscription(self, mock_sns):
ControlNotificationUseCase(mock.Mock()).confirm_subscription(
dict(Token="token", TopicArn="topicarn"))
mock_sns.assert_called_with(arn="topicarn")
mock_sns.return_value.confirm_subscription.assert_called_with("token")
