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):
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 _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 _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_user_delta_reached(self):
snooze = GroupSnooze.objects.create(
group=self.group, user_count=100, state={"users_seen": 0}
)
tagstore.create_group_tag_key(
project_id=self.group.project_id,
group_id=self.group.id,
environment_id=None,
key="sentry:user",
values_seen=100,
)
assert not snooze.is_valid(test_rates=True)
def test_user_delta_reached(self):
snooze = GroupSnooze.objects.create(
group=self.group,
user_count=100,
state={'users_seen': 0},
)
tagstore.create_group_tag_key(
project_id=self.group.project_id,
group_id=self.group.id,
key='sentry:user',
values_seen=100,
)
assert not snooze.is_valid(test_rates=True)
def test_user_delta_reached(self):
snooze = GroupSnooze.objects.create(
group=self.group,
user_count=100,
state={'users_seen': 0},
)
tagstore.create_group_tag_key(
project_id=self.group.project_id,
group_id=self.group.id,
environment_id=self.environment.id,
key='sentry:user',
values_seen=100,
)
assert not snooze.is_valid(test_rates=True)
def test_snooze_user_count(self):
group = self.create_group(
checksum='a' * 32,
status=GroupStatus.RESOLVED,
)
tagstore.create_group_tag_key(
group.project_id,
group.id,
None,
'sentry:user',
values_seen=100,
)
self.login_as(user=self.user)
url = '{url}?id={group.id}'.format(
url=self.path,
group=group,
)
response = self.client.put(url,
data={
'status': 'ignored',
'ignoreUserCount': 100,
},
format='json')
assert response.status_code == 200
snooze = GroupSnooze.objects.get(group=group)
assert snooze.count is None
assert snooze.until is None
assert snooze.user_count == 100
assert snooze.user_window is None
assert snooze.window is None
assert snooze.state['users_seen'] == 100
assert response.data['status'] == 'ignored'
assert response.data['statusDetails']['ignoreCount'] == snooze.count
assert response.data['statusDetails']['ignoreWindow'] == snooze.window
assert response.data['statusDetails'][
'ignoreUserCount'] == snooze.user_count
assert response.data['statusDetails'][
'ignoreUserWindow'] == snooze.user_window
assert response.data['statusDetails']['ignoreUntil'] == snooze.until
assert response.data['statusDetails']['actor']['id'] == six.text_type(
self.user.id)
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_snooze_user_count(self):
group = self.create_group(
checksum='a' * 32,
status=GroupStatus.RESOLVED,
)
tagstore.create_group_tag_key(
group.project_id,
group.id,
self.environment.id,
'sentry:user',
values_seen=100,
)
self.login_as(user=self.user)
url = '{url}?id={group.id}'.format(
url=self.path,
group=group,
)
response = self.client.put(
url, data={
'status': 'ignored',
'ignoreUserCount': 100,
}, format='json'
)
assert response.status_code == 200
snooze = GroupSnooze.objects.get(group=group)
assert snooze.count is None
assert snooze.until is None
assert snooze.user_count == 100
assert snooze.user_window is None
assert snooze.window is None
assert snooze.state['users_seen'] == 100
assert response.data['status'] == 'ignored'
assert response.data['statusDetails']['ignoreCount'] == snooze.count
assert response.data['statusDetails']['ignoreWindow'] == snooze.window
assert response.data['statusDetails']['ignoreUserCount'] == snooze.user_count
assert response.data['statusDetails']['ignoreUserWindow'] == snooze.user_window
assert response.data['statusDetails']['ignoreUntil'] == snooze.until
assert response.data['statusDetails']['actor']['id'] == six.text_type(self.user.id)
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(self):
user = self.create_user()
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key='key')
grouptagkey = tagstore.create_group_tag_key(
project_id=project.id,
group_id=self.create_group(project=project).id,
environment_id=self.environment.id,
key=tagkey.key)
result = serialize(grouptagkey, user)
assert result['id'] == six.text_type(grouptagkey.id)
assert result['key'] == 'key'
def test(self):
user = self.create_user()
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
key='key'
)
grouptagkey = tagstore.create_group_tag_key(
project_id=project.id,
group_id=self.create_group(project=project).id,
key=tagkey.key
)
result = serialize(grouptagkey, user)
assert result['id'] == six.text_type(grouptagkey.id)
assert result['key'] == 'key'
def test_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):
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)
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):
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.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):
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_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()
