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):
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 _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_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):
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):
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 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_environment(self):
self.login_as(user=self.user)
group = self.create_group()
events = {}
for name in ['production', 'development']:
environment = Environment.get_or_create(group.project, name)
tagstore.get_or_create_tag_key(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
value=name,
)
events[name] = event = self.create_event(
group=group,
tags={'environment': name},
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=environment.id,
event_id=event.id,
tags=[
('environment', name),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=production',
format='json')
assert response.status_code == 200, response.content
assert set(map(lambda x: x['id'], response.data)) == set([
six.text_type(events['production'].id),
])
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=invalid', format='json')
assert response.status_code == 200, response.content
assert response.data == []
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(
url + '?environment=production&query=environment:development',
format='json')
assert response.status_code == 200, response.content
assert response.data == []
def test_environment(self):
self.login_as(user=self.user)
group = self.create_group()
events = {}
for name in ['production', 'development']:
environment = Environment.get_or_create(group.project, name)
tagstore.get_or_create_tag_key(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
value=name,
)
events[name] = event = self.create_event(
group=group,
tags={'environment': name},
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=environment.id,
event_id=event.id,
tags=[
('environment', name),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=production', format='json')
assert response.status_code == 200, response.content
assert set(map(lambda x: x['id'], response.data)) == set([
six.text_type(events['production'].id),
])
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=invalid', format='json')
assert response.status_code == 200, response.content
assert response.data == []
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(
url + '?environment=production&query=environment:development',
format='json')
assert response.status_code == 200, response.content
assert response.data == []
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()
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_with_user(self):
user = self.create_user()
project = self.create_project()
euser = EventUser.objects.create(
project_id=project.id,
email='*****@*****.**',
)
tagvalue = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key='sentry:user',
value=euser.tag_value,
)
grouptagvalue = tagstore.create_group_tag_value(
project_id=project.id,
group_id=self.create_group(project=project).id,
environment_id=self.environment.id,
key=tagvalue.key,
value=tagvalue.value,
)
result = serialize(grouptagvalue, user)
assert result['id'] == six.text_type(grouptagvalue.id)
assert result['key'] == 'user'
assert result['value'] == grouptagvalue.value
assert result['name'] == euser.get_label()
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):
tv = tagstore.create_tag_value(
project_id=self.project.id,
environment_id=self.environment.id,
key='sentry:release',
value='1.0',
first_seen=datetime(2018, 2, 1, tzinfo=pytz.utc),
)
tv = tagstore.get_tag_value(self.project.id, self.environment.id,
'sentry:release', '1.0')
assert tv.data['release_id']
release = Release.objects.get(id=tv.data['release_id'])
assert release.version == tv.value
assert release.projects.first() == self.project
assert release.organization == self.project.organization
assert release.date_added == tv.first_seen
# ensure we dont hit some kind of error saving it again
tv.save()
tv2 = tagstore.create_tag_value(
project_id=self.create_project(
organization=self.project.organization, ).id,
environment_id=self.environment.id,
key='sentry:release',
value='1.0',
first_seen=datetime(2018, 1, 1, tzinfo=pytz.utc),
)
assert Release.objects.get(id=release.id).date_added == tv2.first_seen
tagstore.create_tag_value(
project_id=self.create_project(
organization=self.project.organization, ).id,
environment_id=self.environment.id,
key='sentry:release',
value='1.0',
first_seen=datetime(2018, 3, 1, tzinfo=pytz.utc),
)
assert Release.objects.get(id=release.id).date_added == tv2.first_seen
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()
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_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 test_release(self):
user = self.create_user()
project = self.create_project()
tagvalue = tagstore.create_tag_value(
project_id=project.id,
key='sentry:release',
value='df84bccbb23ca15f2868be1f2a5f7c7a6464fadd',
)
result = serialize(tagvalue, user)
assert result['id'] == six.text_type(tagvalue.id)
assert result['key'] == 'release'
assert result['value'] == tagvalue.value
assert result['name'] == tagvalue.get_label()
def test_basic(self):
user = self.create_user()
project = self.create_project()
tagvalue = tagstore.create_tag_value(
project_id=project.id,
key='sentry:user',
value='email:[email protected]',
)
result = serialize(tagvalue, user)
assert result['id'] == six.text_type(tagvalue.id)
assert result['key'] == 'user'
assert result['value'] == tagvalue.value
assert result['name'] == tagvalue.get_label()
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_simple(self):
tv = tagstore.create_tag_value(
project_id=self.project.id,
key='sentry:release',
value='1.0',
)
tv = tagstore.get_tag_value(self.project.id, 'sentry:release', '1.0')
assert tv.data['release_id']
release = Release.objects.get(id=tv.data['release_id'])
assert release.version == tv.value
assert release.projects.first() == self.project
assert release.organization == self.project.organization
# ensure we dont hit some kind of error saving it again
tv.save()
def test_simple(self):
tv = tagstore.create_tag_value(
project_id=self.project.id,
key='sentry:release',
value='1.0',
)
tv = tagstore.get_tag_value(self.project.id, 'sentry:release', '1.0')
assert tv.data['release_id']
release = Release.objects.get(id=tv.data['release_id'])
assert release.version == tv.value
assert release.projects.first() == self.project
assert release.organization == self.project.organization
# ensure we dont hit some kind of error saving it again
tv.save()
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):
user = self.create_user()
project = self.create_project()
project2 = self.create_project(organization=project.organization)
release = Release.objects.create(
organization_id=project.organization_id, version=uuid4().hex
)
release.add_project(project)
release.add_project(project2)
ReleaseProject.objects.filter(release=release, project=project).update(new_groups=1)
ReleaseProject.objects.filter(release=release, project=project2).update(new_groups=1)
environment = Environment.objects.create(
organization_id=project.organization_id, name="prod"
)
environment.add_project(project)
environment.add_project(project2)
ReleaseProjectEnvironment.objects.create(
project_id=project.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
ReleaseProjectEnvironment.objects.create(
project_id=project2.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
key = "sentry:release"
value = release.version
tagstore.create_tag_value(
project_id=project.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now(),
last_seen=timezone.now(),
times_seen=5,
)
tagstore.create_tag_value(
project_id=project2.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now() - datetime.timedelta(days=2),
last_seen=timezone.now() - datetime.timedelta(days=1),
times_seen=5,
)
commit_author = CommitAuthor.objects.create(
name="stebe", email="*****@*****.**", organization_id=project.organization_id
)
commit = Commit.objects.create(
organization_id=project.organization_id,
repository_id=1,
key="abc",
author=commit_author,
message="waddap",
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=1,
)
release.update(
authors=[six.text_type(commit_author.id)], commit_count=1, last_commit_id=commit.id
)
result = serialize(release, user)
assert result["version"] == release.version
assert result["shortVersion"] == release.version
# should be sum of all projects
assert result["newGroups"] == 2
# should be tags from all projects
tagvalue1 = tagstore.get_tag_value(project.id, None, key, value)
tagvalue2 = tagstore.get_tag_value(project2.id, None, key, value)
assert result["firstEvent"] == tagvalue2.first_seen
assert result["lastEvent"] == tagvalue1.last_seen
assert result["commitCount"] == 1
assert result["authors"] == [{"name": "stebe", "email": "*****@*****.**"}]
result = serialize(release, user, project=project)
# should be groups from one project
assert result["newGroups"] == 1
# should be tags from one project
assert result["firstEvent"] == tagvalue1.first_seen
assert result["lastEvent"] == tagvalue1.last_seen
# Make sure a sha1 value gets truncated
release.version = "0" * 40
result = serialize(release, user)
assert result["shortVersion"] == "0" * 7
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_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):
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):
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):
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(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,
event_id=1,
environment_id=self.environment.id,
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(project2.id, env2.id, key)
tv2 = tagstore.create_tag_value(
key=key, value=value, project_id=project2.id, environment_id=env2.id
)
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)],
)
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, self.environment.id, key, value
)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, self.environment.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, self.environment.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, self.environment.id, 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)
tagstore.create_tag_value(key=key, value=value, project_id=project.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id)
tagstore.create_event_tag(
key_id=tk.id,
group_id=group.id,
value_id=1,
project_id=project.id,
event_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)
tagstore.create_group_tag_key(key=key,
group_id=group2.id,
project_id=project2.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group2.id,
project_id=project2.id)
tagstore.create_event_tag(
key_id=tk2.id,
group_id=group2.id,
value_id=1,
project_id=project.id,
event_id=1,
)
with self.tasks():
delete_tag_key(object_id=tk.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
assert not tagstore.get_event_tag_qs(key_id=tk.id).exists()
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):
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_simple(self):
user = self.create_user()
project = self.create_project()
project2 = self.create_project(organization=project.organization)
release = Release.objects.create(
organization_id=project.organization_id, version=uuid4().hex
)
release.add_project(project)
release.add_project(project2)
ReleaseProject.objects.filter(release=release, project=project).update(new_groups=1)
ReleaseProject.objects.filter(release=release, project=project2).update(new_groups=1)
environment = Environment.objects.create(
organization_id=project.organization_id,
name='prod',
)
environment.add_project(project)
environment.add_project(project2)
ReleaseProjectEnvironment.objects.create(
project_id=project.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
ReleaseProjectEnvironment.objects.create(
project_id=project2.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
key = 'sentry:release'
value = release.version
tagstore.create_tag_value(
project_id=project.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now(),
last_seen=timezone.now(),
times_seen=5,
)
tagstore.create_tag_value(
project_id=project2.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now() - datetime.timedelta(days=2),
last_seen=timezone.now() - datetime.timedelta(days=1),
times_seen=5,
)
commit_author = CommitAuthor.objects.create(
name='stebe',
email='*****@*****.**',
organization_id=project.organization_id,
)
commit = Commit.objects.create(
organization_id=project.organization_id,
repository_id=1,
key='abc',
author=commit_author,
message='waddap',
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=1,
)
release.update(
authors=[six.text_type(commit_author.id)],
commit_count=1,
last_commit_id=commit.id,
)
result = serialize(release, user)
assert result['version'] == release.version
assert result['shortVersion'] == release.version
# should be sum of all projects
assert result['newGroups'] == 2
# should be tags from all projects
tagvalue1 = tagstore.get_tag_value(project.id, None, key, value)
tagvalue2 = tagstore.get_tag_value(project2.id, None, key, value)
assert result['firstEvent'] == tagvalue2.first_seen
assert result['lastEvent'] == tagvalue1.last_seen
assert result['commitCount'] == 1
assert result['authors'] == [{'name': 'stebe', 'email': '*****@*****.**'}]
result = serialize(release, user, project=project)
# should be groups from one project
assert result['newGroups'] == 1
# should be tags from one project
assert result['firstEvent'] == tagvalue1.first_seen
assert result['lastEvent'] == tagvalue1.last_seen
# Make sure a sha1 value gets truncated
release.version = '0' * 40
result = serialize(release, user)
assert result['shortVersion'] == '0' * 7
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)
tagstore.create_tag_value(key=key, value=value, project_id=project.id)
GroupTagKey.objects.create(key=key,
group_id=group.id,
project_id=project.id)
GroupTagValue.objects.create(key=key,
value=value,
group_id=group.id,
project_id=project.id)
EventTag.objects.create(
key_id=tk.id,
group_id=group.id,
value_id=1,
project_id=project.id,
event_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)
gtk2 = GroupTagKey.objects.create(key=key,
group_id=group2.id,
project_id=project2.id)
gtv2 = GroupTagValue.objects.create(key=key,
value=value,
group_id=group2.id,
project_id=project2.id)
EventTag.objects.create(
key_id=tk2.id,
group_id=group2.id,
value_id=1,
project_id=project.id,
event_id=1,
)
with self.tasks():
delete_tag_key(object_id=tk.id)
assert not GroupTagValue.objects.filter(
key=tk.key, project_id=project.id).exists()
assert not GroupTagKey.objects.filter(
key=tk.key, project_id=project.id).exists()
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
assert not EventTag.objects.filter(key_id=tk.id).exists()
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(key=key,
project_id=project2.id) is not None
assert GroupTagKey.objects.filter(id=gtk2.id).exists()
assert GroupTagValue.objects.filter(id=gtv2.id).exists()
assert EventTag.objects.filter(key_id=tk2.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()
