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 __init__(self, project_id, group_id, key, environment_id):
self.project = self.get_project(project_id)
self.group = self.get_group(group_id, self.project)
self.key = key
self.environment_id = environment_id
self.header_fields = self.get_header_fields(self.key)
self.lookup_key = self.get_lookup_key(self.key)
# Ensure the tag key exists, as it may have been deleted
try:
tagstore.get_tag_key(self.project.id, environment_id, self.lookup_key)
except tagstore.TagKeyNotFound:
raise ExportError("Requested key does not exist")
self.callbacks = self.get_callbacks(self.key, self.group.project_id)
def get(self, request, group, key):
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key for an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(
request, group.project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tagstore.get_tag_key(group.project_id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
queryset = tagstore.get_group_tag_value_qs(
group.project_id, group.id, environment_id, lookup_key)
sort = request.GET.get('sort')
if sort == 'date':
order_by = '-last_seen'
paginator_cls = DateTimePaginator
elif sort == 'age':
order_by = '-first_seen'
paginator_cls = DateTimePaginator
else:
order_by = '-id'
paginator_cls = Paginator
if key == 'user':
serializer_cls = UserTagValueSerializer()
else:
serializer_cls = None
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
paginator_cls=paginator_cls,
on_results=lambda x: serialize(x, request.user, serializer_cls),
)
def get(self, request, group, key):
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key for an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(
request, group.project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tagstore.get_tag_key(group.project_id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
sort = request.GET.get("sort")
if sort == "date":
order_by = "-last_seen"
elif sort == "age":
order_by = "-first_seen"
else:
order_by = "-id"
if key == "user":
serializer_cls = UserTagValueSerializer(group.project_id)
else:
serializer_cls = None
paginator = tagstore.get_group_tag_value_paginator(group.project_id,
group.id,
environment_id,
lookup_key,
order_by=order_by)
return self.paginate(
request=request,
paginator=paginator,
on_results=lambda results: serialize(results, request.user,
serializer_cls),
)
def get(self, request: Request, group, key) -> Response:
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key for an issue.
When paginated can return at most 1000 values.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
environment_ids = [
e.id for e in get_environments(request, group.project.organization)
]
try:
tagstore.get_tag_key(group.project_id, None, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
sort = request.GET.get("sort")
if sort == "date":
order_by = "-last_seen"
elif sort == "age":
order_by = "-first_seen"
elif sort == "count":
order_by = "-times_seen"
else:
order_by = "-id"
if key == "user":
serializer_cls = UserTagValueSerializer(group.project_id)
else:
serializer_cls = None
paginator = tagstore.get_group_tag_value_paginator(group.project_id,
group.id,
environment_ids,
lookup_key,
order_by=order_by)
return self.paginate(
request=request,
paginator=paginator,
on_results=lambda results: serialize(results, request.user,
serializer_cls),
)
def get(self, request, group, key):
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key for an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
tagstore.get_tag_key(group.project_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
queryset = GroupTagValue.objects.filter(
group_id=group.id,
key=lookup_key,
)
sort = request.GET.get('sort')
if sort == 'date':
order_by = '-last_seen'
paginator_cls = DateTimePaginator
elif sort == 'age':
order_by = '-first_seen'
paginator_cls = DateTimePaginator
elif sort == 'freq':
order_by = '-times_seen'
paginator_cls = OffsetPaginator
else:
order_by = '-id'
paginator_cls = Paginator
if key == 'user':
serializer_cls = UserTagValueSerializer()
else:
serializer_cls = None
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
paginator_cls=paginator_cls,
on_results=lambda x: serialize(x, request.user, serializer_cls),
)
def get(self, request, project, key):
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key. The `query`
parameter can be used to to perform a "contains" match on
values.
:pparam string organization_slug: the slug of the organization.
:pparam string project_slug: the slug of the project.
:pparam string key: the tag key to look up.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
tagkey = tagstore.get_tag_key(project.id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
queryset = tagstore.get_tag_value_qs(project.id, tagkey.key, query=request.GET.get('query'))
return self.paginate(
request=request,
queryset=queryset,
order_by='-last_seen',
paginator_cls=DateTimePaginator,
on_results=lambda x: serialize(x, request.user),
)
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key='foo')
self.login_as(user=self.user)
url = reverse('sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
})
response = self.client.delete(url)
assert response.status_code == 204
if settings.SENTRY_TAGSTORE.startswith('sentry.tagstore.multi'):
backend_count = len(
settings.SENTRY_TAGSTORE_OPTIONS.get('backends', []))
assert mock_delete_tag_key.delay.call_count == backend_count
else:
from sentry.tagstore.models import TagKey
mock_delete_tag_key.delay.assert_called_once_with(
object_id=tagkey.id, model=TagKey)
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key='foo')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 204
mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id)
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
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)
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_protected(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key="environment")
self.login_as(user=self.user)
url = reverse(
"sentry-api-0-project-tagkey-details",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": tagkey.key,
},
)
response = self.client.delete(url)
assert response.status_code == 403
assert mock_delete_tag_key.delay.call_count == 0
assert (tagstore.get_tag_key(
project.id,
None,
tagkey.key,
status=TagKeyStatus.VISIBLE # environment_id
).status == TagKeyStatus.VISIBLE)
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id, key='foo')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 204
mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id)
assert tagstore.get_tag_key(
project.id,
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
def test_protected(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key='environment')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 403
assert mock_delete_tag_key.delay.call_count == 0
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.VISIBLE
).status == TagKeyStatus.VISIBLE
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_protected(self):
project = self.create_project()
self.store_event(
data={
"environment": "prod",
"timestamp": iso_format(before_now(seconds=1))
},
project_id=project.id,
)
self.login_as(user=self.user)
url = reverse(
"sentry-api-0-project-tagkey-details",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": "environment",
},
)
response = self.client.delete(url)
assert response.status_code == 403
assert (tagstore.get_tag_key(
project.id,
None,
"environment",
status=TagKeyStatus.VISIBLE # environment_id
).status == TagKeyStatus.VISIBLE)
def test_simple(self, mock_delete_tag_key):
project = self.create_project()
tagkey = tagstore.create_tag_key(
project_id=project.id,
environment_id=None,
key='foo')
self.login_as(user=self.user)
url = reverse(
'sentry-api-0-project-tagkey-details',
kwargs={
'organization_slug': project.organization.slug,
'project_slug': project.slug,
'key': tagkey.key,
}
)
response = self.client.delete(url)
assert response.status_code == 204
if settings.SENTRY_TAGSTORE.startswith('sentry.tagstore.multi'):
backend_count = len(settings.SENTRY_TAGSTORE_OPTIONS.get('backends', []))
assert mock_delete_tag_key.delay.call_count == backend_count
else:
from sentry.tagstore.models import TagKey
mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id, model=TagKey)
assert tagstore.get_tag_key(
project.id,
None, # environment_id
tagkey.key,
status=TagKeyStatus.PENDING_DELETION
).status == TagKeyStatus.PENDING_DELETION
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 get(self, request, organization, project, group_id, key):
try:
# TODO(tkaemming): This should *actually* redirect, see similar
# comment in ``GroupEndpoint.convert_args``.
group, _ = get_group_with_redirect(
group_id,
queryset=Group.objects.filter(project=project),
)
except Group.DoesNotExist:
raise Http404
if tagstore.is_reserved_key(key):
lookup_key = 'sentry:{0}'.format(key)
else:
lookup_key = key
try:
environment_id = self._get_environment_id_from_request(
request, project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise Http404
# validate existance as it may be deleted
try:
tagstore.get_tag_key(project.id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise Http404
if key == 'user':
callbacks = [attach_eventuser(project.id)]
else:
callbacks = []
gtv_iter = tagstore.get_group_tag_value_iter(group.project_id,
group.id,
environment_id,
lookup_key,
callbacks=callbacks)
filename = '{}-{}'.format(
group.qualified_short_id or group.id,
key,
)
return self.to_csv_response(gtv_iter, filename, key=key)
def get_tag_keys_for_deletion(self, project_id, key):
try:
return [
tagstore.get_tag_key(project_id=project_id,
key=key,
environment_id=None)
]
except tagstore.TagKeyNotFound:
return []
def get(self, request, project, key):
lookup_key = tagstore.prefix_reserved_key(key)
try:
tagkey = tagstore.get_tag_key(project.id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
return Response(serialize(tagkey, request.user))
def get(self, request, organization, project, group_id, key):
try:
# TODO(tkaemming): This should *actually* redirect, see similar
# comment in ``GroupEndpoint.convert_args``.
group, _ = get_group_with_redirect(
group_id,
queryset=Group.objects.filter(project=project),
)
except Group.DoesNotExist:
raise Http404
if tagstore.is_reserved_key(key):
lookup_key = 'sentry:{0}'.format(key)
else:
lookup_key = key
try:
environment_id = self._get_environment_id_from_request(request, project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise Http404
# validate existance as it may be deleted
try:
tagstore.get_tag_key(project.id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise Http404
if key == 'user':
callbacks = [attach_eventuser(project.id)]
else:
callbacks = []
queryset = RangeQuerySetWrapper(
tagstore.get_group_tag_value_qs(group.project_id, group.id, environment_id, lookup_key),
callbacks=callbacks,
)
filename = '{}-{}'.format(
group.qualified_short_id or group.id,
key,
)
return self.to_csv_response(queryset, filename, key=key)
def get(self, request, organization, project, team, group_id, key):
try:
# TODO(tkaemming): This should *actually* redirect, see similar
# comment in ``GroupEndpoint.convert_args``.
group, _ = get_group_with_redirect(
group_id,
queryset=Group.objects.filter(project=project),
)
except Group.DoesNotExist:
raise Http404
if tagstore.is_reserved_key(key):
lookup_key = 'sentry:{0}'.format(key)
else:
lookup_key = key
# validate existance as it may be deleted
try:
tagstore.get_tag_key(group.project_id, lookup_key)
except tagstore.TagKeyNotFound:
raise Http404
if key == 'user':
callbacks = [attach_eventuser(project.id)]
else:
callbacks = []
queryset = RangeQuerySetWrapper(
GroupTagValue.objects.filter(
group_id=group.id,
key=lookup_key,
),
callbacks=callbacks,
)
filename = '{}-{}'.format(
group.qualified_short_id or group.id,
key,
)
return self.to_csv_response(queryset, filename, key=key)
def get(self, request, group, key):
"""
Retrieve Tag Details
````````````````````
Returns details for given tag key related to an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(
request, group.project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tag_key = tagstore.get_tag_key(group.project_id, environment_id,
lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
try:
group_tag_key = tagstore.get_group_tag_key(group.project_id,
group.id,
environment_id,
lookup_key)
except tagstore.GroupTagKeyNotFound:
raise ResourceDoesNotExist
total_values = tagstore.get_group_tag_value_count(
group.project_id, group.id, environment_id, lookup_key)
top_values = tagstore.get_top_group_tag_values(group.project_id,
group.id,
environment_id,
lookup_key,
limit=9)
data = {
'id': six.text_type(tag_key.id),
'key': key,
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
'topValues': serialize(top_values, request.user),
}
return Response(data)
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 get(self, request, project, key):
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(request, project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tagkey = tagstore.get_tag_key(project.id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
return Response(serialize(tagkey, request.user))
def get(self, request, project, key):
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(request, project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tagkey = tagstore.get_tag_key(project.id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
return Response(serialize(tagkey, request.user))
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 get(self, request, project, key):
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key. The `query`
parameter can be used to to perform a "contains" match on
values.
When paginated can return at most 1000 values.
:pparam string organization_slug: the slug of the organization.
:pparam string project_slug: the slug of the project.
:pparam string key: the tag key to look up.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(
request, project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tagkey = tagstore.get_tag_key(project.id, environment_id,
lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
start, end = get_date_range_from_params(request.GET)
paginator = tagstore.get_tag_value_paginator(
project.id,
environment_id,
tagkey.key,
start=start,
end=end,
query=request.GET.get("query"),
order_by="-last_seen",
)
return self.paginate(
request=request,
paginator=paginator,
on_results=lambda results: serialize(results, request.user),
)
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 get(self, request, group, key):
"""
Retrieve Tag Details
````````````````````
Returns details for given tag key related to an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(
request, group.project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tag_key = tagstore.get_tag_key(group.project_id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
try:
group_tag_key = tagstore.get_group_tag_key(
group.project_id, group.id, environment_id, lookup_key)
except tagstore.GroupTagKeyNotFound:
raise ResourceDoesNotExist
total_values = tagstore.get_group_tag_value_count(
group.project_id, group.id, environment_id, lookup_key)
top_values = tagstore.get_top_group_tag_values(
group.project_id, group.id, environment_id, lookup_key, limit=9)
data = {
'id': six.text_type(tag_key.id),
'key': key,
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
'topValues': serialize(top_values, request.user),
}
return Response(data)
def test_simple(self, mock_delete_tag_key, mock_eventstream):
project = self.create_project()
tagkey = tagstore.create_tag_key(project_id=project.id,
environment_id=None,
key="foo")
self.login_as(user=self.user)
eventstream_state = object()
mock_eventstream.start_delete_tag = mock.Mock(
return_value=eventstream_state)
url = reverse(
"sentry-api-0-project-tagkey-details",
kwargs={
"organization_slug": project.organization.slug,
"project_slug": project.slug,
"key": tagkey.key,
},
)
response = self.client.delete(url)
assert response.status_code == 204
if settings.SENTRY_TAGSTORE.startswith("sentry.tagstore.multi"):
backend_count = len(
settings.SENTRY_TAGSTORE_OPTIONS.get("backends", []))
assert mock_delete_tag_key.delay.call_count == backend_count
else:
from sentry.tagstore.models import TagKey
mock_delete_tag_key.delay.assert_called_once_with(
object_id=tagkey.id, model=TagKey)
assert (tagstore.get_tag_key(
project.id,
None,
tagkey.key,
status=TagKeyStatus.PENDING_DELETION # environment_id
).status == TagKeyStatus.PENDING_DELETION)
mock_eventstream.start_delete_tag.assert_called_once_with(
project.id, "foo")
mock_eventstream.end_delete_tag.assert_called_once_with(
eventstream_state)
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 get(self, request, group, key):
"""
Retrieve Tag Details
````````````````````
Returns details for given tag key related to an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
tag_key = tagstore.get_tag_key(group.project_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
try:
group_tag_key = GroupTagKey.objects.get(
group_id=group.id,
key=lookup_key,
)
except GroupTagKey.DoesNotExist:
raise ResourceDoesNotExist
total_values = GroupTagValue.get_value_count(group.id, lookup_key)
top_values = GroupTagValue.get_top_values(group.id, lookup_key, limit=9)
data = {
'id': six.text_type(tag_key.id),
'key': key,
'name': tag_key.get_label(),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
'topValues': serialize(top_values, request.user),
}
return Response(data)
def get(self, request, project, key):
"""
List a Tag's Values
```````````````````
Return a list of values associated with this key. The `query`
parameter can be used to to perform a "contains" match on
values.
:pparam string organization_slug: the slug of the organization.
:pparam string project_slug: the slug of the project.
:pparam string key: the tag key to look up.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(request, project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
tagkey = tagstore.get_tag_key(project.id, environment_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
paginator = tagstore.get_tag_value_paginator(
project.id,
environment_id,
tagkey.key,
query=request.GET.get('query'),
order_by='-last_seen',
)
return self.paginate(
request=request,
paginator=paginator,
on_results=lambda results: serialize(results, request.user),
)
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(group_id=group.id,
project_id=project.id,
event_id=1,
environment_id=self.environment.id,
tags=[
(tk.id, 1),
])
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, self.environment.id, key)
tagstore.create_group_tag_key(key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk2.id, 1),
],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key,
value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, None, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, None,
key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id, None,
key, value) is not None
assert EventTag.objects.filter(key_id=tk.id).exists()
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.legacy.tasks import delete_tag_key
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
],
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(key=key, project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1)
],
)
with self.tasks():
delete_tag_key(object_id=tk.id)
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(project_id=project2.id,
environment_id=env2.id,
key=key,
value=value)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[(tk2.key, tv2.value)],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None,
key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None,
key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id,
env2.id, key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id,
env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(
project_id=project2.id,
environment_id=env2.id,
key=key,
value=value
)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[
(tk2.key, tv2.value)
],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, env2.id, key) is not None
assert tagstore.get_group_tag_value(
group2.project_id, group2.id, env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_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()
