def test_simple(self):
project = self.create_project()
for key in ('foo', 'bar', 'environment'):
tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key=key,
)
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tags',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
}
)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
data = {v['key']: v for v in response.data}
assert len(data) == 3
data['foo']['canDelete'] is True
data['bar']['canDelete'] is True
data['environment']['canDelete'] is False
def _create_tags(self, group, environment_id=None):
for key, values in group.data['tags']:
tagstore.create_tag_key(
project_id=group.project_id,
environment_id=environment_id,
key=key,
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=environment_id,
key=key,
)
if not isinstance(values, list):
values = [values]
for value in values:
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=environment_id,
key=key,
value=value,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=environment_id,
key=key,
value=value,
)
def test_simple(self):
key, value = 'foo', 'bar'
project = self.create_project()
group = self.create_group(project=project)
tagstore.create_tag_key(project_id=project.id, environment_id=self.environment.id, key=key)
tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value,
)
tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
)
self.login_as(user=self.user)
url = '/api/0/issues/{}/tags/{}/values/'.format(group.id, key)
response = self.client.get(url)
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]['value'] == 'bar'
def _create_tags(self, group, environment_id=None):
for key, values in group.data["tags"]:
tagstore.create_tag_key(project_id=group.project_id,
environment_id=environment_id,
key=key)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=environment_id,
key=key,
)
if not isinstance(values, list):
values = [values]
for value in values:
tagstore.create_tag_value(project_id=group.project_id,
environment_id=environment_id,
key=key,
value=value)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=environment_id,
key=key,
value=value,
)
def test_simple(self):
group = self.create_group()
group.data['tags'] = (['foo', 'bar'], ['biz', 'baz'])
group.save()
for key, value in group.data['tags']:
tagstore.create_tag_key(
project_id=group.project_id,
key=key,
)
tagstore.create_tag_value(
project_id=group.project_id,
key=key,
value=value,
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
key=key,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
key=key,
value=value,
)
self.login_as(user=self.user)
url = '/api/0/issues/{}/tags/'.format(group.id)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 2
def test_simple(self):
key, value = "foo", "bar"
project = self.create_project()
group = self.create_group(project=project)
tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key=key)
tagstore.create_tag_value(project_id=project.id,
environment_id=None,
key=key,
value=value)
tagstore.create_group_tag_value(project_id=project.id,
group_id=group.id,
environment_id=None,
key=key,
value=value)
self.login_as(user=self.user)
url = u"/api/0/issues/{}/tags/{}/values/".format(group.id, key)
response = self.client.get(url)
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]["value"] == "bar"
def test_simple(self):
project = self.create_project()
for key in ('foo', 'bar', 'environment'):
tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key=key,
)
self.login_as(user=self.user)
url = reverse('sentry-api-0-project-tags',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
})
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
data = {v['key']: v for v in response.data}
assert len(data) == 3
data['foo']['canDelete'] is True
data['bar']['canDelete'] is True
data['environment']['canDelete'] is False
def setUp(self):
super(ProjectTagsSettingsTest, self).setUp()
self.user = self.create_user('*****@*****.**')
self.org = self.create_organization(
name='Rowdy Tiger',
owner=None,
)
self.team = self.create_team(organization=self.org,
name='Mariachi Band')
self.project = self.create_project(
organization=self.org,
teams=[self.team],
name='Bengal',
)
self.create_member(
user=self.user,
organization=self.org,
role='owner',
teams=[self.team],
)
tagstore.create_tag_key(project_id=self.project.id,
environment_id=None,
key="Foo")
self.login_as(self.user)
self.path1 = '/{}/{}/settings/tags/'.format(self.org.slug,
self.project.slug)
def test_simple(self):
this_group = self.create_group()
this_group.data['tags'] = (['foo', ['bar', 'quux']], ['biz', 'baz'], [
'sentry:release', 'releaseme'])
this_group.save()
other_group = self.create_group()
other_group.data['tags'] = (['abc', 'xyz'],)
other_group.save()
for group in (this_group, other_group):
for key, values in group.data['tags']:
tagstore.create_tag_key(
project_id=group.project_id,
environment_id=None,
key=key,
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
)
if not isinstance(values, list):
values = [values]
for value in values:
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=None,
key=key,
value=value,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
value=value,
)
self.login_as(user=self.user)
url = u'/api/0/issues/{}/tags/'.format(this_group.id)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 3
data = sorted(response.data, key=lambda r: r['key'])
assert data[0]['key'] == 'biz'
assert len(data[0]['topValues']) == 1
assert data[1]['key'] == 'foo'
assert len(data[1]['topValues']) == 2
assert data[2]['key'] == 'release' # Formatted from sentry:release
assert len(data[2]['topValues']) == 1
def test_simple(self):
key, value = 'foo', u'b\xe4r'
# Drop microsecond value for MySQL
now = timezone.now().replace(microsecond=0)
project = self.create_project()
group = self.create_group(project=project)
tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value,
)
group_tag_value = tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
times_seen=1,
first_seen=now - timedelta(hours=1),
last_seen=now,
)
self.login_as(user=self.user)
url = '/{}/{}/issues/{}/tags/{}/export/?environment={}'.format(
project.organization.slug, project.slug, group.id, key,
self.environment.name)
response = self.client.get(url)
assert response.status_code == 200
assert response.streaming
assert response['Content-Type'] == 'text/csv'
rows = list(response.streaming_content)
for idx, row in enumerate(rows):
row = row.decode('utf-8')
assert row.endswith(u'\r\n')
bits = row[:-2].split(',')
if idx == 0:
assert bits == [
'value', 'times_seen', 'last_seen', 'first_seen'
]
else:
assert bits[0] == value
assert bits[1] == '1'
assert bits[2] == group_tag_value.last_seen.strftime(
'%Y-%m-%dT%H:%M:%S.%fZ')
assert bits[3] == group_tag_value.first_seen.strftime(
'%Y-%m-%dT%H:%M:%S.%fZ')
def test_simple(self):
key, value = 'foo', u'b\xe4r'
# Drop microsecond value for MySQL
now = timezone.now().replace(microsecond=0)
project = self.create_project()
group = self.create_group(project=project)
tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value,
)
group_tag_value = tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
times_seen=1,
first_seen=now - timedelta(hours=1),
last_seen=now,
)
self.login_as(user=self.user)
url = '/{}/{}/issues/{}/tags/{}/export/?environment={}'.format(
project.organization.slug, project.slug, group.id, key, self.environment.name
)
response = self.client.get(url)
assert response.status_code == 200
assert response.streaming
assert response['Content-Type'] == 'text/csv'
rows = list(response.streaming_content)
for idx, row in enumerate(rows):
row = row.decode('utf-8')
assert row.endswith(u'\r\n')
bits = row[:-2].split(',')
if idx == 0:
assert bits == ['value', 'times_seen', 'last_seen', 'first_seen']
else:
assert bits[0] == value
assert bits[1] == '1'
assert bits[2] == group_tag_value.last_seen.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
assert bits[3] == group_tag_value.first_seen.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
def test_simple(self):
key, value = "foo", u"b\xe4r"
now = timezone.now()
project = self.create_project()
group = self.create_group(project=project)
tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
group_tag_value = tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
times_seen=1,
first_seen=now - timedelta(hours=1),
last_seen=now,
)
self.login_as(user=self.user)
url = u"/{}/{}/issues/{}/tags/{}/export/?environment={}".format(
project.organization.slug, project.slug, group.id, key,
self.environment.name)
response = self.client.get(url)
assert response.status_code == 200
assert response.streaming
assert response["Content-Type"] == "text/csv"
rows = list(response.streaming_content)
for idx, row in enumerate(rows):
row = row.decode("utf-8")
assert row.endswith(u"\r\n")
bits = row[:-2].split(",")
if idx == 0:
assert bits == [
"value", "times_seen", "last_seen", "first_seen"
]
else:
assert bits[0] == value
assert bits[1] == "1"
assert bits[2] == group_tag_value.last_seen.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
assert bits[3] == group_tag_value.first_seen.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
def test_simple(self):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key='foo',
values_seen=16
)
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.get(url)
assert response.status_code == 200
assert response.data['id'] == six.text_type(tagkey.id)
assert response.data['uniqueValues'] == tagkey.values_seen
def test_query(self):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id, key='foo')
tagstore.create_tag_value(project_id=project.id, key='foo', value='bar')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-values',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.get(url + '?query=bar')
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]['value'] == 'bar'
response = self.client.get(url + '?query=foo')
assert response.status_code == 200
assert len(response.data) == 0
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project, )
event = self.create_event(group=group)
UserReport.objects.create(
group_id=group.id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_query(self):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id, environment_id=None, key="foo")
tagstore.create_tag_value(
project_id=project.id, environment_id=None, key="foo", value="bar"
)
self.login_as(user=self.user)
url = reverse(
"sentry-api-0-project-tagkey-values",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": tagkey.key,
},
)
response = self.client.get(url + "?query=bar")
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]["value"] == "bar"
response = self.client.get(url + "?query=foo")
assert response.status_code == 200
assert len(response.data) == 0
def test_simple(self):
group = self.create_group()
group.data["tags"] = (["foo", "bar"],)
group.save()
key, value = group.data["tags"][0]
tagkey = tagstore.create_tag_key(
project_id=group.project_id, environment_id=None, key=key, values_seen=2
)
tagstore.create_tag_value(
project_id=group.project_id, environment_id=None, key=key, value=value, times_seen=4
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
values_seen=1,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
value=value,
times_seen=3,
)
self.login_as(user=self.user)
url = u"/api/0/issues/{}/tags/{}/".format(group.id, tagkey.key)
response = self.client.get(url, format="json")
assert response.status_code == 200, response.content
assert response.data["key"] == six.text_type(tagkey.key)
assert response.data["totalValues"] == 3
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id, key='foo')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 204
mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id)
assert tagstore.get_tag_key(
project.id,
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key='foo')
self.login_as(user=self.user)
url = reverse('sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
})
response = self.client.delete(url)
assert response.status_code == 204
if settings.SENTRY_TAGSTORE.startswith('sentry.tagstore.multi'):
backend_count = len(
settings.SENTRY_TAGSTORE_OPTIONS.get('backends', []))
assert mock_delete_tag_key.delay.call_count == backend_count
else:
from sentry.tagstore.models import TagKey
mock_delete_tag_key.delay.assert_called_once_with(
object_id=tagkey.id, model=TagKey)
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key='foo')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 204
mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id)
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key='foo')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 204
if settings.SENTRY_TAGSTORE.startswith('sentry.tagstore.multi'):
backend_count = len(settings.SENTRY_TAGSTORE_OPTIONS.get('backends', []))
assert mock_delete_tag_key.delay.call_count == backend_count
else:
from sentry.tagstore.models import TagKey
mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id, model=TagKey)
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
def test_protected(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key="environment")
self.login_as(user=self.user)
url = reverse(
"sentry-api-0-project-tagkey-details",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": tagkey.key,
},
)
response = self.client.delete(url)
assert response.status_code == 403
assert mock_delete_tag_key.delay.call_count == 0
assert (tagstore.get_tag_key(
project.id,
None,
tagkey.key,
status=TagKeyStatus.VISIBLE # environment_id
).status == TagKeyStatus.VISIBLE)
def test_simple(self):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key='foo')
tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key='foo',
value='bar')
self.login_as(user=self.user)
url = reverse('sentry-api-0-project-tagkey-values',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
})
response = self.client.get(url)
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]['value'] == 'bar'
def test_protected(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key='environment')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 403
assert mock_delete_tag_key.delay.call_count == 0
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.VISIBLE
).status == TagKeyStatus.VISIBLE
def test_simple(self):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key='foo',
values_seen=16
)
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.get(url)
assert response.status_code == 200
assert response.data['id'] == six.text_type(tagkey.id)
assert response.data['uniqueValues'] == tagkey.values_seen
def test_simple(self):
project = self.create_project()
for key in ('foo', 'bar'):
tagstore.create_tag_key(
project_id=project.id,
key=key,
)
self.login_as(user=self.user)
url = reverse('sentry-api-0-project-tags',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
})
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 2
def test_simple(self):
this_group = self.create_group()
this_group.data['tags'] = (['foo', 'bar'], ['biz', 'baz'])
this_group.save()
other_group = self.create_group()
other_group.data['tags'] = (['abc', 'xyz'], )
other_group.save()
for group in (this_group, other_group):
for key, value in group.data['tags']:
tagstore.create_tag_key(
project_id=group.project_id,
environment_id=self.environment.id,
key=key,
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key=key,
value=value,
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
)
self.login_as(user=self.user)
url = '/api/0/issues/{}/tags/'.format(this_group.id)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 2
def test_simple(self):
project = self.create_project()
for key in ('foo', 'bar'):
tagstore.create_tag_key(
project_id=project.id,
key=key,
)
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tags',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
}
)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 2
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project, )
event = self.create_event(group=group)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
event_id=event.event_id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
def test(self):
user = self.create_user()
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id, key='key')
grouptagkey = GroupTagKey.objects.create(
project_id=project.id,
group_id=self.create_group(project=project).id,
key=tagkey.key)
result = serialize(grouptagkey, user)
assert result['id'] == six.text_type(grouptagkey.id)
assert result['key'] == 'key'
def test_user_tag(self):
project = self.create_project()
group = self.create_group(project=project)
euser = EventUser.objects.create(
project_id=project.id,
ident='1',
email='*****@*****.**',
username='******',
ip_address='127.0.0.1',
)
tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key='sentry:user',
)
tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key='sentry:user',
value=euser.tag_value,
)
tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key='sentry:user',
value=euser.tag_value,
)
self.login_as(user=self.user)
url = '/api/0/issues/{}/tags/user/values/'.format(group.id)
response = self.client.get(url)
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]['email'] == '*****@*****.**'
assert response.data[0]['value'] == euser.tag_value
def setUp(self):
super(ProjectReleaseTrackingSettingsTest, self).setUp()
self.user = self.create_user('*****@*****.**')
self.org = self.create_organization(
name='Rowdy Tiger',
owner=None,
)
self.team = self.create_team(organization=self.org, name='Mariachi Band')
self.project = self.create_project(
organization=self.org,
teams=[self.team],
name='Bengal',
)
self.create_member(
user=self.user,
organization=self.org,
role='owner',
teams=[self.team],
)
tagstore.create_tag_key(project_id=self.project.id, environment_id=None, key="Foo")
self.login_as(self.user)
self.path1 = u'/{}/{}/settings/release-tracking/'.format(self.org.slug, self.project.slug)
def test_user_tag(self):
project = self.create_project()
group = self.create_group(project=project)
euser = EventUser.objects.create(
project_id=project.id,
ident="1",
email="*****@*****.**",
username="******",
ip_address="127.0.0.1",
)
tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key="sentry:user")
tagstore.create_tag_value(project_id=project.id,
environment_id=None,
key="sentry:user",
value=euser.tag_value)
tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=None,
key="sentry:user",
value=euser.tag_value,
)
self.login_as(user=self.user)
url = u"/api/0/issues/{}/tags/user/values/".format(group.id)
response = self.client.get(url)
assert response.status_code == 200
assert len(response.data) == 1
assert response.data[0]["email"] == "*****@*****.**"
assert response.data[0]["value"] == euser.tag_value
def test(self):
user = self.create_user()
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
key='key'
)
grouptagkey = tagstore.create_group_tag_key(
project_id=project.id,
group_id=self.create_group(project=project).id,
key=tagkey.key
)
result = serialize(grouptagkey, user)
assert result['id'] == six.text_type(grouptagkey.id)
assert result['key'] == 'key'
def test_simple(self):
event_id = "a" * 32
project = self.create_project()
node_id = Event.generate_node_id(project.id, event_id)
group = self.create_group(project=project)
event = self.create_event(group=group, event_id=event_id)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(name="hello.png", type="image/png"),
name="hello.png",
)
UserReport.objects.create(event_id=event.event_id,
project_id=event.project_id,
name="Jane Doe")
key = "key"
value = "value"
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[(tk.key, tv.value)],
)
assert nodestore.get(node_id) is not None
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id, project_id=project.id).exists()
assert not UserReport.objects.filter(event_id=event.event_id,
project_id=project.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert nodestore.get(node_id) is None
def test_simple(self, mock_delete_tag_key, mock_eventstream):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key="foo")
self.login_as(user=self.user)
eventstream_state = object()
mock_eventstream.start_delete_tag = mock.Mock(
return_value=eventstream_state)
url = reverse(
"sentry-api-0-project-tagkey-details",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": tagkey.key,
},
)
response = self.client.delete(url)
assert response.status_code == 204
if settings.SENTRY_TAGSTORE.startswith("sentry.tagstore.multi"):
backend_count = len(
settings.SENTRY_TAGSTORE_OPTIONS.get("backends", []))
assert mock_delete_tag_key.delay.call_count == backend_count
else:
from sentry.tagstore.models import TagKey
mock_delete_tag_key.delay.assert_called_once_with(
object_id=tagkey.id, model=TagKey)
assert (tagstore.get_tag_key(
project.id,
None,
tagkey.key,
status=TagKeyStatus.PENDING_DELETION # environment_id
).status == TagKeyStatus.PENDING_DELETION)
mock_eventstream.start_delete_tag.assert_called_once_with(
project.id, "foo")
mock_eventstream.end_delete_tag.assert_called_once_with(
eventstream_state)
def test_simple(self):
group = self.create_group()
group.data['tags'] = (['foo', 'bar'], )
group.save()
key, value = group.data['tags'][0]
tagkey = tagstore.create_tag_key(
project_id=group.project_id,
environment_id=None,
key=key,
values_seen=2
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=None,
key=key,
value=value,
times_seen=4
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
values_seen=1,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
value=value,
times_seen=3,
)
self.login_as(user=self.user)
url = '/api/0/issues/{}/tags/{}/'.format(group.id, tagkey.key)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert response.data['id'] == six.text_type(tagkey.id)
assert response.data['key'] == six.text_type(tagkey.key)
assert response.data['uniqueValues'] == 1
assert response.data['totalValues'] == 3
def test_simple(self):
group = self.create_group()
group.data['tags'] = (['foo', 'bar'], )
group.save()
key, value = group.data['tags'][0]
tagkey = tagstore.create_tag_key(
project_id=group.project_id,
environment_id=None,
key=key,
values_seen=2
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=None,
key=key,
value=value,
times_seen=4
)
tagstore.create_group_tag_key(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
values_seen=1,
)
tagstore.create_group_tag_value(
project_id=group.project_id,
group_id=group.id,
environment_id=None,
key=key,
value=value,
times_seen=3,
)
self.login_as(user=self.user)
url = '/api/0/issues/{}/tags/{}/'.format(group.id, tagkey.key)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert response.data['key'] == six.text_type(tagkey.key)
assert response.data['uniqueValues'] == 1
assert response.data['totalValues'] == 3
def test_simple(self):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key="foo",
values_seen=16)
self.login_as(user=self.user)
url = reverse(
"sentry-api-0-project-tagkey-details",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": tagkey.key,
},
)
response = self.client.get(url)
assert response.status_code == 200
assert response.data["uniqueValues"] == tagkey.values_seen
def test_simple(self):
tagstore.create_tag_key(project_id=self.project.id, key='site')
tagstore.create_tag_key(project_id=self.project.id, key='url')
tagstore.create_tag_key(project_id=self.project.id, key='os')
self.login_as(self.user)
resp = self.client.get(self.path)
assert resp.status_code == 200
self.assertTemplateUsed('sentry/projects/manage_tags.html')
assert resp.context['organization'] == self.organization
assert resp.context['team'] == self.team
assert resp.context['project'] == self.project
tag_list = [t.key for t in resp.context['tag_list']]
assert 'site' in tag_list
assert 'url' in tag_list
assert 'os' in tag_list
def test_tags(self):
self.login_as(user=self.user)
group = self.create_group()
event_1 = self.create_event(event_id='a' * 32, group=group)
event_2 = self.create_event(event_id='b' * 32, group=group)
tagkey_1 = tagstore.create_tag_key(
project_id=group.project_id,
environment_id=self.environment.id,
key='foo')
tagkey_2 = tagstore.create_tag_key(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar')
tagvalue_1 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='foo',
value='baz')
tagvalue_2 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='biz')
tagvalue_3 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='buz')
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_1.id,
tags=[
(tagkey_1.key, tagvalue_1.value),
(tagkey_2.key, tagvalue_3.value),
],
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_2.id,
tags=[
(tagkey_2.key, tagvalue_2.value),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?query=foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:biz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_2.id)
response = self.client.get(url + '?query=bar:biz%20foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:buz%20foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=a:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(
project_id=project2.id,
environment_id=env2.id,
key=key,
value=value
)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[
(tk2.key, tv2.value)
],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, env2.id, key) is not None
assert tagstore.get_group_tag_value(
group2.project_id, group2.id, env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(project_id=project2.id,
environment_id=env2.id,
key=key,
value=value)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[(tk2.key, tv2.value)],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None,
key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None,
key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id,
env2.id, key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id,
env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.legacy.tasks import delete_tag_key
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
],
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(key=key, project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1)
],
)
with self.tasks():
delete_tag_key(object_id=tk.id)
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(group_id=group.id,
project_id=project.id,
event_id=1,
environment_id=self.environment.id,
tags=[
(tk.id, 1),
])
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, self.environment.id, key)
tagstore.create_group_tag_key(key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk2.id, 1),
],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key,
value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, None, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, None,
key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id, None,
key, value) is not None
assert EventTag.objects.filter(key_id=tk.id).exists()
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
event_id=event.event_id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tv = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventMapping.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
EventAttachment.objects.create(
event_id=event.event_id,
group_id=event.group_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
group_id=group.id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tv = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
group_id=group.id,
).exists()
assert not EventMapping.objects.filter(
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_tags(self):
self.login_as(user=self.user)
group = self.create_group()
event_1 = self.create_event(event_id='a' * 32, group=group)
event_2 = self.create_event(event_id='b' * 32, group=group)
tagkey_1 = tagstore.create_tag_key(project_id=group.project_id,
environment_id=self.environment.id,
key='foo')
tagkey_2 = tagstore.create_tag_key(project_id=group.project_id,
environment_id=self.environment.id,
key='bar')
tagvalue_1 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='foo',
value='baz')
tagvalue_2 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='biz')
tagvalue_3 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='buz')
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_1.id,
tags=[
(tagkey_1.key, tagvalue_1.value),
(tagkey_2.key, tagvalue_3.value),
],
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_2.id,
tags=[
(tagkey_2.key, tagvalue_2.value),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?query=foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:biz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_2.id)
response = self.client.get(url + '?query=bar:biz%20foo:baz',
format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:buz%20foo:baz',
format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=a:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
]
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, self.environment.id, key)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1),
],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
