Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_simple(self):
group1 = self.create_group(status=GroupStatus.IGNORED)
GroupSnooze.objects.create(group=group1, until=timezone.now() - timedelta(minutes=1))
group2 = self.create_group(status=GroupStatus.IGNORED)
GroupSnooze.objects.create(group=group2, until=timezone.now() + timedelta(minutes=1))
clear_expired_snoozes()
assert Group.objects.get(id=group1.id).status == GroupStatus.UNRESOLVED
assert Group.objects.get(id=group2.id).status == GroupStatus.IGNORED
def test_project_restriction(self):
project1 = self.create_project()
group1_1 = self.create_group(project1)
group1_2 = self.create_group(project1)
project2 = self.create_project()
group2_1 = self.create_group(project2)
group2_2 = self.create_group(project2)
BulkDeleteQuery(model=Group, project_id=project1.id).execute()
assert Project.objects.filter(id=project1.id).exists()
assert Project.objects.filter(id=project2.id).exists()
assert Group.objects.filter(id=group2_1.id).exists()
assert Group.objects.filter(id=group2_2.id).exists()
assert not Group.objects.filter(id=group1_1.id).exists()
assert not Group.objects.filter(id=group1_2.id).exists()
def test_user_delta_reached(self):
project = self.create_project()
for i in xrange(0, 100):
self.store_event(
data={
"user": {"id": i},
"timestamp": iso_format(before_now(seconds=1)),
"fingerprint": ["group1"],
},
project_id=project.id,
)
group = list(Group.objects.all())[-1]
snooze = GroupSnooze.objects.create(group=group, user_count=100, state={"users_seen": 0})
assert not snooze.is_valid(test_rates=True)
Client(
"http://%s:%s@localhost:8000/%s"
% (self.pk.public_key, self.pk.secret_key, self.pk.project_id),
default_integrations=False,
)
)
hub.capture_message("foo")
hub.client.close()
for _request in requests:
self.send_event(*_request)
assert request.call_count == 1
assert Group.objects.count() == 1
group = Group.objects.get()
assert group.data["title"] == "foo"
def test_set_private(self):
group1 = self.create_group(checksum="a" * 32)
group2 = self.create_group(checksum="b" * 32)
# Manually mark them as shared
for g in group1, group2:
GroupShare.objects.create(project_id=g.project_id, group=g)
assert bool(g.get_share_id())
self.login_as(user=self.user)
response = self.get_valid_response(
qs_params={"id": [group1.id, group2.id]}, isPublic="false"
)
assert response.data == {"isPublic": False, "shareId": None}
new_group1 = Group.objects.get(id=group1.id)
assert not bool(new_group1.get_share_id())
new_group2 = Group.objects.get(id=group2.id)
assert not bool(new_group2.get_share_id())
),
),
'last_seen_to': CallbackCondition(
# This condition represents the upper threshold for "last
# seen" time for an environment. Due to assertions #2 and
# #3, we can exclude any values where the group first seen
# value is greater than that threshold.
lambda queryset, last_seen: queryset.exclude(
first_seen__gt=last_seen,
),
),
}).build(
group_queryset.extra(
where=[
'{} = {}'.format(
get_sql_column(Group, 'id'),
get_sql_column(GroupEnvironment, 'group'),
),
'{} = %s'.format(
get_sql_column(GroupEnvironment, 'environment'),
),
],
params=[environment.id],
tables=[GroupEnvironment._meta.db_table],
),
parameters,
).order_by(group_queryset_sort_clause)
get_sort_expression, sort_value_to_cursor_value = environment_sort_strategies[sort_by]
group_tag_value_queryset = tagstore.get_group_tag_value_qs(
project_id=project.id,
def get(self, request, share_id):
"""
Retrieve an aggregate
Return details on an individual aggregate specified by it's shared ID.
{method} {path}
Note: This is not the equivalent of what you'd receive with the standard
group details endpoint. Data is more restrictive and designed
specifically for sharing.
"""
try:
group = Group.from_share_id(share_id)
except Group.DoesNotExist:
raise ResourceDoesNotExist
if group.organization.flags.disable_shared_issues:
raise ResourceDoesNotExist
event = group.get_latest_event()
context = serialize(
group,
request.user,
SharedGroupSerializer(
environment_func=self._get_environment_func(request, group.project.organization_id)
),
)
# TODO(dcramer): move latestEvent/project into SharedGroupSerializer
def fetch_instance(self, issue_id):
try:
group = Group.objects.get_from_cache(id=issue_id)
except Group.DoesNotExist:
raise Http404
return group
records = []
group_sequence = itertools.count(1)
event_sequence = itertools.count(1)
for i in xrange(random.randint(1, 30)):
group_id = next(group_sequence)
culprit = '{module} in {function}'.format(
module='.'.join(
''.join(random.sample(WORDS, random.randint(1, int(random.paretovariate(2.2))))) for word in xrange(1, 4)
),
function=random.choice(WORDS)
)
group = state['groups'][group_id] = Group(
id=group_id,
project=project,
message=words(int(random.weibullvariate(8, 4)), common=False),
culprit=culprit,
level=random.choice(LOG_LEVELS.keys()),
)
offset = timedelta(seconds=0)
for i in xrange(random.randint(1, 10)):
offset += timedelta(seconds=random.random() * 120)
event = Event(
id=next(event_sequence),
event_id=uuid.uuid4().hex,
project=project,
group=group,
message=group.message,