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 _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"],)
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=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_lookup_by_release(self):
self.login_as(self.user)
project = self.project
project2 = self.create_project(name='baz',
organization=project.organization)
release = Release.objects.create(organization=project.organization,
version='12345')
release.add_project(project)
release.add_project(project2)
group = self.create_group(checksum='a' * 32, project=project)
group2 = self.create_group(checksum='b' * 32, project=project2)
tagstore.create_group_tag_value(project_id=project.id,
group_id=group.id,
key='sentry:release',
value=release.version)
tagstore.create_group_tag_value(project_id=project2.id,
group_id=group2.id,
key='sentry:release',
value=release.version)
url = '%s?query=%s' % (self.path,
quote('release:"%s"' % release.version))
response = self.client.get(url, format='json')
issues = json.loads(response.content)
assert response.status_code == 200
assert len(issues) == 1
assert int(issues[0]['id']) == group.id
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_lookup_by_release(self):
self.login_as(self.user)
project = self.project
project2 = self.create_project(name='baz', organization=project.organization)
release = Release.objects.create(organization=project.organization, version='12345')
release.add_project(project)
release.add_project(project2)
group = self.create_group(checksum='a' * 32, project=project)
group2 = self.create_group(checksum='b' * 32, project=project2)
tagstore.create_group_tag_value(
project_id=project.id, group_id=group.id, environment_id=self.environment.id,
key='sentry:release', value=release.version
)
tagstore.create_group_tag_value(
project_id=project2.id, group_id=group2.id, environment_id=self.environment.id,
key='sentry:release', value=release.version
)
url = '%s?query=%s' % (self.path, quote('release:"%s"' % release.version))
response = self.client.get(url, format='json')
issues = json.loads(response.content)
assert response.status_code == 200
assert len(issues) == 1
assert int(issues[0]['id']) == group.id
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):
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_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_first_release_from_tag(self):
project = self.create_project()
release = Release.objects.create(
version='a',
organization_id=project.organization_id,
)
release.add_project(project)
group = self.create_group(project=project, )
tagstore.create_group_tag_value(project_id=project.id,
group_id=group.id,
key='sentry:release',
value=release.version)
assert group.first_release is None
assert group.get_first_release() == release.version
assert group.get_last_release() == release.version
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_first_release_from_tag(self):
project = self.create_project()
release = Release.objects.create(
version='a',
organization_id=project.organization_id,
)
release.add_project(project)
group = self.create_group(
project=project,
)
tagstore.create_group_tag_value(
project_id=project.id, group_id=group.id, key='sentry:release', value=release.version
)
assert group.first_release is None
assert group.get_first_release() == release.version
assert group.get_last_release() == release.version
def test_first_release_from_tag(self):
project = self.create_project()
release = Release.objects.create(
version="a", organization_id=project.organization_id)
release.add_project(project)
group = self.create_group(project=project)
tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key="sentry:release",
value=release.version,
)
assert group.first_release is None
assert group.get_first_release() == release.version
assert group.get_last_release() == release.version
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):
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):
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):
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_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(OrganizationUserIssuesSearchTest, self).setUp()
self.org = self.create_organization()
self.org.flags.allow_joinleave = False
self.org.save()
self.team1 = self.create_team(organization=self.org)
self.team2 = self.create_team(organization=self.org)
self.project1 = self.create_project(team=self.team1)
self.project2 = self.create_project(team=self.team2)
group1 = self.create_group(project=self.project1,
last_seen=timezone.now() -
timedelta(minutes=1))
group2 = self.create_group(project=self.project2)
EventUser.objects.create(email='*****@*****.**',
project_id=self.project1.id)
EventUser.objects.create(email='*****@*****.**',
project_id=self.project1.id)
EventUser.objects.create(email='*****@*****.**',
project_id=self.project2.id)
tagstore.create_group_tag_value(key='sentry:user',
value='email:[email protected]',
group_id=group1.id,
project_id=self.project1.id)
tagstore.create_group_tag_value(key='sentry:user',
value='email:[email protected]',
group_id=group1.id,
project_id=self.project1.id)
tagstore.create_group_tag_value(key='sentry:user',
value='email:[email protected]',
group_id=group2.id,
project_id=self.project2.id)
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_with_first_release(self):
self.login_as(user=self.user)
group = self.create_group()
release = Release.objects.create(
organization_id=group.project.organization_id, version="1.0")
release.add_project(group.project)
tagstore.create_group_tag_value(
group_id=group.id,
project_id=group.project_id,
environment_id=self.environment.id,
key="sentry:release",
value=release.version,
)
url = u"/api/0/issues/{}/".format(group.id)
response = self.client.get(url, format="json")
assert response.status_code == 200, response.content
assert response.data["id"] == six.text_type(group.id)
assert response.data["firstRelease"]["version"] == release.version
def test_with_first_release(self):
self.login_as(user=self.user)
group = self.create_group()
release = Release.objects.create(
organization_id=group.project.organization_id,
version='1.0',
)
release.add_project(group.project)
tagstore.create_group_tag_value(
group_id=group.id,
project_id=group.project_id,
key='sentry:release',
value=release.version,
)
url = '/api/0/issues/{}/'.format(group.id)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert response.data['id'] == six.text_type(group.id)
assert response.data['firstRelease']['version'] == release.version
def test_with_first_release(self):
self.login_as(user=self.user)
group = self.create_group()
release = Release.objects.create(
organization_id=group.project.organization_id,
version='1.0',
)
release.add_project(group.project)
tagstore.create_group_tag_value(
group_id=group.id,
project_id=group.project_id,
key='sentry:release',
value=release.version,
)
url = '/api/0/issues/{}/'.format(group.id)
response = self.client.get(url, format='json')
assert response.status_code == 200, response.content
assert response.data['id'] == six.text_type(group.id)
assert response.data['firstRelease']['version'] == release.version
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 setUp(self):
super(OrganizationUserIssuesTest, self).setUp()
self.org = self.create_organization()
self.org.flags.allow_joinleave = False
self.org.save()
self.team1 = self.create_team(organization=self.org)
self.team2 = self.create_team(organization=self.org)
self.project1 = self.create_project(team=self.team1)
self.project2 = self.create_project(team=self.team2)
self.group1 = self.create_group(
project=self.project1,
last_seen=timezone.now() - timedelta(minutes=1),
)
self.group2 = self.create_group(
project=self.project2,
)
self.euser1 = EventUser.objects.create(email='*****@*****.**', project_id=self.project1.id)
self.euser2 = EventUser.objects.create(email='*****@*****.**', project_id=self.project1.id)
self.euser3 = EventUser.objects.create(email='*****@*****.**', project_id=self.project2.id)
tagstore.create_group_tag_value(
key='sentry:user',
value=self.euser1.tag_value,
group_id=self.group1.id,
project_id=self.project1.id,
environment_id=self.environment.id,
)
tagstore.create_group_tag_value(
key='sentry:user',
value=self.euser2.tag_value,
group_id=self.group1.id,
project_id=self.project1.id,
environment_id=self.environment.id,
)
tagstore.create_group_tag_value(
key='sentry:user',
value=self.euser3.tag_value,
group_id=self.group2.id,
project_id=self.project2.id,
environment_id=self.environment.id,
)
self.path = reverse(
'sentry-api-0-organization-user-issues', args=[
self.org.slug,
self.euser1.id,
]
)
def setUp(self):
super(OrganizationUserIssuesTest, self).setUp()
self.org = self.create_organization()
self.org.flags.allow_joinleave = False
self.org.save()
self.team1 = self.create_team(organization=self.org)
self.team2 = self.create_team(organization=self.org)
self.project1 = self.create_project(teams=[self.team1])
self.project2 = self.create_project(teams=[self.team2])
self.group1 = self.create_group(
project=self.project1,
last_seen=timezone.now() - timedelta(minutes=1),
)
self.group2 = self.create_group(
project=self.project2,
)
self.euser1 = EventUser.objects.create(email='*****@*****.**', project_id=self.project1.id)
self.euser2 = EventUser.objects.create(email='*****@*****.**', project_id=self.project1.id)
self.euser3 = EventUser.objects.create(email='*****@*****.**', project_id=self.project2.id)
tagstore.create_group_tag_value(
key='sentry:user',
value=self.euser1.tag_value,
group_id=self.group1.id,
project_id=self.project1.id,
environment_id=None,
)
tagstore.create_group_tag_value(
key='sentry:user',
value=self.euser2.tag_value,
group_id=self.group1.id,
project_id=self.project1.id,
environment_id=None,
)
tagstore.create_group_tag_value(
key='sentry:user',
value=self.euser3.tag_value,
group_id=self.group2.id,
project_id=self.project2.id,
environment_id=None,
)
self.path = reverse(
'sentry-api-0-organization-user-issues', args=[
self.org.slug,
self.euser1.id,
]
)
def setUp(self):
super(OrganizationUserIssuesSearchTest, self).setUp()
self.org = self.create_organization()
self.org.flags.allow_joinleave = False
self.org.save()
self.team1 = self.create_team(organization=self.org)
self.team2 = self.create_team(organization=self.org)
self.project1 = self.create_project(teams=[self.team1])
self.project2 = self.create_project(teams=[self.team2])
group1 = self.create_group(
project=self.project1, last_seen=timezone.now() - timedelta(minutes=1)
)
group2 = self.create_group(project=self.project2)
EventUser.objects.create(email='*****@*****.**', project_id=self.project1.id)
EventUser.objects.create(email='*****@*****.**', project_id=self.project1.id)
EventUser.objects.create(email='*****@*****.**', project_id=self.project2.id)
tagstore.create_group_tag_value(
key='sentry:user',
value='email:[email protected]',
group_id=group1.id,
environment_id=None,
project_id=self.project1.id
)
tagstore.create_group_tag_value(
key='sentry:user',
value='email:[email protected]',
group_id=group1.id,
environment_id=None,
project_id=self.project1.id
)
tagstore.create_group_tag_value(
key='sentry:user',
value='email:[email protected]',
group_id=group2.id,
environment_id=None,
project_id=self.project2.id
)
def setUp(self):
self.backend = self.create_backend()
self.group1 = self.create_group(
project=self.project,
checksum='a' * 32,
message='foo',
times_seen=5,
status=GroupStatus.UNRESOLVED,
last_seen=datetime(2013, 8, 13, 3, 8, 24, 880386),
first_seen=datetime(2013, 7, 13, 3, 8, 24, 880386),
score=ScoreClause.calculate(
times_seen=5,
last_seen=datetime(2013, 8, 13, 3, 8, 24, 880386),
),
)
self.event1 = self.create_event(event_id='a' * 32,
group=self.group1,
datetime=datetime(
2013, 7, 13, 3, 8, 24, 880386),
tags={
'server': 'example.com',
'environment': 'production',
})
self.event3 = self.create_event(event_id='c' * 32,
group=self.group1,
datetime=datetime(
2013, 8, 13, 3, 8, 24, 880386),
tags={
'server': 'example.com',
'environment': 'production',
})
self.group2 = self.create_group(
project=self.project,
checksum='b' * 32,
message='bar',
times_seen=10,
status=GroupStatus.RESOLVED,
last_seen=datetime(2013, 7, 14, 3, 8, 24, 880386),
first_seen=datetime(2013, 7, 14, 3, 8, 24, 880386),
score=ScoreClause.calculate(
times_seen=10,
last_seen=datetime(2013, 7, 14, 3, 8, 24, 880386),
),
)
self.event2 = self.create_event(event_id='b' * 32,
group=self.group2,
datetime=datetime(
2013, 7, 14, 3, 8, 24, 880386),
tags={
'server': 'example.com',
'environment': 'staging',
'url': 'http://example.com',
})
for key, value in self.event1.data['tags']:
tagstore.create_group_tag_value(
project_id=self.group1.project_id,
group_id=self.group1.id,
environment_id=None,
key=key,
value=value,
)
for key, value in self.event2.data['tags']:
tagstore.create_group_tag_value(
project_id=self.group2.project_id,
group_id=self.group2.id,
environment_id=None,
key=key,
value=value,
)
GroupBookmark.objects.create(
user=self.user,
group=self.group2,
project=self.group2.project,
)
GroupAssignee.objects.create(
user=self.user,
group=self.group2,
project=self.group2.project,
)
GroupSubscription.objects.create(
user=self.user,
group=self.group1,
project=self.group1.project,
is_active=True,
)
GroupSubscription.objects.create(
user=self.user,
group=self.group2,
project=self.group2.project,
is_active=False,
)
def test_merge_updates_tag_values_seen(self):
project = self.create_project()
target, other = [self.create_group(project) for _ in range(0, 2)]
data = {
'sentry:user': {
'id:1': {
target: 2,
},
'id:2': {
other: 3,
},
'id:3': {
target: 1,
other: 2,
},
},
'key': {
'foo': {
other: 3,
},
},
}
input_group_tag_keys = defaultdict(int) # [(group, key)] = values_seen
input_group_tag_values = defaultdict(int) # [(group, key, value)] = times_seen
output_group_tag_keys = defaultdict(int) # [key] = values_seen
output_group_tag_values = defaultdict(int) # [(key, value)] = times_seen
for key, values in data.items():
output_group_tag_keys[key] = len(values)
for value, groups in values.items():
for group, count in groups.items():
input_group_tag_keys[(group, key)] += 1
input_group_tag_values[(group, key, value)] += count
output_group_tag_values[(key, value)] += count
for ((group, key), values_seen) in input_group_tag_keys.items():
tagstore.create_group_tag_key(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
values_seen=values_seen,
)
for ((group, key, value), times_seen) in input_group_tag_values.items():
tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
times_seen=times_seen,
)
with self.tasks():
merge_group(other.id, target.id)
assert not Group.objects.filter(id=other.id).exists()
assert len(
tagstore.get_group_tag_keys(
other.project_id,
other.id,
environment_id=self.environment.id)) == 0
assert len(
GroupTagValue.objects.filter(
project_id=other.project_id,
group_id=other.id,
)) == 0
for key, values_seen in output_group_tag_keys.items():
assert tagstore.get_group_tag_key(
target.project_id, target.id, environment_id=self.environment.id, key=key).values_seen == values_seen
for (key, value), times_seen in output_group_tag_values.items():
assert tagstore.get_group_tag_value(
project_id=target.project_id,
group_id=target.id,
environment_id=self.environment.id,
key=key,
value=value,
).times_seen == times_seen
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 setUp(self):
self.backend = self.create_backend()
self.project1 = self.create_project(name='foo')
self.project2 = self.create_project(name='bar')
self.group1 = self.create_group(
project=self.project1,
checksum='a' * 32,
message='foo',
times_seen=5,
status=GroupStatus.UNRESOLVED,
last_seen=datetime(2013, 8, 13, 3, 8, 24, 880386),
first_seen=datetime(2013, 7, 13, 3, 8, 24, 880386),
)
self.event1 = self.create_event(
event_id='a' * 32,
group=self.group1,
datetime=datetime(2013, 7, 13, 3, 8, 24, 880386),
tags={
'server': 'example.com',
'env': 'production',
}
)
self.event3 = self.create_event(
event_id='c' * 32,
group=self.group1,
datetime=datetime(2013, 8, 13, 3, 8, 24, 880386),
tags={
'server': 'example.com',
'env': 'production',
}
)
self.group2 = self.create_group(
project=self.project1,
checksum='b' * 32,
message='bar',
times_seen=10,
status=GroupStatus.RESOLVED,
last_seen=datetime(2013, 7, 14, 3, 8, 24, 880386),
first_seen=datetime(2013, 7, 14, 3, 8, 24, 880386),
)
self.event2 = self.create_event(
event_id='b' * 32,
group=self.group2,
datetime=datetime(2013, 7, 14, 3, 8, 24, 880386),
tags={
'server': 'example.com',
'env': 'staging',
'url': 'http://example.com',
}
)
for key, value in self.event1.data['tags']:
tagstore.create_group_tag_value(
project_id=self.group1.project_id,
group_id=self.group1.id,
key=key,
value=value,
)
for key, value in self.event2.data['tags']:
tagstore.create_group_tag_value(
project_id=self.group2.project_id,
group_id=self.group2.id,
key=key,
value=value,
)
GroupBookmark.objects.create(
user=self.user,
group=self.group2,
project=self.group2.project,
)
GroupAssignee.objects.create(
user=self.user,
group=self.group2,
project=self.group2.project,
)
GroupSubscription.objects.create(
user=self.user,
group=self.group1,
project=self.group1.project,
is_active=True,
)
GroupSubscription.objects.create(
user=self.user,
group=self.group2,
project=self.group2.project,
is_active=False,
)
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):
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,
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):
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):
key, value = "foo", u"b\xe4r"
project = self.create_project()
if settings.SENTRY_TAGSTORE in [
"sentry.tagstore.snuba.SnubaCompatibilityTagStorage",
"sentry.tagstore.snuba.SnubaTagStorage",
]:
event_timestamp = iso_format(before_now(seconds=1))
event = self.store_event(
data={
"tags": {
key: value
},
"timestamp": event_timestamp,
"environment": self.environment.name,
},
project_id=project.id,
assert_no_errors=False,
)
group = event.group
first_seen = datetime.strptime(
event_timestamp,
"%Y-%m-%dT%H:%M:%S").strftime("%Y-%m-%dT%H:%M:%S.%fZ")
last_seen = first_seen
else:
from django.utils import timezone
from sentry import tagstore
now = timezone.now()
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,
)
first_seen = group_tag_value.first_seen.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
last_seen = group_tag_value.last_seen.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
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] == last_seen
assert bits[3] == first_seen
def test_merge_updates_tag_values_seen(self):
project = self.create_project()
target, other = [self.create_group(project) for _ in range(0, 2)]
data = {
'sentry:user': {
'id:1': {
target: 2,
},
'id:2': {
other: 3,
},
'id:3': {
target: 1,
other: 2,
},
},
'key': {
'foo': {
other: 3,
},
},
}
input_group_tag_keys = defaultdict(int) # [(group, key)] = values_seen
input_group_tag_values = defaultdict(
int) # [(group, key, value)] = times_seen
output_group_tag_keys = defaultdict(int) # [key] = values_seen
output_group_tag_values = defaultdict(
int) # [(key, value)] = times_seen
for key, values in data.items():
output_group_tag_keys[key] = len(values)
for value, groups in values.items():
for group, count in groups.items():
input_group_tag_keys[(group, key)] += 1
input_group_tag_values[(group, key, value)] += count
output_group_tag_values[(key, value)] += count
for ((group, key), values_seen) in input_group_tag_keys.items():
tagstore.create_group_tag_key(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
values_seen=values_seen,
)
for ((group, key, value),
times_seen) in input_group_tag_values.items():
tagstore.create_group_tag_value(
project_id=project.id,
group_id=group.id,
environment_id=self.environment.id,
key=key,
value=value,
times_seen=times_seen,
)
with self.tasks():
merge_group(other.id, target.id)
assert not Group.objects.filter(id=other.id).exists()
assert len(
tagstore.get_group_tag_keys(
other.project_id, other.id,
environment_id=self.environment.id)) == 0
assert len(
GroupTagValue.objects.filter(
project_id=other.project_id,
group_id=other.id,
)) == 0
for key, values_seen in output_group_tag_keys.items():
assert tagstore.get_group_tag_key(
target.project_id,
target.id,
environment_id=self.environment.id,
key=key).values_seen == values_seen
for (key, value), times_seen in output_group_tag_values.items():
assert tagstore.get_group_tag_value(
project_id=target.project_id,
group_id=target.id,
environment_id=self.environment.id,
key=key,
value=value,
).times_seen == times_seen
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()
