Python models.Environment类代码示例

    def test_transfer_to_team(self):
        from_org = self.create_organization()
        from_team = self.create_team(organization=from_org)
        to_org = self.create_organization()
        to_team = self.create_team(organization=to_org)

        project = self.create_project(teams=[from_team])

        rule = Rule.objects.create(
            project=project,
            environment_id=Environment.get_or_create(project, 'production').id,
            label='Golden Rule',
            data={},
        )

        project.transfer_to(team=to_team)

        project = Project.objects.get(id=project.id)

        assert project.teams.count() == 1
        assert project.teams.first() == to_team
        assert project.organization_id == to_org.id

        updated_rule = project.rule_set.get(label='Golden Rule')
        assert updated_rule.id == rule.id
        assert updated_rule.environment_id != rule.environment_id
        assert updated_rule.environment_id == Environment.get_or_create(project, 'production').id

    def test_multiple_environments(self):
        group = self.create_group()
        self.login_as(user=self.user)

        environment = Environment.get_or_create(group.project, 'production')
        environment2 = Environment.get_or_create(group.project, 'staging')

        url = u'/api/0/issues/{}/?enable_snuba=1'.format(group.id)

        from sentry.api.endpoints.group_details import tsdb

        with mock.patch(
                'sentry.api.endpoints.group_details.tsdb.get_range',
                side_effect=tsdb.get_range) as get_range:
            response = self.client.get(
                '%s&environment=production&environment=staging' % (url,),
                format='json'
            )
            assert response.status_code == 200
            assert get_range.call_count == 2
            for args, kwargs in get_range.call_args_list:
                assert kwargs['environment_ids'] == [environment.id, environment2.id]

        response = self.client.get('%s&environment=invalid' % (url,), format='json')
        assert response.status_code == 404

    def test_simple(self):
        project = self.create_project()

        with pytest.raises(Environment.DoesNotExist):
            Environment.get_for_organization_id(
                project.organization_id,
                'prod',
            )

        env = Environment.get_or_create(
            project=project,
            name='prod',
        )

        assert env.name == 'prod'
        assert env.projects.first().id == project.id

        env2 = Environment.get_or_create(
            project=project,
            name='prod',
        )

        assert env2.id == env.id

        with self.assertNumQueries(0):
            assert Environment.get_for_organization_id(
                project.organization_id,
                'prod',
            ).id == env.id

    def test_with_environment(self):
        self.login_as(user=self.user)

        project = self.create_project()

        Environment.get_or_create(
            project,
            'production',
        )

        conditions = [
            {
                'id': 'sentry.rules.conditions.first_seen_event.FirstSeenEventCondition',
                'key': 'foo',
                'match': 'eq',
                'value': 'bar',
            }
        ]

        actions = [{'id': 'sentry.rules.actions.notify_event.NotifyEventAction'}]

        url = reverse(
            'sentry-api-0-project-rules',
            kwargs={
                'organization_slug': project.organization.slug,
                'project_slug': project.slug,
            }
        )
        response = self.client.post(
            url,
            data={
                'name': 'hello world',
                'environment': 'production',
                'conditions': conditions,
                'actions': actions,
                'actionMatch': 'any',
                'frequency': 30,
            },
            format='json'
        )

        assert response.status_code == 200, response.content
        assert response.data['id']
        assert response.data['environment'] == 'production'

        rule = Rule.objects.get(id=response.data['id'])
        assert rule.label == 'hello world'
        assert rule.environment_id == Environment.get_or_create(
            rule.project,
            'production',
        ).id

    def test_environment(self):
        group = self.group

        environment = Environment.get_or_create(group.project, 'production')

        from sentry.api.serializers.models.group import tsdb

        with mock.patch(
                'sentry.api.serializers.models.group.tsdb.get_range',
                side_effect=tsdb.get_range) as get_range:
            serialize(
                [group],
                serializer=StreamGroupSerializer(
                    environment_func=lambda: environment,
                    stats_period='14d',
                ),
            )
            assert get_range.call_count == 1
            for args, kwargs in get_range.call_args_list:
                assert kwargs['environment_id'] == environment.id

        def get_invalid_environment():
            raise Environment.DoesNotExist()

        with mock.patch(
                'sentry.api.serializers.models.group.tsdb.make_series',
                side_effect=tsdb.make_series) as make_series:
            serialize(
                [group],
                serializer=StreamGroupSerializer(
                    environment_func=get_invalid_environment,
                    stats_period='14d',
                )
            )
            assert make_series.call_count == 1

    def test_environment(self):
        group = self.group

        environment = Environment.get_or_create(group.project, 'production')

        with mock.patch(
                'sentry.api.serializers.models.group.snuba_tsdb.get_range',
                side_effect=snuba_tsdb.get_range) as get_range:
            serialize(
                [group],
                serializer=StreamGroupSerializerSnuba(
                    environment_ids=[environment.id],
                    stats_period='14d',
                ),
            )
            assert get_range.call_count == 1
            for args, kwargs in get_range.call_args_list:
                assert kwargs['environment_ids'] == [environment.id]

        with mock.patch(
                'sentry.api.serializers.models.group.snuba_tsdb.get_range',
                side_effect=snuba_tsdb.get_range) as get_range:
            serialize(
                [group],
                serializer=StreamGroupSerializerSnuba(
                    environment_ids=None,
                    stats_period='14d',
                )
            )
            assert get_range.call_count == 1
            for args, kwargs in get_range.call_args_list:
                assert kwargs['environment_ids'] is None

    def test_environment(self):
        group = self.create_group()
        self.login_as(user=self.user)

        environment = Environment.get_or_create(group.project, 'production')

        url = u'/api/0/issues/{}/'.format(group.id)

        from sentry.api.endpoints.group_details import tsdb

        with mock.patch(
                'sentry.api.endpoints.group_details.tsdb.get_range',
                side_effect=tsdb.get_range) as get_range:
            response = self.client.get(url, {'environment': 'production'}, format='json')
            assert response.status_code == 200
            assert get_range.call_count == 2
            for args, kwargs in get_range.call_args_list:
                assert kwargs['environment_ids'] == [environment.id]

        with mock.patch(
                'sentry.api.endpoints.group_details.tsdb.make_series',
                side_effect=tsdb.make_series) as make_series:
            response = self.client.get(url, {'environment': 'invalid'}, format='json')
            assert response.status_code == 200
            assert make_series.call_count == 2

    def test_with_environment(self):
        self.login_as(user=self.user)

        team = self.create_team()
        project1 = self.create_project(teams=[team], name='foo')
        self.create_project(teams=[team], name='bar')

        rule = project1.rule_set.all()[0]
        rule.update(
            environment_id=Environment.get_or_create(
                rule.project,
                'production',
            ).id,
        )

        url = reverse(
            'sentry-api-0-project-rule-details',
            kwargs={
                'organization_slug': project1.organization.slug,
                'project_slug': project1.slug,
                'rule_id': rule.id,
            }
        )
        response = self.client.get(url, format='json')

        assert response.status_code == 200, response.content
        assert response.data['id'] == six.text_type(rule.id)
        assert response.data['environment'] == 'production'

 def create_environment(self, **kwargs):
     project = kwargs.get('project', self.project)
     name = kwargs.get('name', petname.Generate(1, ' ', letters=10))
     return Environment.get_or_create(
         project=project,
         name=name
     )

    def test_simple(self):
        project = self.create_project()

        env = Environment.get_or_create(
            project=project,
            name='prod',
        )

        assert env.name == 'prod'
        assert env.projects.first().id == project.id

        env2 = Environment.get_or_create(
            project=project,
            name='prod',
        )

        assert env2.id == env.id

    def test_environment(self):
        self.login_as(user=self.user)

        group = self.create_group()
        events = {}

        for name in ['production', 'development']:
            environment = Environment.get_or_create(group.project, name)

            tagstore.get_or_create_tag_key(
                project_id=group.project_id,
                environment_id=environment.id,
                key='environment',
            )

            tagstore.create_tag_value(
                project_id=group.project_id,
                environment_id=environment.id,
                key='environment',
                value=name,
            )

            events[name] = event = self.create_event(
                group=group,
                tags={'environment': name},
            )

            tagstore.create_event_tags(
                project_id=group.project_id,
                group_id=group.id,
                environment_id=environment.id,
                event_id=event.id,
                tags=[
                    ('environment', name),
                ],
            )

        url = u'/api/0/issues/{}/events/'.format(group.id)
        response = self.client.get(url + '?environment=production', format='json')

        assert response.status_code == 200, response.content
        assert set(map(lambda x: x['id'], response.data)) == set([
            six.text_type(events['production'].id),
        ])

        url = u'/api/0/issues/{}/events/'.format(group.id)
        response = self.client.get(url + '?environment=invalid', format='json')

        assert response.status_code == 200, response.content
        assert response.data == []

        url = u'/api/0/issues/{}/events/'.format(group.id)
        response = self.client.get(
            url + '?environment=production&query=environment:development',
            format='json')

        assert response.status_code == 200, response.content
        assert response.data == []

    def get_environment(self):
        from sentry.models import Environment
        if not hasattr(self, '_environment_cache'):
            self._environment_cache = Environment.objects.get(
                organization_id=self.project.organization_id,
                name=Environment.get_name_or_default(self.get_tag('environment')),
            )

        return self._environment_cache

    def get(self, request, project, environment):
        try:
            instance = EnvironmentProject.objects.select_related('environment').get(
                project=project,
                environment__name=Environment.get_name_from_path_segment(environment),
            )
        except EnvironmentProject.DoesNotExist:
            raise ResourceDoesNotExist

        return Response(serialize(instance, request.user))

    def _setup_tags_for_event(self, event):
        tags = dict(event.data['tags'])

        try:
            environment = self.environments[tags['environment']]
        except KeyError:
            environment = self.environments[tags['environment']] = Environment.get_or_create(
                event.project,
                tags['environment'],
            )

        GroupEnvironment.objects.get_or_create(
            environment_id=environment.id,
            group_id=event.group_id,
        )

        for key, value in tags.items():
            for environment_id in [AGGREGATE_ENVIRONMENT_ID, environment.id]:
                tag_value, created = tagstore.get_or_create_group_tag_value(
                    project_id=event.project_id,
                    group_id=event.group_id,
                    environment_id=environment_id,
                    key=key,
                    value=value,
                )

                if created:  # XXX: Hack for tagstore compat
                    tag_value.update(
                        times_seen=1,
                        first_seen=event.datetime,
                        last_seen=event.datetime,
                    )
                else:
                    updates = {
                        'times_seen': tag_value.times_seen + 1,
                    }

                    if event.datetime < tag_value.first_seen:
                        updates['first_seen'] = event.datetime

                    if event.datetime > tag_value.last_seen:
                        updates['last_seen'] = event.datetime

                    if updates:
                        tag_value.update(**updates)

                tagstore.create_event_tags(
                    project_id=event.project_id,
                    group_id=event.group_id,
                    environment_id=environment_id,
                    event_id=event.id,
                    tags=tags.items(),
                    date_added=event.datetime,
                )

    def test_get_environment(self):
        environment = Environment.get_or_create(self.project, 'production')
        event = self.create_event(
            data={'tags': [
                ('environment', 'production'),
            ]}
        )

        event.get_environment() == environment

        with self.assertNumQueries(0):
            event.get_environment() == environment