def test_event_filter(self):
self.create_snapshot("user", "1", self.base_time)
self.create_event("user", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
data={
"events": [{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
}]
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
filter = SessionRecordingsFilter(
data={
"events": [{
"id": "$autocapture",
"type": "events",
"order": 0,
"name": "$autocapture"
}]
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_duration_filter(self):
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
self.create_snapshot("user", "2", self.base_time)
self.create_snapshot("user", "2",
self.base_time + relativedelta(minutes=4))
filter = SessionRecordingsFilter(
data={
"session_recording_duration":
'{"type":"recording","key":"duration","value":60,"operator":"gt"}'
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "2")
filter = SessionRecordingsFilter(
data={
"session_recording_duration":
'{"type":"recording","key":"duration","value":60,"operator":"lt"}'
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
def test_date_to_filter(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1",
self.base_time - relativedelta(days=3))
self.create_snapshot(
"user", "1", self.base_time - relativedelta(days=3) +
relativedelta(seconds=30))
filter = SessionRecordingsFilter(
team=self.team,
data={
"date_to": (self.base_time -
relativedelta(days=4)).strftime("%Y-%m-%d")
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
filter = SessionRecordingsFilter(
team=self.team,
data={"date_to": (self.base_time).strftime("%Y-%m-%d")})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
def test_event_filter_with_properties(self):
self.create_snapshot("user", "1", self.base_time)
self.create_event("user",
self.base_time,
properties={"$browser": "Chrome"})
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
data={
"events": [
{
"id":
"$pageview",
"type":
"events",
"order":
0,
"name":
"$pageview",
"properties": [{
"key": "$browser",
"value": ["Chrome"],
"operator": "exact",
"type": "event"
}],
},
]
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
filter = SessionRecordingsFilter(
data={
"events": [
{
"id":
"$pageview",
"type":
"events",
"order":
0,
"name":
"$pageview",
"properties": [{
"key": "$browser",
"value": ["Firefox"],
"operator": "exact",
"type": "event"
}],
},
]
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_multiple_event_filters(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time)
self.create_event("user", self.base_time)
self.create_event("user", self.base_time, event_name="new-event")
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [
{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
},
{
"id": "new-event",
"type": "events",
"order": 0,
"name": "new-event"
},
]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [
{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
},
{
"id": "new-event2",
"type": "events",
"order": 0,
"name": "new-event2"
},
]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_event_filter_matching_with_no_session_id(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
create_snapshot(distinct_id="user",
session_id="1",
timestamp=self.base_time,
window_id="1",
team_id=self.team.id)
self.create_event("user", self.base_time)
create_snapshot(
distinct_id="user",
session_id="1",
timestamp=self.base_time + relativedelta(seconds=30),
window_id="1",
team_id=self.team.id,
)
self.create_event("user",
self.base_time + relativedelta(seconds=31),
event_name="$autocapture")
# Pageview within timestamps matches recording
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
}]
},
)
session_recording_list_instance = SessionRecordingList(filter=filter,
team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
# Pageview outside timestamps does not match recording
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [{
"id": "$autocapture",
"type": "events",
"order": 0,
"name": "$autocapture"
}]
},
)
session_recording_list_instance = SessionRecordingList(filter=filter,
team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_event_filter_with_matching_on_session_id(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time, window_id="1")
self.create_event("user",
self.base_time,
properties={"$session_id": "1"})
self.create_event("user",
self.base_time,
event_name="$autocapture",
properties={"$session_id": "2"})
self.create_snapshot("user",
"1",
self.base_time + relativedelta(seconds=30),
window_id="1")
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
}]
},
)
session_recording_list_instance = ClickhouseSessionRecordingList(
filter=filter, team_id=self.team.pk)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [{
"id": "$autocapture",
"type": "events",
"order": 0,
"name": "$autocapture"
}]
},
)
session_recording_list_instance = ClickhouseSessionRecordingList(
filter=filter, team_id=self.team.pk)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_basic_query(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=10))
self.create_snapshot("user", "2",
self.base_time + relativedelta(seconds=20))
filter = SessionRecordingsFilter(team=self.team,
data={"no_filter": None})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["start_time"],
self.base_time + relativedelta(seconds=20))
self.assertEqual(session_recordings[0]["session_id"], "2")
self.assertEqual(session_recordings[0]["distinct_id"], "user")
self.assertEqual(session_recordings[1]["start_time"],
self.base_time)
self.assertEqual(session_recordings[1]["session_id"], "1")
self.assertEqual(session_recordings[1]["distinct_id"], "user")
self.assertEqual(more_recordings_available, False)
def track_session_recordings_list(self):
filter = SessionRecordingsFilter(
data=SESSIONS_DATE_RANGE,
team=self.team,
)
ClickhouseSessionRecordingList(filter, self.team.pk).run()
def test_all_sessions_recording_object_keys_with_entity_filter(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time)
self.create_event("user", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
}]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
self.assertEqual(session_recordings[0]["distinct_id"], "user")
self.assertEqual(session_recordings[0]["start_time"],
self.base_time)
self.assertEqual(session_recordings[0]["end_time"],
self.base_time + relativedelta(seconds=30))
self.assertEqual(session_recordings[0]["duration"], 30)
def test_recording_without_fullsnapshot_dont_appear(self):
self.create_snapshot("user", "1", self.base_time, type=1)
filter = SessionRecordingsFilter(data={"no-filter": True})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_event_filter_with_person_properties(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
Person.objects.create(team=self.team,
distinct_ids=["user2"],
properties={"email": "bla2"})
self.create_snapshot("user", "1", self.base_time)
self.create_event("user", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
self.create_snapshot("user2", "2", self.base_time)
self.create_event("user2", self.base_time)
self.create_snapshot("user2", "2",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
team=self.team,
data={
"properties": [{
"key": "email",
"value": ["bla"],
"operator": "exact",
"type": "person"
}],
},
)
session_recording_list_instance = ClickhouseSessionRecordingList(
filter=filter, team_id=self.team.pk)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
def test_recording_that_spans_time_bounds(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
day_line = datetime(2021, 11, 5)
self.create_snapshot("user", "1",
day_line - relativedelta(hours=3))
self.create_snapshot("user", "1",
day_line + relativedelta(hours=3))
filter = SessionRecordingsFilter(
team=self.team,
data={
"date_to":
day_line.strftime("%Y-%m-%d"),
"date_from":
(day_line - relativedelta(days=10)).strftime("%Y-%m-%d"),
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
self.assertEqual(session_recordings[0]["duration"], 6 * 60 * 60)
def test_teams_dont_leak_event_filter(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
another_team = Team.objects.create(organization=self.organization)
self.create_snapshot("user", "1", self.base_time)
self.create_event(1,
self.base_time + relativedelta(seconds=15),
team=another_team)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
team=self.team,
data={
"events": [{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
}]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_pagination(self):
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user2", "2",
self.base_time + relativedelta(seconds=10))
self.create_snapshot("user3", "3",
self.base_time + relativedelta(seconds=20))
filter = SessionRecordingsFilter(data={
"limit": 2,
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "3")
self.assertEqual(session_recordings[1]["session_id"], "2")
self.assertEqual(more_recordings_available, True)
filter = SessionRecordingsFilter(data={"limit": 2, "offset": 0})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "3")
self.assertEqual(session_recordings[1]["session_id"], "2")
self.assertEqual(more_recordings_available, True)
filter = SessionRecordingsFilter(data={"limit": 2, "offset": 1})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "2")
self.assertEqual(session_recordings[1]["session_id"], "1")
self.assertEqual(more_recordings_available, False)
filter = SessionRecordingsFilter(data={"limit": 2, "offset": 2})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
self.assertEqual(more_recordings_available, False)
def snapshots(self, request: request.Request, **kwargs):
session_recording_id = kwargs["pk"]
filter = SessionRecordingsFilter(request=request)
session_recording_snapshots = self._get_session_recording_snapshots(
request, filter, session_recording_id)
if len(session_recording_snapshots["snapshots"]) == 0:
raise exceptions.NotFound("Snapshots not found")
return response.Response({"result": session_recording_snapshots})
def track_session_recordings_list_event_filter(self):
filter = SessionRecordingsFilter(
data={
"events": [{
"id": "$pageview"
}],
**SESSIONS_DATE_RANGE
},
team=self.team,
)
ClickhouseSessionRecordingList(filter, self.team.pk).run()
def list(self, request: request.Request, *args: Any,
**kwargs: Any) -> Response:
filter = SessionRecordingsFilter(request=request)
(session_recordings,
more_recordings_available) = self._get_session_recording_list(filter)
if not request.user.is_authenticated: # for mypy
raise exceptions.NotAuthenticated()
viewed_session_recordings = set(
SessionRecordingViewed.objects.filter(
team=self.team, user=request.user).values_list("session_id",
flat=True))
distinct_ids = map(lambda x: x["distinct_id"], session_recordings)
person_distinct_ids = PersonDistinctId.objects.filter(
distinct_id__in=distinct_ids,
team=self.team).select_related("person")
distinct_id_to_person = {}
for person_distinct_id in person_distinct_ids:
distinct_id_to_person[
person_distinct_id.distinct_id] = person_distinct_id.person
session_recordings = list(
map(
lambda x: {
**x,
"viewed": x["session_id"] in viewed_session_recordings,
},
session_recordings,
))
session_recording_serializer = SessionRecordingSerializer(
data=session_recordings, many=True)
session_recording_serializer.is_valid(raise_exception=True)
session_recording_serializer_with_person = list(
map(
lambda session_recording: {
**session_recording,
"person":
PersonSerializer(instance=distinct_id_to_person.get(
session_recording["distinct_id"])).data,
},
session_recording_serializer.data,
))
return Response({
"results": session_recording_serializer_with_person,
"has_next": more_recordings_available
})
def test_recording_without_fullsnapshot_dont_appear(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user",
"1",
self.base_time,
has_full_snapshot=False)
filter = SessionRecordingsFilter(team=self.team,
data={"no-filter": True})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
def test_all_filters_at_once(self):
p = Person.objects.create(team=self.team,
distinct_ids=["user", "user2"],
properties={"email": "bla"})
action2 = self.create_action(name="custom-event")
self.create_snapshot("user", "1",
self.base_time - relativedelta(days=3))
self.create_event("user", self.base_time - relativedelta(days=3))
self.create_event(
"user",
self.base_time - relativedelta(days=3),
event_name="custom-event",
properties={"$browser": "Chrome"},
)
self.create_snapshot(
"user", "1", self.base_time - relativedelta(days=3) +
relativedelta(hours=6))
filter = SessionRecordingsFilter(
team=self.team,
data={
"person_uuid":
str(p.uuid),
"date_to": (self.base_time +
relativedelta(days=3)).strftime("%Y-%m-%d"),
"date_from": (self.base_time -
relativedelta(days=10)).strftime("%Y-%m-%d"),
"session_recording_duration":
'{"type":"recording","key":"duration","value":60,"operator":"gt"}',
"events": [{
"id": "$pageview",
"type": "events",
"order": 0,
"name": "$pageview"
}],
"actions": [{
"id": action2.id,
"type": "actions",
"order": 1,
"name": "custom-event",
}],
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
def test_date_to_filter(self):
self.create_snapshot("user", "1",
self.base_time - relativedelta(days=3))
self.create_snapshot(
"user", "1", self.base_time - relativedelta(days=3) +
relativedelta(seconds=30))
filter = SessionRecordingsFilter(
data={
"date_to": (self.base_time -
relativedelta(days=4)).strftime("%Y-%m-%d")
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
filter = SessionRecordingsFilter(
data={"date_to": (self.base_time).strftime("%Y-%m-%d")})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
def test_duration_filter(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
self.create_snapshot("user", "2", self.base_time)
self.create_snapshot("user", "2",
self.base_time + relativedelta(minutes=4))
filter = SessionRecordingsFilter(
team=self.team,
data={
"session_recording_duration":
'{"type":"recording","key":"duration","value":60,"operator":"gt"}'
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team_id=self.team.pk)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "2")
filter = SessionRecordingsFilter(
team=self.team,
data={
"session_recording_duration":
'{"type":"recording","key":"duration","value":60,"operator":"lt"}'
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team_id=self.team.pk)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
def track_session_recordings_list_person_property_filter(self):
filter = SessionRecordingsFilter(
data={
"events": [
{
"id": "$pageview",
"properties": [{"key": "email", "operator": "icontains", "value": ".com", "type": "person"}],
}
],
**SESSIONS_DATE_RANGE,
},
team=self.team,
)
SessionRecordingList(filter, self.team).run()
def test_recordings_dont_leak_data_between_teams(self):
another_team = Team.objects.create(organization=self.organization)
self.create_snapshot("user",
"1",
self.base_time,
team_id=another_team.pk)
self.create_snapshot("user", "2", self.base_time)
filter = SessionRecordingsFilter(data={"no_filter": None})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "2")
self.assertEqual(session_recordings[0]["distinct_id"], "user")
def test_all_sessions_recording_object_keys(self):
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(data={"no_filter": None})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
self.assertEqual(session_recordings[0]["distinct_id"], "user")
self.assertEqual(session_recordings[0]["start_time"],
self.base_time)
self.assertEqual(session_recordings[0]["end_time"],
self.base_time + relativedelta(seconds=30))
self.assertEqual(session_recordings[0]["duration"], 30)
def test_event_filter_with_cohort_properties(self):
with self.settings(USE_PRECALCULATED_CH_COHORT_PEOPLE=True):
with freeze_time("2021-08-21T20:00:00.000Z"):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
Person.objects.create(team=self.team,
distinct_ids=["user2"],
properties={
"email": "bla2",
"$some_prop": "some_val"
})
cohort = Cohort.objects.create(team=self.team,
name="cohort1",
groups=[{
"properties": {
"$some_prop": "some_val"
}
}])
cohort.calculate_people_ch(pending_version=0)
self.create_snapshot("user", "1", self.base_time)
self.create_event("user", self.base_time, team=self.team)
self.create_snapshot(
"user", "1", self.base_time + relativedelta(seconds=30))
self.create_snapshot("user2", "2", self.base_time)
self.create_event("user2", self.base_time, team=self.team)
self.create_snapshot(
"user2", "2", self.base_time + relativedelta(seconds=30))
filter = SessionRecordingsFilter(
team=self.team,
data={
"properties": [{
"key": "id",
"value": cohort.pk,
"operator": None,
"type": "cohort"
}],
},
)
session_recording_list_instance = ClickhouseSessionRecordingList(
filter=filter, team_id=self.team.pk)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "2")
def retrieve(self, request: request.Request, *args: Any,
**kwargs: Any) -> response.Response:
session_recording_id = kwargs["pk"]
filter = SessionRecordingsFilter(request=request)
session_recording_meta_data = self._get_session_recording_meta_data(
request, filter, session_recording_id)
if not session_recording_meta_data.get("session_id"):
raise exceptions.NotFound("Session not found")
if not request.user.is_authenticated: # for mypy
raise exceptions.NotAuthenticated()
viewed_session_recording = SessionRecordingViewed.objects.filter(
team=self.team, user=request.user,
session_id=session_recording_id).exists()
session_recording_serializer = SessionRecordingSerializer(
data={
**session_recording_meta_data, "session_id":
session_recording_id,
"viewed": viewed_session_recording
})
session_recording_serializer.is_valid(raise_exception=True)
distinct_id = session_recording_meta_data["distinct_id"]
try:
person: Union[Person, None] = Person.objects.get(
persondistinctid__distinct_id=distinct_id,
persondistinctid__team_id=self.team,
team=self.team)
except Person.DoesNotExist:
person = None
if request.GET.get("save_view"):
SessionRecordingViewed.objects.get_or_create(
team=self.team,
user=request.user,
session_id=session_recording_id)
return response.Response({
"result": {
"session_recording": session_recording_serializer.data,
"person": PersonSerializer(instance=person).data,
}
})
def test_person_id_filter(self):
p = Person.objects.create(team=self.team,
distinct_ids=["user", "user2"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user2", "2",
self.base_time + relativedelta(seconds=10))
self.create_snapshot("user3", "3",
self.base_time + relativedelta(seconds=20))
filter = SessionRecordingsFilter(data={
"person_uuid": str(p.uuid),
})
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "2")
self.assertEqual(session_recordings[1]["session_id"], "1")
def test_pagination(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
self.create_snapshot("user", "1", self.base_time)
self.create_snapshot("user", "2",
self.base_time + relativedelta(seconds=10))
self.create_snapshot("user", "3",
self.base_time + relativedelta(seconds=20))
filter = SessionRecordingsFilter(team=self.team,
data={
"limit": 2,
})
session_recording_list_instance = session_recording_list(
filter=filter, team_id=self.team.pk)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "3")
self.assertEqual(session_recordings[1]["session_id"], "2")
self.assertEqual(more_recordings_available, True)
filter = SessionRecordingsFilter(team=self.team,
data={
"limit": 2,
"offset": 0
})
session_recording_list_instance = session_recording_list(
filter=filter, team_id=self.team.pk)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "3")
self.assertEqual(session_recordings[1]["session_id"], "2")
self.assertEqual(more_recordings_available, True)
filter = SessionRecordingsFilter(team=self.team,
data={
"limit": 2,
"offset": 1
})
session_recording_list_instance = session_recording_list(
filter=filter, team_id=self.team.pk)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 2)
self.assertEqual(session_recordings[0]["session_id"], "2")
self.assertEqual(session_recordings[1]["session_id"], "1")
self.assertEqual(more_recordings_available, False)
filter = SessionRecordingsFilter(team=self.team,
data={
"limit": 2,
"offset": 2
})
session_recording_list_instance = session_recording_list(
filter=filter, team_id=self.team.pk)
(session_recordings, more_recordings_available
) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
self.assertEqual(more_recordings_available, False)
def test_action_filter(self):
Person.objects.create(team=self.team,
distinct_ids=["user"],
properties={"email": "bla"})
action1 = self.create_action("custom-event",
properties=[{
"key": "$browser",
"value": "Firefox"
}])
action2 = self.create_action(name="custom-event")
self.create_snapshot("user", "1", self.base_time)
self.create_event("user",
self.base_time,
event_name="custom-event",
properties={"$browser": "Chrome"})
self.create_snapshot("user", "1",
self.base_time + relativedelta(seconds=30))
# An action with properties
filter = SessionRecordingsFilter(
team=self.team,
data={
"actions": [{
"id": action1.id,
"type": "actions",
"order": 1,
"name": "custom-event",
}]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)
# An action without properties
filter = SessionRecordingsFilter(
team=self.team,
data={
"actions": [{
"id": action2.id,
"type": "actions",
"order": 1,
"name": "custom-event",
}]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 1)
self.assertEqual(session_recordings[0]["session_id"], "1")
# Adding properties to an action
filter = SessionRecordingsFilter(
team=self.team,
data={
"actions": [{
"id":
action2.id,
"type":
"actions",
"order":
1,
"name":
"custom-event",
"properties": [{
"key": "$browser",
"value": ["Firefox"],
"operator": "exact",
"type": "event"
}],
}]
},
)
session_recording_list_instance = session_recording_list(
filter=filter, team=self.team)
(session_recordings, _) = session_recording_list_instance.run()
self.assertEqual(len(session_recordings), 0)