def test_minimal(self):
kwargs = {
"message": "hello",
"tags": {
"foo": "bar"
},
"timestamp": iso_format(before_now(seconds=1)),
}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)["id"]
instance = self.get_event(event_id)
assert instance.message == "hello"
assert instance.data["logentry"] == {"formatted": "hello"}
assert instance.title == instance.data["title"] == "hello"
assert instance.location is instance.data.get("location", None) is None
assert tagstore.get_tag_key(self.project.id, None, "foo") is not None
assert tagstore.get_tag_value(self.project.id, None, "foo",
"bar") is not None
assert (tagstore.get_group_tag_key(self.project.id, instance.group_id,
None, "foo") is not None)
assert (tagstore.get_group_tag_value(instance.project_id,
instance.group_id, None, "foo",
"bar") is not None)
def test_minimal(self):
event_data = {
"message": "hello",
"tags": {
"foo": "bar"
},
"timestamp": iso_format(before_now(seconds=1)),
}
event = self.store_event(event_data, self.project.id)
assert event is not None
instance = self.get_event(event.event_id)
assert instance.message == "hello"
assert instance.data["logentry"] == {"formatted": "hello"}
assert instance.title == instance.data["title"] == "hello"
assert instance.location is instance.data.get("location", None) is None
assert tagstore.get_tag_key(self.project.id, None, "foo") is not None
assert tagstore.get_tag_value(self.project.id, None, "foo",
"bar") is not None
assert (tagstore.get_group_tag_key(self.project.id, instance.group_id,
None, "foo") is not None)
assert (tagstore.get_group_tag_value(instance.project_id,
instance.group_id, None, "foo",
"bar") is not None)
def test_minimal(self):
kwargs = {'message': 'hello', 'tags': {'foo': 'bar'}}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)['id']
instance = Event.objects.get(event_id=event_id)
Event.objects.bind_nodes([instance], 'data')
assert instance.message == 'hello'
assert instance.data['logentry'] == {'formatted': 'hello'}
assert instance.title == instance.data['title'] == 'hello'
assert instance.location is instance.data.get('location', None) is None
assert tagstore.get_tag_key(self.project.id, None, 'foo') is not None
assert tagstore.get_tag_value(self.project.id, None, 'foo', 'bar') is not None
assert tagstore.get_group_tag_key(
self.project.id, instance.group_id, None, 'foo') is not None
assert tagstore.get_group_tag_value(
instance.project_id,
instance.group_id,
None,
'foo',
'bar') is not None
def test_minimal(self):
kwargs = {'message': 'hello', 'tags': {'foo': 'bar'}}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)['id']
instance = Event.objects.get(event_id=event_id)
Event.objects.bind_nodes([instance], 'data')
assert instance.message == 'hello'
assert instance.data['logentry'] == {'formatted': 'hello'}
assert instance.title == instance.data['title'] == 'hello'
assert instance.location is instance.data.get('location', None) is None
assert tagstore.get_tag_key(self.project.id, None, 'foo') is not None
assert tagstore.get_tag_value(self.project.id, None, 'foo', 'bar') is not None
assert tagstore.get_group_tag_key(
self.project.id, instance.group_id, None, 'foo') is not None
assert tagstore.get_group_tag_value(
instance.project_id,
instance.group_id,
None,
'foo',
'bar') is not None
def test_exception(self):
kwargs = {
"exception": {
"type": "ZeroDivisionError",
"value": "cannot divide by zero",
"stacktrace": {
"frames": [
{
"filename": "utils.py",
"in_app": False,
"function": "raise_it",
"module": "utils",
},
{
"filename": "main.py",
"in_app": True,
"function": "fail_it",
"module": "main",
},
]
},
},
"tags": {
"foo": "bar"
},
"timestamp": iso_format(before_now(seconds=1)),
}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)["id"]
instance = self.get_event(event_id)
assert len(instance.data["exception"]) == 1
assert (instance.title == instance.data["title"] ==
"ZeroDivisionError: cannot divide by zero")
assert instance.location == instance.data["location"] == "main.py"
assert instance.culprit == instance.data["culprit"] == "main in fail_it"
assert tagstore.get_tag_key(self.project.id, None, "foo") is not None
assert tagstore.get_tag_value(self.project.id, None, "foo",
"bar") is not None
assert (tagstore.get_group_tag_key(self.project.id, instance.group_id,
None, "foo") is not None)
assert (tagstore.get_group_tag_value(instance.project_id,
instance.group_id, None, "foo",
"bar") is not None)
def test_minimal(self):
kwargs = {'message': 'hello', 'tags': {'foo': 'bar'}}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)['id']
instance = Event.objects.get(event_id=event_id)
assert instance.message == 'hello'
assert tagstore.get_tag_key(self.project.id, 'foo') is not None
assert tagstore.get_tag_value(self.project.id, 'foo', 'bar') is not None
assert tagstore.get_group_tag_key(instance.group_id, 'foo') is not None
assert tagstore.get_group_tag_value(instance.group_id, 'foo', 'bar') is not None
def test_exception(self):
event_data = {
"exception": {
"type": "ZeroDivisionError",
"value": "cannot divide by zero",
"stacktrace": {
"frames": [
{
"filename": "utils.py",
"in_app": False,
"function": "raise_it",
"module": "utils",
},
{
"filename": "main.py",
"in_app": True,
"function": "fail_it",
"module": "main",
},
]
},
},
"tags": {
"foo": "bar"
},
"timestamp": iso_format(before_now(seconds=1)),
}
event = self.store_event(event_data, self.project.id)
assert event is not None
instance = self.get_event(event.event_id)
assert len(instance.data["exception"]) == 1
assert (instance.title == instance.data["title"] ==
"ZeroDivisionError: cannot divide by zero")
assert instance.location == instance.data["location"] == "main.py"
assert instance.culprit == instance.data["culprit"] == "main in fail_it"
assert tagstore.get_tag_key(self.project.id, None, "foo") is not None
assert tagstore.get_tag_value(self.project.id, None, "foo",
"bar") is not None
assert (tagstore.get_group_tag_key(self.project.id, instance.group_id,
None, "foo") is not None)
assert (tagstore.get_group_tag_value(instance.project_id,
instance.group_id, None, "foo",
"bar") is not None)
def test_exception(self):
kwargs = {
'exception': {
'type': 'ZeroDivisionError',
'value': 'cannot divide by zero',
'stacktrace': {
'frames': [{
'filename': 'utils.py',
'in_app': False,
'function': 'raise_it',
'module': 'utils',
}, {
'filename': 'main.py',
'in_app': True,
'function': 'fail_it',
'module': 'main',
}]
}
},
'tags': {
'foo': 'bar'
}
}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)['id']
instance = Event.objects.get(event_id=event_id)
Event.objects.bind_nodes([instance], 'data')
assert len(instance.data['exception']) == 1
assert instance.title == instance.data[
'title'] == 'ZeroDivisionError: cannot divide by zero'
assert instance.location == instance.data['location'] == 'main.py'
assert instance.culprit == instance.data['culprit'] == 'main in fail_it'
assert tagstore.get_tag_key(self.project.id, None, 'foo') is not None
assert tagstore.get_tag_value(self.project.id, None, 'foo',
'bar') is not None
assert tagstore.get_group_tag_key(self.project.id, instance.group_id,
None, 'foo') is not None
assert tagstore.get_group_tag_value(instance.project_id,
instance.group_id, None, 'foo',
'bar') is not None
def test_minimal(self):
kwargs = {'message': 'hello', 'tags': {'foo': 'bar'}}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)['id']
instance = Event.objects.get(event_id=event_id)
assert instance.message == 'hello'
assert tagstore.get_tag_key(self.project.id, 'foo') is not None
assert tagstore.get_tag_value(self.project.id, 'foo',
'bar') is not None
assert tagstore.get_group_tag_key(instance.group_id, 'foo') is not None
assert tagstore.get_group_tag_value(instance.group_id, 'foo',
'bar') is not None
def test_exception(self):
kwargs = {'exception': {
'type': 'ZeroDivisionError',
'value': 'cannot divide by zero',
'stacktrace': {'frames': [
{
'filename': 'utils.py',
'in_app': False,
'function': 'raise_it',
'module': 'utils',
},
{
'filename': 'main.py',
'in_app': True,
'function': 'fail_it',
'module': 'main',
}
]}
}, 'tags': {'foo': 'bar'}}
resp = self._postWithHeader(kwargs)
assert resp.status_code == 200, resp.content
event_id = json.loads(resp.content)['id']
instance = Event.objects.get(event_id=event_id)
Event.objects.bind_nodes([instance], 'data')
assert len(instance.data['exception']) == 1
assert instance.title == instance.data['title'] == 'ZeroDivisionError: cannot divide by zero'
assert instance.location == instance.data['location'] == 'main.py'
assert instance.culprit == instance.data['culprit'] == 'main in fail_it'
assert tagstore.get_tag_key(self.project.id, None, 'foo') is not None
assert tagstore.get_tag_value(self.project.id, None, 'foo', 'bar') is not None
assert tagstore.get_group_tag_key(
self.project.id, instance.group_id, None, 'foo') is not None
assert tagstore.get_group_tag_value(
instance.project_id,
instance.group_id,
None,
'foo',
'bar') is not None
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_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.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):
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()
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(project_id=project2.id,
environment_id=env2.id,
key=key,
value=value)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[(tk2.key, tv2.value)],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None,
key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None,
key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id,
env2.id, key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id,
env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.legacy.tasks import delete_tag_key
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key, project_id=project.id)
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_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()
