def test_identifier_conflict(self):
create_method = BaseManager.create
call_count = [0]
alert_rule = self.create_alert_rule()
def mock_base_create(*args, **kwargs):
if not call_count[0]:
call_count[0] += 1
# This incident will take the identifier we already fetched and
# use it, which will cause the database to throw an integrity
# error.
with transaction.atomic():
incident = Incident.objects.create(
self.organization,
status=IncidentStatus.OPEN.value,
title="Conflicting Incident",
type=IncidentType.ALERT_TRIGGERED.value,
alert_rule=alert_rule,
)
assert incident.identifier == kwargs["identifier"]
try:
create_method(*args, **kwargs)
except IntegrityError:
raise
else:
self.fail("Expected an integrity error")
else:
call_count[0] += 1
return create_method(*args, **kwargs)
self.organization
with patch.object(BaseManager, "create", new=mock_base_create):
incident = Incident.objects.create(
self.organization,
alert_rule=alert_rule,
status=IncidentStatus.OPEN.value,
title="hi",
type=IncidentType.ALERT_TRIGGERED.value,
)
# We should have 3 calls - one for initial create, one for conflict,
# then the final one for the retry we get due to the conflict
assert call_count[0] == 3
# Ideally this would be 2, but because we create the conflicting
# row inside of a transaction it ends up rolled back. We just want
# to verify that it was created successfully.
assert incident.identifier == 1
def test_simple(self):
org = self.create_organization(
name="test", status=OrganizationStatus.PENDING_DELETION)
user = self.create_user()
self.create_team(organization=org, name="test1")
self.create_team(organization=org, name="test2")
release = Release.objects.create(version="a" * 32,
organization_id=org.id)
repo = Repository.objects.create(organization_id=org.id,
name=org.name,
provider="dummy")
commit_author = CommitAuthor.objects.create(organization_id=org.id,
name="foo",
email="*****@*****.**")
commit = Commit.objects.create(repository_id=repo.id,
organization_id=org.id,
author=commit_author,
key="a" * 40)
ReleaseCommit.objects.create(organization_id=org.id,
release=release,
commit=commit,
order=0)
env = Environment.objects.create(organization_id=org.id,
project_id=4,
name="foo")
release_env = ReleaseEnvironment.objects.create(organization_id=org.id,
project_id=4,
release_id=release.id,
environment_id=env.id)
with self.tasks():
with patch.object(DummyRepositoryProvider,
"delete_repository") as mock_delete_repo:
delete_organization(object_id=org.id, actor_id=user.id)
assert mock_delete_repo.call_count == 1
assert not Organization.objects.filter(id=org.id).exists()
assert not Environment.objects.filter(id=env.id).exists()
assert not ReleaseEnvironment.objects.filter(
id=release_env.id).exists()
assert not Repository.objects.filter(id=repo.id).exists()
assert not ReleaseCommit.objects.filter(
organization_id=org.id).exists()
assert not Release.objects.filter(organization_id=org.id).exists()
assert not CommitAuthor.objects.filter(id=commit_author.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
def test(self):
with patch.object(AlertRuleTriggerAction,
"_type_registrations",
new={}):
mock_handler = Mock()
AlertRuleTriggerAction.register_type(
"email", AlertRuleTriggerAction.Type.EMAIL, [])(mock_handler)
incident = self.create_incident()
metric_value = 1234
with self.tasks():
handle_trigger_action.delay(self.action.id,
incident.id,
self.project.id,
"fire",
metric_value=metric_value)
mock_handler.assert_called_once_with(self.action, incident,
self.project)
mock_handler.return_value.fire.assert_called_once_with(
metric_value)
def test_simple(self, mock_build_repository_config):
with patch.object(
ExampleRepositoryProvider, "build_repository_config", return_value=self.repo_config_data
) as mock_get_repository_data:
response = self.client.post(
self.url, data={"provider": "integrations:example", "name": "getsentry/sentry"}
)
mock_get_repository_data.assert_called_once_with(
organization=self.org, data={"my_config_key": "some_var"}
)
assert response.status_code == 201, (response.status_code, response.content)
assert response.data["id"]
repo = Repository.objects.get(id=response.data["id"])
assert repo.provider == "integrations:example"
assert repo.name == "getsentry/sentry"
assert repo.url == "https://github.com/getsentry/sentry"
assert repo.config == {"name": "getsentry/sentry"}
def override_options(options):
"""
A context manager for overriding specific configuration
Options.
"""
from django.conf import settings
from sentry.options import default_manager
wrapped = default_manager.store.get
def new_get(key, **kwargs):
try:
return options[key.name]
except KeyError:
return wrapped(key, **kwargs)
# Patch options into SENTRY_OPTIONS as well
new_options = settings.SENTRY_OPTIONS.copy()
new_options.update(options)
with override_settings(SENTRY_OPTIONS=new_options):
with patch.object(default_manager.store, "get", side_effect=new_get):
yield
def test_simple(self):
self.login_as(user=self.user)
org = self.create_organization(owner=self.user, name="baz")
with patch.object(DummyRepositoryProvider,
"needs_auth",
return_value=False):
url = reverse("sentry-api-0-organization-repositories",
args=[org.slug])
response = self.client.post(url,
data={
"provider": "dummy",
"name": "getsentry/sentry"
})
assert response.status_code == 201, (response.status_code,
response.content)
assert response.data["id"]
repo = Repository.objects.get(id=response.data["id"])
assert repo.provider == "dummy"
assert repo.name == "getsentry/sentry"
def test_simple(self):
self.login_as(user=self.user)
org = self.create_organization(owner=self.user, name="baz")
repo = Repository.objects.create(name="example",
provider="dummy",
organization_id=org.id)
release = Release.objects.create(organization_id=org.id,
version="abcabcabc")
commit = Commit.objects.create(organization_id=org.id,
repository_id=repo.id,
key="a" * 40)
ReleaseHeadCommit.objects.create(organization_id=org.id,
repository_id=repo.id,
release=release,
commit=commit)
refs = [{"repository": repo.name, "commit": "b" * 40}]
release2 = Release.objects.create(organization_id=org.id,
version="12345678")
deploy = Deploy.objects.create(organization_id=org.id,
release=release2,
environment_id=5)
with self.tasks():
with patch.object(Deploy,
"notify_if_ready") as mock_notify_if_ready:
fetch_commits(
release_id=release2.id,
user_id=self.user.id,
refs=refs,
previous_release_id=release.id,
)
commit_list = list(
Commit.objects.filter(releasecommit__release=release2).order_by(
"releasecommit__order"))
# see DummyRepositoryProvider.compare_commits
assert len(commit_list) == 3
assert commit_list[0].repository_id == repo.id
assert commit_list[0].organization_id == org.id
assert commit_list[0].key == "62de626b7c7cfb8e77efb4273b1a3df4123e6216"
assert commit_list[1].repository_id == repo.id
assert commit_list[1].organization_id == org.id
assert commit_list[1].key == "58de626b7c7cfb8e77efb4273b1a3df4123e6345"
assert commit_list[2].repository_id == repo.id
assert commit_list[2].organization_id == org.id
assert commit_list[2].key == "b" * 40
mock_notify_if_ready.assert_called_with(deploy.id, fetch_complete=True)
latest_repo_release_environment = LatestRepoReleaseEnvironment.objects.get(
repository_id=repo.id, environment_id=5)
assert latest_repo_release_environment.deploy_id == deploy.id
assert latest_repo_release_environment.release_id == release2.id
assert latest_repo_release_environment.commit_id == commit_list[0].id
def test_log_finish(self):
with patch.object(self.logger, "info") as mock:
self.mediator.call()
assert faux(mock).kwarg_equals("extra.at", "finish")
def test_log_start(self):
with patch.object(self.logger, "info") as mock:
self.mediator.call()
assert faux(mock, 0).args_equals(None)
assert faux(mock, 0).kwarg_equals("extra.at", "start")
def test_log_with_request_project(self, _):
with patch.object(self.logger, "info") as log:
self.mediator.log(at="test")
assert faux(log).kwarg_equals("extra.project", "bar")
def test_log(self):
with patch.object(self.logger, "info") as mock:
self.mediator.log(at="test")
mock.assert_called_with(None, extra={"at": "test"})
