class GetSupportedFunctionsTest(TestCase):
mock_client = Mock()
mock_paginate = MagicMock()
mock_paginate.paginate = MagicMock(return_value=[
{
"Functions": [
{
"FunctionName": "lambdaA",
"Runtime": "nodejs12.x"
},
{
"FunctionName": "lambdaB",
"Runtime": "nodejs10.x"
},
]
},
{
"Functions": [
{
"FunctionName": "lambdaC",
"Runtime": "nodejs12.x"
},
{
"FunctionName": "lambdaD",
"Runtime": "python3.6"
},
{
"FunctionName": "lambdaE",
"Runtime": "nodejs14.x"
},
]
},
])
mock_client.get_paginator = MagicMock(return_value=mock_paginate)
assert get_supported_functions(mock_client) == [
{
"FunctionName": "lambdaA",
"Runtime": "nodejs12.x"
},
{
"FunctionName": "lambdaB",
"Runtime": "nodejs10.x"
},
{
"FunctionName": "lambdaC",
"Runtime": "nodejs12.x"
},
{
"FunctionName": "lambdaD",
"Runtime": "python3.6"
},
{
"FunctionName": "lambdaE",
"Runtime": "nodejs14.x"
},
]
mock_client.get_paginator.assert_called_once_with("list_functions")
def test_disable_python(self, mock_gen_aws_client,
mock_get_serialized_lambda_function):
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.get_function = MagicMock(
return_value={
"Configuration": {
"FunctionName":
"lambdaF",
"Runtime":
"python3.6",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaF",
"Handler":
"sentry_sdk.integrations.init_serverless_sdk.sentry_lambda_handler",
"Layers": [
{
"Arn":
"arn:aws:lambda:us-east-2:1234:layer:something-else:2"
},
{
"Arn":
"arn:aws:lambda:us-east-2:1234:layer:my-python-layer:34"
},
],
"Environment": {
"Variables": {
"SENTRY_INITIAL_HANDLER":
"lambda_handler.test_handler",
"SENTRY_DSN": self.sentry_dsn,
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
"OTHER": "hi",
}
},
},
})
mock_client.update_function_configuration = MagicMock()
return_value = {
"name": "lambdaF",
"runtime": "python3.6",
"version": -1,
"outOfDate": False,
"enabled": False,
}
mock_get_serialized_lambda_function.return_value = return_value
assert self.get_response(action="disable",
target="lambdaF").data == return_value
mock_client.get_function.assert_called_with(FunctionName="lambdaF")
mock_client.update_function_configuration.assert_called_with(
FunctionName="lambdaF",
Layers=["arn:aws:lambda:us-east-2:1234:layer:something-else:2"],
Environment={"Variables": {
"OTHER": "hi"
}},
Handler="lambda_handler.test_handler",
)
def test_update_version(self, mock_gen_aws_client,
mock_get_serialized_lambda_function):
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.get_function = MagicMock(
return_value={
"Configuration": {
"FunctionName":
"lambdaD",
"Runtime":
"nodejs10.x",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaD",
"Layers": [
{
"Arn":
"arn:aws:lambda:us-east-2:1234:layer:something-else:2"
},
{
"Arn":
"arn:aws:lambda:us-east-2:1234:layer:my-layer:2"
},
],
"Environment": {
"Variables": {
"NODE_OPTIONS": "-r @sentry/serverless/dist/auto",
"SENTRY_DSN": self.sentry_dsn,
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
"OTHER": "hi",
}
},
},
})
mock_client.update_function_configuration = MagicMock()
return_value = {
"name": "lambdaD",
"runtime": "nodejs10.x",
"version": 3,
"outOfDate": False,
"enabled": True,
}
mock_get_serialized_lambda_function.return_value = return_value
assert self.get_response(action="updateVersion",
target="lambdaD").data == return_value
mock_client.get_function.assert_called_with(FunctionName="lambdaD")
mock_client.update_function_configuration.assert_called_with(
FunctionName="lambdaD",
Layers=[
{
"Arn":
"arn:aws:lambda:us-east-2:1234:layer:something-else:2"
},
"arn:aws:lambda:us-east-2:1234:layer:my-layer:3",
],
)
def test_lambda_setup_layer_too_many_requests_exception(
self, mock_react_view, mock_gen_aws_client, mock_get_supported_functions
):
class MockException(Exception):
pass
too_many_requests_err = (
"An error occurred (TooManyRequestsException) when calling the "
"UpdateFunctionConfiguration operation (reached max retries: 4): "
"Rate exceeded"
)
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.update_function_configuration = MagicMock(
side_effect=Exception(too_many_requests_err)
)
mock_client.describe_account = MagicMock(return_value={"Account": {"Name": "my_name"}})
mock_client.exceptions = MagicMock()
mock_client.exceptions.ResourceConflictException = MockException
mock_get_supported_functions.return_value = [
{
"FunctionName": "lambdaB",
"Runtime": "nodejs10.x",
"FunctionArn": "arn:aws:lambda:us-east-2:599817902985:function:lambdaB",
},
]
aws_external_id = "12-323"
self.pipeline.state.step_index = 2
self.pipeline.state.data = {
"region": region,
"account_number": account_number,
"aws_external_id": aws_external_id,
"project_id": self.projectA.id,
}
resp = self.client.post(
self.setup_path,
{"lambdaB": True},
format="json",
HTTP_ACCEPT="application/json",
headers={"Content-Type": "application/json", "Accept": "application/json"},
)
assert resp.status_code == 200
assert not Integration.objects.filter(provider=self.provider.key).exists()
failures = [
{
"name": "lambdaB",
"error": "Something went wrong! Please enable function manually after installation",
}
]
mock_react_view.assert_called_with(
ANY, "awsLambdaFailureDetails", {"lambdaFunctionFailures": failures, "successCount": 0}
)
def _stub_github(self):
responses.reset()
sentry.integrations.github.integration.get_jwt = MagicMock(
return_value="jwt_token_1")
sentry.integrations.github.client.get_jwt = MagicMock(
return_value="jwt_token_1")
responses.add(
responses.POST,
self.base_url +
"/installations/{}/access_tokens".format(self.installation_id),
json={
"token": self.access_token,
"expires_at": self.expires_at
},
)
responses.add(
responses.GET,
self.base_url + "/installation/repositories",
json={
"repositories": [
{
"id": 1296269,
"name": "foo",
"full_name": "Test-Organization/foo"
},
{
"id": 9876574,
"name": "bar",
"full_name": "Test-Organization/bar"
},
]
},
)
responses.add(
responses.GET,
self.base_url +
"/app/installations/{}".format(self.installation_id),
json={
"id": self.installation_id,
"app_id": self.app_id,
"account": {
"login": "******",
"avatar_url": "http://example.com/avatar.png",
"html_url": "https://github.com/Test-Organization",
"type": "Organization",
},
},
)
responses.add(responses.GET,
self.base_url + "/repos/Test-Organization/foo/hooks",
json=[])
def test_lambda_setup_layer_missing_role_error(
self, mock_react_view, mock_gen_aws_client, mock_get_supported_functions
):
class MockException(Exception):
pass
missing_role_err = (
"An error occurred (InvalidParameterValueException) when "
"calling the UpdateFunctionConfiguration operation: "
"The role defined for the function cannot be "
"assumed by Lambda."
)
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.update_function_configuration = MagicMock(
side_effect=Exception(missing_role_err)
)
mock_client.describe_account = MagicMock(return_value={"Account": {"Name": "my_name"}})
mock_client.exceptions = MagicMock()
mock_client.exceptions.ResourceConflictException = MockException
mock_get_supported_functions.return_value = [
{
"FunctionName": "lambdaB",
"Runtime": "nodejs10.x",
"FunctionArn": "arn:aws:lambda:us-east-2:599817902985:function:lambdaB",
},
]
aws_external_id = "12-323"
self.pipeline.state.step_index = 2
self.pipeline.state.data = {
"region": region,
"account_number": account_number,
"aws_external_id": aws_external_id,
"project_id": self.projectA.id,
}
resp = self.client.post(
self.setup_path,
{"lambdaB": True},
format="json",
HTTP_ACCEPT="application/json",
headers={"Content-Type": "application/json", "Accept": "application/json"},
)
assert resp.status_code == 200
assert not Integration.objects.filter(provider=self.provider.key).exists()
failures = [
{"name": "lambdaB", "error": "Invalid role associated with the lambda function"}
]
mock_react_view.assert_called_with(
ANY, "awsLambdaFailureDetails", {"lambdaFunctionFailures": failures, "successCount": 0}
)
def test_lambda_setup_layer_error(
self, mock_react_view, mock_gen_aws_client, mock_get_supported_functions
):
class MockException(Exception):
pass
bad_layer = "arn:aws:lambda:us-east-2:546545:layer:another-layer:5"
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.update_function_configuration = MagicMock(
side_effect=Exception(f"Layer version {bad_layer} does not exist")
)
mock_client.describe_account = MagicMock(return_value={"Account": {"Name": "my_name"}})
mock_client.exceptions = MagicMock()
mock_client.exceptions.ResourceConflictException = MockException
mock_get_supported_functions.return_value = [
{
"FunctionName": "lambdaA",
"Runtime": "nodejs12.x",
"FunctionArn": "arn:aws:lambda:us-east-2:599817902985:function:lambdaA",
},
{
"FunctionName": "lambdaB",
"Runtime": "nodejs10.x",
"FunctionArn": "arn:aws:lambda:us-east-2:599817902985:function:lambdaB",
},
]
aws_external_id = "12-323"
self.pipeline.state.step_index = 2
self.pipeline.state.data = {
"region": region,
"account_number": account_number,
"aws_external_id": aws_external_id,
"project_id": self.projectA.id,
}
resp = self.client.post(
self.setup_path,
{"lambdaB": True},
format="json",
HTTP_ACCEPT="application/json",
headers={"Content-Type": "application/json", "Accept": "application/json"},
)
assert resp.status_code == 200
assert not Integration.objects.filter(provider=self.provider.key).exists()
failures = [{"name": "lambdaB", "error": "Invalid existing layer another-layer"}]
mock_react_view.assert_called_with(
ANY, "awsLambdaFailureDetails", {"lambdaFunctionFailures": failures, "successCount": 0}
)
def test_retry_file_open(self) -> None:
project = self.project
release = Release.objects.create(
organization_id=project.organization_id, version="abc")
release.add_project(project)
content = b"foo"
file = File.objects.create(
name="file.min.js",
type="release.file",
headers={"Content-Type": "application/json; charset=utf-8"},
)
file.putfile(BytesIO(content))
ReleaseFile.objects.create(
name=file.name,
release=release,
organization_id=project.organization_id,
file=file,
)
stale_file_error = OSError()
stale_file_error.errno = errno.ESTALE
bad_file = MagicMock()
bad_file.chunks.side_effect = stale_file_error
bad_file_reader = MagicMock()
bad_file_reader.__enter__.return_value = bad_file
good_file = MagicMock()
good_file.chunks.return_value = iter([content])
good_file_reader = MagicMock()
good_file_reader.__enter__.return_value = good_file
with patch(
"sentry.lang.javascript.processor.ReleaseFile.cache") as cache:
cache.getfile.side_effect = [bad_file_reader, good_file_reader]
assert fetch_release_file(file.name, release) == http.UrlResult(
file.name,
{k.lower(): v.lower()
for k, v in file.headers.items()},
content,
200,
"utf-8",
)
assert bad_file.chunks.call_count == 1
assert good_file.chunks.call_count == 1
def test_includes_v2_plugins(self):
group = self.create_group()
result = self.TEMPLATE.render(context={"group": group},
request=MagicMock())
assert f"<span>Example Tag - http://example.com?id={group.id}</span>" in result
assert "<span>Example Two - None</span>" in result
def test_includes_v2_plugins(self):
group = self.create_group()
result = self.TEMPLATE.render(context={"group": group},
request=MagicMock())
assert "<span>Example Action - http://example.com?id=%s</span>" % (
group.id, ) in result
def test_simple(self, mock_get_client, mock_get_session):
arn = (
"arn:aws:cloudformation:us-west-1:599817902985:stack/"
"Sentry-Monitoring-Stack-Filter/e42083d0-3e3f-11eb-b66a-0ac9b5db7f30"
)
aws_external_id = "124-343"
mock_client = Mock()
mock_get_client.return_value = mock_client
credentials = {
"AccessKeyId": "my_access_key_id",
"SecretAccessKey": "my_secret_access_key",
"SessionToken": "my_session_token",
}
mock_client.assume_role = MagicMock(return_value={"Credentials": credentials})
mock_session = Mock()
mock_session.client = MagicMock(return_value="expected_output")
mock_get_session.return_value = mock_session
assert "expected_output" == gen_aws_client(arn, aws_external_id)
mock_get_client.assert_called_once_with(
service_name="sts",
aws_access_key_id="aws-key-id",
aws_secret_access_key="aws-secret-access-key",
region_name="us-east-2",
)
role_arn = "arn:aws:iam::599817902985:role/SentryRole"
mock_client.assume_role.assert_called_once_with(
RoleSessionName="Sentry", RoleArn=role_arn, ExternalId=aws_external_id
)
mock_get_session.assert_called_once_with(
aws_access_key_id=credentials["AccessKeyId"],
aws_secret_access_key=credentials["SecretAccessKey"],
aws_session_token=credentials["SessionToken"],
)
mock_session.client.assert_called_once_with(service_name="lambda", region_name="us-west-1")
def test_applies_correctly(self):
event = self.get_event()
plugin = MagicMock()
rule = self.get_rule()
rule.get_plugins = lambda: (LegacyPluginService(plugin), )
results = list(rule.after(event=event, state=self.get_state()))
assert len(results) == 1
assert plugin.should_notify.call_count == 1
assert results[0].callback is plugin.rule_notify
def test_audits(self, create_audit_entry):
InternalCreator.run(
name="nulldb",
user=self.user,
author="Sentry",
organization=self.org,
scopes=("project:read",),
webhook_url="http://example.com",
schema={"elements": [self.create_issue_link_schema()]},
request=MagicMock(),
)
call = faux(create_audit_entry)
assert call.kwarg_equals("organization", self.org)
assert call.kwarg_equals("target_object", self.org.id)
assert call.kwarg_equals("event", AuditLogEntryEvent.INTERNAL_INTEGRATION_ADD)
def test_applies_correctly_for_plugins(self):
event = self.get_event()
plugin = MagicMock()
plugin.is_enabled.return_value = True
plugin.should_notify.return_value = True
rule = self.get_rule(data={"service": "mail"})
with patch("sentry.plugins.base.plugins.get") as get_plugin:
get_plugin.return_value = plugin
results = list(rule.after(event=event, state=self.get_state()))
assert len(results) == 1
assert plugin.should_notify.call_count == 1
assert results[0].callback is plugin.rule_notify
def test_records_analytics(self, create_audit_entry, record):
sentry_app = InternalCreator.run(
name="nulldb",
user=self.user,
author="Sentry",
organization=self.org,
scopes=("project:read",),
webhook_url="http://example.com",
schema={"elements": [self.create_issue_link_schema()]},
request=MagicMock(),
)
assert faux(record).args_equals("internal_integration.created")
assert faux(record).kwargs == {
"user_id": self.user.id,
"organization_id": self.org.id,
"sentry_app": sentry_app.slug,
}
def test_notify_sentry_app_and_plugin_with_same_slug(self):
event = self.get_event()
self.create_sentry_app(organization=event.organization, name="Notify", is_alertable=True)
plugin = MagicMock()
plugin.is_enabled.return_value = True
plugin.should_notify.return_value = True
rule = self.get_rule(data={"service": "notify"})
with patch("sentry.plugins.base.plugins.get") as get_plugin:
get_plugin.return_value = plugin
results = list(rule.after(event=event, state=self.get_state()))
assert len(results) == 2
assert plugin.should_notify.call_count == 1
assert results[0].callback is notify_sentry_app
assert results[1].callback is plugin.rule_notify
def test_simple(self, mock_get_client, mock_get_session):
account_number = "599817902985"
region = "us-west-1"
aws_external_id = "124-343"
mock_client = Mock()
mock_get_client.return_value = mock_client
credentials = {
"AccessKeyId": "my_access_key_id",
"SecretAccessKey": "my_secret_access_key",
"SessionToken": "my_session_token",
}
mock_client.assume_role = MagicMock(
return_value={"Credentials": credentials})
mock_session = Mock()
mock_session.client = MagicMock(return_value="expected_output")
mock_get_session.return_value = mock_session
assert "expected_output" == gen_aws_client(account_number, region,
aws_external_id)
mock_get_client.assert_called_once_with(
service_name="sts",
aws_access_key_id="aws-key-id",
aws_secret_access_key="aws-secret-access-key",
region_name="us-east-2",
)
role_arn = "arn:aws:iam::599817902985:role/SentryRole"
mock_client.assume_role.assert_called_once_with(
RoleSessionName="Sentry",
RoleArn=role_arn,
ExternalId=aws_external_id,
Policy=json.dumps({
"Version":
"2012-10-17",
"Statement": [
{
"Effect":
"Allow",
"Action": [
"lambda:UpdateFunctionConfiguration",
"lambda:GetFunction"
],
"Resource":
"arn:aws:lambda:us-west-1:599817902985:function:*",
},
{
"Effect":
"Allow",
"Action": [
"lambda:ListFunctions",
"lambda:ListLayerVersions",
"lambda:GetLayerVersion",
"organizations:DescribeAccount",
],
"Resource":
"*",
},
],
}),
)
mock_get_session.assert_called_once_with(
aws_access_key_id=credentials["AccessKeyId"],
aws_secret_access_key=credentials["SecretAccessKey"],
aws_session_token=credentials["SessionToken"],
)
mock_session.client.assert_called_once_with(service_name="lambda",
region_name="us-west-1")
def test_enable_python_layer_on_already_enabled(
self, mock_gen_aws_client, mock_get_serialized_lambda_function):
"""
Test that ensures that if sentry-sdk is already enabled, then
re-enabling it should not override the env variables since it could be
problematic since the SENTRY_INITIAL_HANDLER env variable could be overriden
the second time with "sentry_sdk.integrations.init_serverless_sdk.
sentry_lambda_handler" and then disabling the sentry-sdk, would break
the function because the Handler will be updated with an incorrect
SENTRY_INITIAL_HANDLER value
"""
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.get_function = MagicMock(
return_value={
"Configuration": {
"FunctionName":
"lambdaZ",
"Runtime":
"python3.8",
"Handler":
"sentry_sdk.integrations.init_serverless_sdk.sentry_lambda_handler",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaZ",
"Layers": [
"arn:aws:lambda:us-east-2:1234:layer:something-else:2",
"arn:aws:lambda:us-east-2:1234:layer:my-python-layer:34",
],
"Environment": {
"Variables": {
"SENTRY_INITIAL_HANDLER":
"lambda_handler.test_handler",
"SENTRY_DSN": self.sentry_dsn,
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
}
},
},
})
mock_client.update_function_configuration = MagicMock()
return_value = {
"name": "lambdaZ",
"runtime": "python3.8",
"version": 3,
"outOfDate": False,
"enabled": True,
}
mock_get_serialized_lambda_function.return_value = return_value
assert self.get_response(action="enable",
target="lambdaZ").data == return_value
mock_client.get_function.assert_called_with(FunctionName="lambdaZ")
mock_client.update_function_configuration.assert_called_with(
FunctionName="lambdaZ",
Layers=[
"arn:aws:lambda:us-east-2:1234:layer:something-else:2",
"arn:aws:lambda:us-east-2:1234:layer:my-python-layer:34",
],
Environment={
"Variables": {
"SENTRY_INITIAL_HANDLER": "lambda_handler.test_handler",
"SENTRY_DSN": self.sentry_dsn,
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
}
},
Handler=
"sentry_sdk.integrations.init_serverless_sdk.sentry_lambda_handler",
)
def test_python_lambda_setup_layer_success(self, mock_gen_aws_client,
mock_get_supported_functions):
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.update_function_configuration = MagicMock()
mock_client.describe_account = MagicMock(
return_value={"Account": {
"Name": "my_name"
}})
mock_get_supported_functions.return_value = [{
"FunctionName":
"lambdaA",
"Handler":
"lambda_handler.test_handler",
"Runtime":
"python3.6",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaA",
}]
aws_external_id = "12-323"
self.pipeline.state.step_index = 2
self.pipeline.state.data = {
"region": region,
"account_number": account_number,
"aws_external_id": aws_external_id,
"project_id": self.projectA.id,
}
sentry_project_dsn = ProjectKey.get_default(
project=self.projectA).get_dsn(public=True)
resp = self.client.post(
self.setup_path,
data={"lambdaA": True},
format="json",
HTTP_ACCEPT="application/json",
headers={
"Content-Type": "application/json",
"Accept": "application/json"
},
)
assert resp.status_code == 200
mock_client.update_function_configuration.assert_called_once_with(
FunctionName="lambdaA",
Layers=["arn:aws:lambda:us-east-2:1234:layer:my-python-layer:34"],
Environment={
"Variables": {
"SENTRY_INITIAL_HANDLER": "lambda_handler.test_handler",
"SENTRY_DSN": sentry_project_dsn,
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
}
},
Handler=
"sentry_sdk.integrations.init_serverless_sdk.sentry_lambda_handler",
)
integration = Integration.objects.get(provider=self.provider.key)
assert integration.name == "my_name us-east-2"
assert integration.external_id == "599817902985-us-east-2"
assert integration.metadata == {
"region": region,
"account_number": account_number,
"aws_external_id": aws_external_id,
}
assert OrganizationIntegration.objects.filter(
integration=integration, organization=self.organization)
def test_lambda_setup_layer_success(self, mock_gen_aws_client,
mock_get_supported_functions):
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.update_function_configuration = MagicMock()
mock_client.describe_account = MagicMock(
return_value={"Account": {
"Name": "my_name"
}})
mock_get_supported_functions.return_value = [
{
"FunctionName":
"lambdaA",
"Runtime":
"nodejs12.x",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaA",
},
{
"FunctionName":
"lambdaB",
"Runtime":
"nodejs10.x",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaB",
},
]
aws_external_id = "12-323"
self.pipeline.state.step_index = 2
self.pipeline.state.data = {
"arn": arn,
"aws_external_id": aws_external_id,
"project_id": self.projectA.id,
}
sentry_project_dsn = ProjectKey.get_default(
project=self.projectA).get_dsn(public=True)
resp = self.client.post(
self.setup_path,
{"lambdaB": True},
format="json",
HTTP_ACCEPT="application/json",
headers={
"Content-Type": "application/json",
"Accept": "application/json"
},
)
assert resp.status_code == 200
mock_client.update_function_configuration.assert_called_with(
FunctionName="lambdaB",
Layers=["arn:aws:lambda:us-east-2:1234:layer:my-layer:3"],
Environment={
"Variables": {
"NODE_OPTIONS": "-r @sentry/serverless/dist/auto",
"SENTRY_DSN": sentry_project_dsn,
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
}
},
)
integration = Integration.objects.get(provider=self.provider.key)
assert integration.name == "my_name us-east-2"
assert integration.external_id == "599817902985-us-east-2"
assert integration.metadata == {
"arn": arn,
"aws_external_id": aws_external_id
}
assert OrganizationIntegration.objects.filter(
integration=integration, organization=self.organization)
def test_lambda_setup_layer_env_vars_limit_exceeded_exception(
self, mock_react_view, mock_gen_aws_client,
mock_get_supported_functions):
class MockException(Exception):
pass
env_vars_size_limit_err = (
"An error occurred (InvalidParameterValueException) when calling the "
"UpdateFunctionConfiguration operation: Lambda was unable to configure "
"your environment variables because the environment variables you have "
"provided exceeded the 4KB limit. String measured: {'MESSAGE':'This is production "
"environment','TARGET_ENV' :'pre-production','IS_SERVERLESS':'true','STAGE':'pre-prod'"
)
mock_client = Mock()
mock_gen_aws_client.return_value = mock_client
mock_client.update_function_configuration = MagicMock(
side_effect=Exception(env_vars_size_limit_err))
mock_client.describe_account = MagicMock(
return_value={"Account": {
"Name": "my_name"
}})
mock_client.exceptions = MagicMock()
mock_client.exceptions.ResourceConflictException = MockException
mock_get_supported_functions.return_value = [
{
"FunctionName":
"lambdaB",
"Runtime":
"nodejs10.x",
"FunctionArn":
"arn:aws:lambda:us-east-2:599817902985:function:lambdaB",
},
]
aws_external_id = "12-323"
self.pipeline.state.step_index = 2
self.pipeline.state.data = {
"region": region,
"account_number": account_number,
"aws_external_id": aws_external_id,
"project_id": self.projectA.id,
}
resp = self.client.post(
self.setup_path,
{"lambdaB": True},
format="json",
HTTP_ACCEPT="application/json",
headers={
"Content-Type": "application/json",
"Accept": "application/json"
},
)
assert resp.status_code == 200
assert not Integration.objects.filter(
provider=self.provider.key).exists()
failures = [{
"name":
"lambdaB",
"error":
"Environment variables size limit of 4KB was exceeded",
}]
mock_react_view.assert_called_with(ANY, "awsLambdaFailureDetails", {
"lambdaFunctionFailures": failures,
"successCount": 0
})
def test_supported_foreign_lang(self):
result = self.TEMPLATE.render(
request=MagicMock(LANGUAGE_CODE="fr") # French, in locale/catalogs.json
)
assert '<script src="/_static/{version}/sentry/dist/locale/fr.js"></script>' in result
def test_no_lang(self):
result = self.TEMPLATE.render(request=MagicMock())
assert result.strip() == ""
def test_english(self):
result = self.TEMPLATE.render(request=MagicMock(LANGUAGE_CODE="en"))
assert result.strip() == ""
def test_unsupported_foreign_lang(self):
result = self.TEMPLATE.render(
request=MagicMock(LANGUAGE_CODE="ro") # Romanian, not in locale/catalogs.json
)
assert result.strip() == ""
