def test_simple(self):
group = self.create_group(project=self.project)
event = self.create_event(group=group)
with self.tasks():
index_event_tags.delay(
event_id=event.id,
group_id=group.id,
project_id=self.project.id,
environment_id=self.environment.id,
organization_id=self.project.organization_id,
tags=[('foo', 'bar'), ('biz', 'baz')],
)
tags = list(EventTag.objects.filter(
event_id=event.id,
).values_list('key_id', 'value_id'))
assert len(tags) == 2
tagkey = tagstore.get_tag_key(
project_id=self.project.id,
environment_id=self.environment.id,
key='foo',
)
tagvalue = tagstore.get_tag_value(
project_id=self.project.id,
environment_id=self.environment.id,
key='foo',
value='bar',
)
assert (tagkey.id, tagvalue.id) in tags
tagkey = tagstore.get_tag_key(
project_id=self.project.id,
environment_id=self.environment.id,
key='biz',
)
tagvalue = tagstore.get_tag_value(
project_id=self.project.id,
environment_id=self.environment.id,
key='biz',
value='baz',
)
assert (tagkey.id, tagvalue.id) in tags
# ensure it safely handles repeat runs
with self.tasks():
index_event_tags.delay(
event_id=event.id,
group_id=group.id,
project_id=self.project.id,
environment_id=self.environment.id,
organization_id=self.project.organization_id,
tags=[('foo', 'bar'), ('biz', 'baz')],
)
queryset = EventTag.objects.filter(
event_id=event.id,
)
assert queryset.count() == 2
def test_simple(self):
group = self.create_group(project=self.project)
event = self.create_event(group=group)
with self.tasks():
index_event_tags.delay(
event_id=event.id,
group_id=group.id,
project_id=self.project.id,
environment_id=self.environment.id,
organization_id=self.project.organization_id,
tags=[('foo', 'bar'), ('biz', 'baz')],
)
tags = list(EventTag.objects.filter(
event_id=event.id,
).values_list('key_id', 'value_id'))
assert len(tags) == 2
tagkey = tagstore.get_tag_key(
project_id=self.project.id,
environment_id=self.environment.id,
key='foo',
)
tagvalue = tagstore.get_tag_value(
project_id=self.project.id,
environment_id=self.environment.id,
key='foo',
value='bar',
)
assert (tagkey.id, tagvalue.id) in tags
tagkey = tagstore.get_tag_key(
project_id=self.project.id,
environment_id=self.environment.id,
key='biz',
)
tagvalue = tagstore.get_tag_value(
project_id=self.project.id,
environment_id=self.environment.id,
key='biz',
value='baz',
)
assert (tagkey.id, tagvalue.id) in tags
# ensure it safely handles repeat runs
with self.tasks():
index_event_tags.delay(
event_id=event.id,
group_id=group.id,
project_id=self.project.id,
environment_id=self.environment.id,
organization_id=self.project.organization_id,
tags=[('foo', 'bar'), ('biz', 'baz')],
)
queryset = EventTag.objects.filter(
event_id=event.id,
)
assert queryset.count() == 2
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_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"
},
"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):
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(
key='foo',
project_id=self.project.id,
) is not None
assert tagstore.get_tag_value(
key='foo',
value='bar',
project_id=self.project.id,
) is not None
assert GroupTagKey.objects.filter(
key='foo',
group_id=instance.group_id,
project_id=self.project.id,
).exists()
assert GroupTagValue.objects.filter(
key='foo',
value='bar',
group_id=instance.group_id,
project_id=self.project.id,
).exists()
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_simple(self):
tv = tagstore.create_tag_value(
project_id=self.project.id,
key='sentry:release',
value='1.0',
)
tv = tagstore.get_tag_value(self.project.id, 'sentry:release', '1.0')
assert tv.data['release_id']
release = Release.objects.get(id=tv.data['release_id'])
assert release.version == tv.value
assert release.projects.first() == self.project
assert release.organization == self.project.organization
# ensure we dont hit some kind of error saving it again
tv.save()
def test_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):
tv = tagstore.create_tag_value(
project_id=self.project.id,
key='sentry:release',
value='1.0',
)
tv = tagstore.get_tag_value(self.project.id, 'sentry:release', '1.0')
assert tv.data['release_id']
release = Release.objects.get(id=tv.data['release_id'])
assert release.version == tv.value
assert release.projects.first() == self.project
assert release.organization == self.project.organization
# ensure we dont hit some kind of error saving it again
tv.save()
def test_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):
tv = tagstore.create_tag_value(
project_id=self.project.id,
environment_id=self.environment.id,
key='sentry:release',
value='1.0',
first_seen=datetime(2018, 2, 1, tzinfo=pytz.utc),
)
tv = tagstore.get_tag_value(self.project.id, self.environment.id,
'sentry:release', '1.0')
assert tv.data['release_id']
release = Release.objects.get(id=tv.data['release_id'])
assert release.version == tv.value
assert release.projects.first() == self.project
assert release.organization == self.project.organization
assert release.date_added == tv.first_seen
# ensure we dont hit some kind of error saving it again
tv.save()
tv2 = tagstore.create_tag_value(
project_id=self.create_project(
organization=self.project.organization, ).id,
environment_id=self.environment.id,
key='sentry:release',
value='1.0',
first_seen=datetime(2018, 1, 1, tzinfo=pytz.utc),
)
assert Release.objects.get(id=release.id).date_added == tv2.first_seen
tagstore.create_tag_value(
project_id=self.create_project(
organization=self.project.organization, ).id,
environment_id=self.environment.id,
key='sentry:release',
value='1.0',
first_seen=datetime(2018, 3, 1, tzinfo=pytz.utc),
)
assert Release.objects.get(id=release.id).date_added == tv2.first_seen
def test_simple(self):
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.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):
user = self.create_user()
project = self.create_project()
project2 = self.create_project(organization=project.organization)
release_version = uuid4().hex
release = Release.objects.create(
organization_id=project.organization_id, version=release_version)
release.add_project(project)
release.add_project(project2)
ReleaseProject.objects.filter(release=release,
project=project).update(new_groups=1)
ReleaseProject.objects.filter(release=release,
project=project2).update(new_groups=1)
self.store_event(
data={
"timestamp": iso_format(before_now(seconds=1)),
"release": release_version,
"environment": "prod",
},
project_id=project.id,
)
release = Release.objects.get(version=release_version)
commit_author = CommitAuthor.objects.create(
name="stebe",
email="*****@*****.**",
organization_id=project.organization_id)
commit = Commit.objects.create(
organization_id=project.organization_id,
repository_id=1,
key="abc",
author=commit_author,
message="waddap",
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=1,
)
release.update(authors=[str(commit_author.id)],
commit_count=1,
last_commit_id=commit.id)
result = serialize(release, user)
assert result["version"] == release.version
# should be sum of all projects
assert result["newGroups"] == 2
tagvalue1 = tagstore.get_tag_value(project.id, None, "sentry:release",
release_version)
assert result["lastEvent"] == tagvalue1.last_seen
assert result["commitCount"] == 1
assert result["authors"] == [{
"name": "stebe",
"email": "*****@*****.**"
}]
assert result["version"] == release.version
assert result["versionInfo"]["package"] is None
assert result["versionInfo"]["version"]["raw"] == release_version
assert result["versionInfo"]["buildHash"] == release_version
assert result["versionInfo"]["description"] == release_version[:12]
current_formatted_datetime = datetime.utcnow().strftime(
"%Y-%m-%dT%H:%M:%S+00:00")
current_project_meta = {
"prev_release_version": "[email protected]",
"next_release_version": "[email protected]",
"sessions_lower_bound": current_formatted_datetime,
"sessions_upper_bound": current_formatted_datetime,
"first_release_version": "[email protected]",
"last_release_version": "[email protected]",
}
result = serialize(release,
user,
project=project,
current_project_meta=current_project_meta)
assert result["newGroups"] == 1
assert result["firstEvent"] == tagvalue1.first_seen
assert result["lastEvent"] == tagvalue1.last_seen
assert (result["currentProjectMeta"]["prevReleaseVersion"] ==
current_project_meta["prev_release_version"])
assert (result["currentProjectMeta"]["nextReleaseVersion"] ==
current_project_meta["next_release_version"])
assert (result["currentProjectMeta"]["sessionsLowerBound"] ==
current_project_meta["sessions_lower_bound"])
assert (result["currentProjectMeta"]["sessionsUpperBound"] ==
current_project_meta["sessions_upper_bound"])
assert (result["currentProjectMeta"]["firstReleaseVersion"] ==
current_project_meta["first_release_version"])
assert (result["currentProjectMeta"]["lastReleaseVersion"] ==
current_project_meta["last_release_version"])
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key, project_id=project.id)
tagstore.create_tag_value(key=key, value=value, project_id=project.id)
GroupTagKey.objects.create(key=key,
group_id=group.id,
project_id=project.id)
GroupTagValue.objects.create(key=key,
value=value,
group_id=group.id,
project_id=project.id)
EventTag.objects.create(
key_id=tk.id,
group_id=group.id,
value_id=1,
project_id=project.id,
event_id=1,
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(key=key, project_id=project2.id)
gtk2 = GroupTagKey.objects.create(key=key,
group_id=group2.id,
project_id=project2.id)
gtv2 = GroupTagValue.objects.create(key=key,
value=value,
group_id=group2.id,
project_id=project2.id)
EventTag.objects.create(
key_id=tk2.id,
group_id=group2.id,
value_id=1,
project_id=project.id,
event_id=1,
)
with self.tasks():
delete_tag_key(object_id=tk.id)
assert not GroupTagValue.objects.filter(
key=tk.key, project_id=project.id).exists()
assert not GroupTagKey.objects.filter(
key=tk.key, project_id=project.id).exists()
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
assert not EventTag.objects.filter(key_id=tk.id).exists()
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(key=key,
project_id=project2.id) is not None
assert GroupTagKey.objects.filter(id=gtk2.id).exists()
assert GroupTagValue.objects.filter(id=gtv2.id).exists()
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
team = self.create_team(name="test", slug="test")
project = self.create_project(teams=[team], name="test1", slug="test1")
group = self.create_group(project=project)
key = "foo"
value = "bar"
tk = tagstore.create_tag_key(
key=key, project_id=project.id, environment_id=self.environment.id
)
tv = tagstore.create_tag_value(
key=key, value=value, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_group_tag_key(
key=key, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
environment_id=self.environment.id,
tags=[(tk.key, tv.value)],
)
project2 = self.create_project(teams=[team], name="test2")
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, env2.id, key)
tv2 = tagstore.create_tag_value(
key=key, value=value, project_id=project2.id, environment_id=env2.id
)
tagstore.create_group_tag_key(
key=key, group_id=group2.id, project_id=project2.id, environment_id=env2.id
)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=env2.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[(tk2.key, tv2.value)],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(
group.project_id, group.id, self.environment.id, key, value
)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, self.environment.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, self.environment.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, self.environment.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, env2.id, key) is not None
assert (
tagstore.get_group_tag_value(group2.project_id, group2.id, env2.id, key, value)
is not None
)
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.legacy.tasks import delete_tag_key
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key, project_id=project.id)
tagstore.create_tag_value(key=key, value=value, project_id=project.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id)
tagstore.create_event_tag(
key_id=tk.id,
group_id=group.id,
value_id=1,
project_id=project.id,
event_id=1,
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(key=key, project_id=project2.id)
tagstore.create_group_tag_key(key=key,
group_id=group2.id,
project_id=project2.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group2.id,
project_id=project2.id)
tagstore.create_event_tag(
key_id=tk2.id,
group_id=group2.id,
value_id=1,
project_id=project.id,
event_id=1,
)
with self.tasks():
delete_tag_key(object_id=tk.id)
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
assert not tagstore.get_event_tag_qs(key_id=tk.id).exists()
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_simple(self):
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):
user = self.create_user()
project = self.create_project()
project2 = self.create_project(organization=project.organization)
release = Release.objects.create(
organization_id=project.organization_id, version=uuid4().hex
)
release.add_project(project)
release.add_project(project2)
ReleaseProject.objects.filter(release=release, project=project).update(new_groups=1)
ReleaseProject.objects.filter(release=release, project=project2).update(new_groups=1)
environment = Environment.objects.create(
organization_id=project.organization_id, name="prod"
)
environment.add_project(project)
environment.add_project(project2)
ReleaseProjectEnvironment.objects.create(
project_id=project.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
ReleaseProjectEnvironment.objects.create(
project_id=project2.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
key = "sentry:release"
value = release.version
tagstore.create_tag_value(
project_id=project.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now(),
last_seen=timezone.now(),
times_seen=5,
)
tagstore.create_tag_value(
project_id=project2.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now() - datetime.timedelta(days=2),
last_seen=timezone.now() - datetime.timedelta(days=1),
times_seen=5,
)
commit_author = CommitAuthor.objects.create(
name="stebe", email="*****@*****.**", organization_id=project.organization_id
)
commit = Commit.objects.create(
organization_id=project.organization_id,
repository_id=1,
key="abc",
author=commit_author,
message="waddap",
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=1,
)
release.update(
authors=[six.text_type(commit_author.id)], commit_count=1, last_commit_id=commit.id
)
result = serialize(release, user)
assert result["version"] == release.version
assert result["shortVersion"] == release.version
# should be sum of all projects
assert result["newGroups"] == 2
# should be tags from all projects
tagvalue1 = tagstore.get_tag_value(project.id, None, key, value)
tagvalue2 = tagstore.get_tag_value(project2.id, None, key, value)
assert result["firstEvent"] == tagvalue2.first_seen
assert result["lastEvent"] == tagvalue1.last_seen
assert result["commitCount"] == 1
assert result["authors"] == [{"name": "stebe", "email": "*****@*****.**"}]
result = serialize(release, user, project=project)
# should be groups from one project
assert result["newGroups"] == 1
# should be tags from one project
assert result["firstEvent"] == tagvalue1.first_seen
assert result["lastEvent"] == tagvalue1.last_seen
# Make sure a sha1 value gets truncated
release.version = "0" * 40
result = serialize(release, user)
assert result["shortVersion"] == "0" * 7
def test_simple(self):
user = self.create_user()
project = self.create_project()
project2 = self.create_project(organization=project.organization)
release_version = uuid4().hex
release = Release.objects.create(
organization_id=project.organization_id, version=release_version)
release.add_project(project)
release.add_project(project2)
ReleaseProject.objects.filter(release=release,
project=project).update(new_groups=1)
ReleaseProject.objects.filter(release=release,
project=project2).update(new_groups=1)
self.store_event(
data={
"timestamp": iso_format(before_now(seconds=1)),
"release": release_version,
"environment": "prod",
},
project_id=project.id,
)
release = Release.objects.get(version=release_version)
commit_author = CommitAuthor.objects.create(
name="stebe",
email="*****@*****.**",
organization_id=project.organization_id)
commit = Commit.objects.create(
organization_id=project.organization_id,
repository_id=1,
key="abc",
author=commit_author,
message="waddap",
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=1,
)
release.update(authors=[six.text_type(commit_author.id)],
commit_count=1,
last_commit_id=commit.id)
result = serialize(release, user)
assert result["version"] == release.version
# should be sum of all projects
assert result["newGroups"] == 2
tagvalue1 = tagstore.get_tag_value(project.id, None, "sentry:release",
release_version)
assert result["lastEvent"] == tagvalue1.last_seen
assert result["commitCount"] == 1
assert result["authors"] == [{
"name": "stebe",
"email": "*****@*****.**"
}]
result = serialize(release, user, project=project)
assert result["newGroups"] == 1
assert result["firstEvent"] == tagvalue1.first_seen
assert result["lastEvent"] == tagvalue1.last_seen
def test_simple(self):
user = self.create_user()
project = self.create_project()
project2 = self.create_project(organization=project.organization)
release = Release.objects.create(
organization_id=project.organization_id, version=uuid4().hex
)
release.add_project(project)
release.add_project(project2)
ReleaseProject.objects.filter(release=release, project=project).update(new_groups=1)
ReleaseProject.objects.filter(release=release, project=project2).update(new_groups=1)
environment = Environment.objects.create(
organization_id=project.organization_id,
name='prod',
)
environment.add_project(project)
environment.add_project(project2)
ReleaseProjectEnvironment.objects.create(
project_id=project.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
ReleaseProjectEnvironment.objects.create(
project_id=project2.id,
release_id=release.id,
environment_id=environment.id,
new_issues_count=1,
)
key = 'sentry:release'
value = release.version
tagstore.create_tag_value(
project_id=project.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now(),
last_seen=timezone.now(),
times_seen=5,
)
tagstore.create_tag_value(
project_id=project2.id,
environment_id=None,
key=key,
value=value,
first_seen=timezone.now() - datetime.timedelta(days=2),
last_seen=timezone.now() - datetime.timedelta(days=1),
times_seen=5,
)
commit_author = CommitAuthor.objects.create(
name='stebe',
email='*****@*****.**',
organization_id=project.organization_id,
)
commit = Commit.objects.create(
organization_id=project.organization_id,
repository_id=1,
key='abc',
author=commit_author,
message='waddap',
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=1,
)
release.update(
authors=[six.text_type(commit_author.id)],
commit_count=1,
last_commit_id=commit.id,
)
result = serialize(release, user)
assert result['version'] == release.version
assert result['shortVersion'] == release.version
# should be sum of all projects
assert result['newGroups'] == 2
# should be tags from all projects
tagvalue1 = tagstore.get_tag_value(project.id, None, key, value)
tagvalue2 = tagstore.get_tag_value(project2.id, None, key, value)
assert result['firstEvent'] == tagvalue2.first_seen
assert result['lastEvent'] == tagvalue1.last_seen
assert result['commitCount'] == 1
assert result['authors'] == [{'name': 'stebe', 'email': '*****@*****.**'}]
result = serialize(release, user, project=project)
# should be groups from one project
assert result['newGroups'] == 1
# should be tags from one project
assert result['firstEvent'] == tagvalue1.first_seen
assert result['lastEvent'] == tagvalue1.last_seen
# Make sure a sha1 value gets truncated
release.version = '0' * 40
result = serialize(release, user)
assert result['shortVersion'] == '0' * 7
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(
project_id=project2.id,
environment_id=env2.id,
key=key,
value=value
)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[
(tk2.key, tv2.value)
],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, env2.id, key) is not None
assert tagstore.get_group_tag_value(
group2.project_id, group2.id, env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
