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): 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_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()