class TestClickhouseTrends(ClickhouseTestMixin, trend_test_factory(ClickhouseTrends, _create_event, Person.objects.create, _create_action, _create_cohort)): # type: ignore
def test_breakdown_filtering(self):
self._create_events()
# test breakdown filtering
with freeze_time("2020-01-04T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "$some_property",
"events": [
{"id": "sign up", "name": "sign up", "type": "events", "order": 0,},
{"id": "no events"},
],
}
),
self.team,
)
self.assertEqual(response[0]["label"], 'sign up - "value"')
self.assertEqual(response[1]["label"], 'sign up - "other_value"')
self.assertEqual(response[2]["label"], 'no events - "value"')
self.assertEqual(response[3]["label"], 'no events - "other_value"')
self.assertEqual(sum(response[0]["data"]), 2)
self.assertEqual(response[0]["breakdown_value"], '"value"')
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["breakdown_value"], '"other_value"')
class TestClickhouseTrends(ClickhouseTestMixin,
trend_test_factory(ClickhouseTrends, _create_event,
Person.objects.create,
_create_action,
_create_cohort)): # type: ignore
def test_interval_rounding(self):
self._test_events_with_dates(
dates=["2020-11-01", "2020-11-10", "2020-11-11", "2020-11-18"],
interval="week",
date_from="2020-11-04",
date_to="2020-11-24",
result=[{
"action": {
"id": "event_name",
"type": "events",
"order": None,
"name": "event_name",
"math": None,
"math_property": None,
"properties": [],
},
"label":
"event_name",
"count":
4.0,
"data": [1.0, 2.0, 1.0, 0.0],
"labels": [
"Sun. 1 November", "Sun. 8 November", "Sun. 15 November",
"Sun. 22 November"
],
"days":
["2020-11-01", "2020-11-08", "2020-11-15", "2020-11-22"],
}],
)
def test_breakdown_by_person_property(self):
person1, person2, person3, person4 = self._create_multiple_people()
action = _create_action(name="watched movie", team=self.team)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"name",
"breakdown_type":
"person",
"actions": [{
"id": action.pk,
"type": "actions",
"order": 0
}],
}),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"name",
"breakdown_type":
"person",
"events": [{
"id": "watched movie",
"name": "watched movie",
"type": "events",
"order": 0,
}],
}),
self.team,
)
self.assertListEqual(
[res["breakdown_value"] for res in event_response],
["person1", "person2", "person3"])
for response in event_response:
if response["breakdown_value"] == "person1":
self.assertEqual(response["count"], 1)
self.assertEqual(response["label"], "watched movie - person1")
if response["breakdown_value"] == "person2":
self.assertEqual(response["count"], 3)
if response["breakdown_value"] == "person3":
self.assertEqual(response["count"], 3)
self.assertTrue(
self._compare_entity_response(
event_response,
action_response,
))
def test_breakdown_filtering(self):
self._create_events()
# test breakdown filtering
with freeze_time("2020-01-04T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"$some_property",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
},
{
"id": "no events"
},
],
}),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - value")
self.assertEqual(response[1]["label"], "sign up - other_value")
self.assertEqual(response[2]["label"], "no events - value")
self.assertEqual(response[3]["label"], "no events - other_value")
self.assertEqual(sum(response[0]["data"]), 2)
self.assertEqual(response[0]["breakdown_value"], "value")
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["breakdown_value"], "other_value")
def test_breakdown_filtering_with_properties(self):
with freeze_time("2020-01-03T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "first url",
"$browser": "Firefox",
"$os": "Mac"
},
)
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "first url",
"$browser": "Chrome",
"$os": "Windows"
},
)
with freeze_time("2020-01-04T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "second url",
"$browser": "Firefox",
"$os": "Mac"
},
)
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "second url",
"$browser": "Chrome",
"$os": "Windows"
},
)
with freeze_time("2020-01-05T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"$current_url",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
"properties": [{
"key": "$os",
"value": "Mac"
}],
},
],
"properties": [{
"key": "$browser",
"value": "Firefox"
}],
}),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - second url")
self.assertEqual(response[1]["label"], "sign up - first url")
self.assertEqual(sum(response[0]["data"]), 1)
self.assertEqual(response[0]["breakdown_value"], "second url")
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["breakdown_value"], "first url")
def test_dau_with_breakdown_filtering(self):
sign_up_action, _ = self._create_events()
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$some_property": "other_value"},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"actions": [{
"id": sign_up_action.id,
"math": "dau"
}]
}),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"events": [{
"id": "sign up",
"math": "dau"
}]
}),
self.team,
)
self.assertEqual(event_response[0]["label"], "sign up - value")
self.assertEqual(event_response[1]["label"], "sign up - other_value")
self.assertEqual(sum(event_response[0]["data"]), 1)
self.assertEqual(event_response[0]["data"][4],
1) # property not defined
self.assertEqual(sum(event_response[1]["data"]), 1)
self.assertEqual(event_response[1]["data"][5], 1)
self.assertTrue(
self._compare_entity_response(action_response, event_response))
def test_dau_with_breakdown_filtering_with_prop_filter(self):
sign_up_action, _ = self._create_events()
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$some_property": "other_value",
"$os": "Windows"
},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"actions": [{
"id": sign_up_action.id,
"math": "dau"
}],
"properties": [{
"key": "$os",
"value": "Windows"
}],
}),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"events": [{
"id": "sign up",
"math": "dau"
}],
"properties": [{
"key": "$os",
"value": "Windows"
}],
}),
self.team,
)
self.assertEqual(event_response[0]["label"], "sign up - value")
self.assertEqual(event_response[1]["label"], "sign up - other_value")
self.assertEqual(sum(event_response[1]["data"]), 1)
self.assertEqual(event_response[1]["data"][5],
1) # property not defined
self.assertTrue(
self._compare_entity_response(action_response, event_response))
# this ensures that the properties don't conflict when formatting params
def test_action_with_prop(self):
person = Person.objects.create(team_id=self.team.pk,
distinct_ids=["blabla", "anonymous_id"],
properties={"$some_prop": "some_val"})
sign_up_action = Action.objects.create(team=self.team, name="sign up")
ActionStep.objects.create(
action=sign_up_action,
event="sign up",
properties={"$current_url": "https://posthog.com/feedback/1234"})
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "https://posthog.com/feedback/1234"
},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"actions": [{
"id": sign_up_action.id,
"math": "dau"
}],
"properties": [{
"key": "$current_url",
"value": "fake"
}],
}),
self.team,
)
# if the params were shared it would be 1 because action would take precedence
self.assertEqual(action_response[0]["count"], 0)
def test_combine_all_cohort_and_icontains(self):
# This caused some issues with SQL parsing
sign_up_action, _ = self._create_events()
cohort = Cohort.objects.create(team=self.team,
name="a",
groups=[{
"properties": {
"key": "value"
}
}])
action_response = ClickhouseTrends().run(
Filter(
data={
"actions": [{
"id": sign_up_action.id,
"math": "dau"
}],
"properties": [{
"key": "$current_url",
"value": "ii",
"operator": "icontains"
}],
"breakdown": [cohort.pk, "all"],
"breakdown_type":
"cohort",
}),
self.team,
)
self.assertEqual(action_response[0]["count"], 0)
class TestClickhouseTrends(ClickhouseTestMixin, trend_test_factory(ClickhouseTrends, _create_event, Person.objects.create, _create_action, _create_cohort)): # type: ignore
def test_breakdown_with_filter(self):
Person.objects.create(team_id=self.team.pk, distinct_ids=["person1"], properties={"email": "*****@*****.**"})
Person.objects.create(team_id=self.team.pk, distinct_ids=["person2"], properties={"email": "*****@*****.**"})
_create_event(event="sign up", distinct_id="person1", team=self.team, properties={"key": "val"})
_create_event(event="sign up", distinct_id="person2", team=self.team, properties={"key": "oh"})
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "key",
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,}],
"properties": [{"key": "key", "value": "oh", "operator": "not_icontains"}],
}
),
self.team,
)
self.assertEqual(len(response), 2)
self.assertEqual(response[1]["breakdown_value"], "val")
def test_breakdown_filtering_limit(self):
self._create_breakdown_events()
with freeze_time("2020-01-04T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "$some_property",
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0}],
}
),
self.team,
)
self.assertEqual(len(response), 26) # We fetch 25 to see if there are more ethan 20 values
def test_breakdown_by_person_property(self):
person1, person2, person3, person4 = self._create_multiple_people()
action = _create_action(name="watched movie", team=self.team)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "name",
"breakdown_type": "person",
"actions": [{"id": action.pk, "type": "actions", "order": 0}],
}
),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "name",
"breakdown_type": "person",
"events": [{"id": "watched movie", "name": "watched movie", "type": "events", "order": 0,}],
}
),
self.team,
)
self.assertListEqual(
[res["breakdown_value"] for res in event_response], ["none", "person1", "person2", "person3"]
)
for response in event_response:
if response["breakdown_value"] == "person1":
self.assertEqual(response["count"], 1)
self.assertEqual(response["label"], "watched movie - person1")
if response["breakdown_value"] == "person2":
self.assertEqual(response["count"], 3)
if response["breakdown_value"] == "person3":
self.assertEqual(response["count"], 3)
self.assertEntityResponseEqual(
event_response, action_response,
)
def test_breakdown_filtering(self):
self._create_events()
# test breakdown filtering
with freeze_time("2020-01-04T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "$some_property",
"events": [
{"id": "sign up", "name": "sign up", "type": "events", "order": 0,},
{"id": "no events"},
],
}
),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - none")
self.assertEqual(response[1]["label"], "sign up - value")
self.assertEqual(response[2]["label"], "sign up - other_value")
self.assertEqual(response[3]["label"], "no events - none")
self.assertEqual(sum(response[0]["data"]), 2)
self.assertEqual(sum(response[1]["data"]), 2)
self.assertEqual(sum(response[2]["data"]), 1)
self.assertEqual(sum(response[3]["data"]), 1)
def test_breakdown_filtering_persons(self):
Person.objects.create(team_id=self.team.pk, distinct_ids=["person1"], properties={"email": "*****@*****.**"})
Person.objects.create(team_id=self.team.pk, distinct_ids=["person2"], properties={"email": "*****@*****.**"})
Person.objects.create(team_id=self.team.pk, distinct_ids=["person3"], properties={})
_create_event(event="sign up", distinct_id="person1", team=self.team, properties={"key": "val"})
_create_event(event="sign up", distinct_id="person2", team=self.team, properties={"key": "val"})
_create_event(event="sign up", distinct_id="person3", team=self.team, properties={"key": "val"})
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "email",
"breakdown_type": "person",
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,},],
}
),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - none")
self.assertEqual(response[1]["label"], "sign up - [email protected]")
self.assertEqual(response[2]["label"], "sign up - [email protected]")
self.assertEqual(response[0]["count"], 1)
self.assertEqual(response[1]["count"], 1)
self.assertEqual(response[2]["count"], 1)
# ensure that column names are properly handled when subqueries and person subquery share properties column
def test_breakdown_filtering_persons_with_action_props(self):
Person.objects.create(team_id=self.team.pk, distinct_ids=["person1"], properties={"email": "*****@*****.**"})
Person.objects.create(team_id=self.team.pk, distinct_ids=["person2"], properties={"email": "*****@*****.**"})
Person.objects.create(team_id=self.team.pk, distinct_ids=["person3"], properties={})
_create_event(event="sign up", distinct_id="person1", team=self.team, properties={"key": "val"})
_create_event(event="sign up", distinct_id="person2", team=self.team, properties={"key": "val"})
_create_event(event="sign up", distinct_id="person3", team=self.team, properties={"key": "val"})
action = _create_action(
name="sign up",
team=self.team,
properties=[{"key": "key", "type": "event", "value": ["val"], "operator": "exact"}],
)
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "email",
"breakdown_type": "person",
"actions": [{"id": action.pk, "type": "actions", "order": 0}],
}
),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - none")
self.assertEqual(response[1]["label"], "sign up - [email protected]")
self.assertEqual(response[2]["label"], "sign up - [email protected]")
self.assertEqual(response[0]["count"], 1)
self.assertEqual(response[1]["count"], 1)
self.assertEqual(response[2]["count"], 1)
def test_breakdown_filtering_with_properties(self):
with freeze_time("2020-01-03T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$current_url": "first url", "$browser": "Firefox", "$os": "Mac"},
)
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$current_url": "first url", "$browser": "Chrome", "$os": "Windows"},
)
with freeze_time("2020-01-04T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$current_url": "second url", "$browser": "Firefox", "$os": "Mac"},
)
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$current_url": "second url", "$browser": "Chrome", "$os": "Windows"},
)
with freeze_time("2020-01-05T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "$current_url",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
"properties": [{"key": "$os", "value": "Mac"}],
},
],
"properties": [{"key": "$browser", "value": "Firefox"}],
}
),
self.team,
)
self.assertEqual(response[1]["label"], "sign up - second url")
self.assertEqual(response[2]["label"], "sign up - first url")
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["breakdown_value"], "second url")
self.assertEqual(sum(response[2]["data"]), 1)
self.assertEqual(response[2]["breakdown_value"], "first url")
def test_dau_with_breakdown_filtering(self):
sign_up_action, _ = self._create_events()
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team, event="sign up", distinct_id="blabla", properties={"$some_property": "other_value"},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(data={"breakdown": "$some_property", "actions": [{"id": sign_up_action.id, "math": "dau"}]}),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(data={"breakdown": "$some_property", "events": [{"id": "sign up", "math": "dau"}]}), self.team,
)
self.assertEqual(event_response[1]["label"], "sign up - value")
self.assertEqual(event_response[2]["label"], "sign up - other_value")
self.assertEqual(sum(event_response[1]["data"]), 1)
self.assertEqual(event_response[1]["data"][4], 1) # property not defined
self.assertEqual(sum(event_response[2]["data"]), 1)
self.assertEqual(event_response[2]["data"][5], 1)
self.assertEntityResponseEqual(action_response, event_response)
def test_dau_with_breakdown_filtering_with_prop_filter(self):
sign_up_action, _ = self._create_events()
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$some_property": "other_value", "$os": "Windows"},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"actions": [{"id": sign_up_action.id, "math": "dau"}],
"properties": [{"key": "$os", "value": "Windows"}],
}
),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"events": [{"id": "sign up", "math": "dau"}],
"properties": [{"key": "$os", "value": "Windows"}],
}
),
self.team,
)
self.assertEqual(event_response[1]["label"], "sign up - other_value")
self.assertEqual(sum(event_response[1]["data"]), 1)
self.assertEqual(event_response[1]["data"][5], 1) # property not defined
self.assertEntityResponseEqual(action_response, event_response)
# this ensures that the properties don't conflict when formatting params
def test_action_with_prop(self):
person = Person.objects.create(
team_id=self.team.pk, distinct_ids=["blabla", "anonymous_id"], properties={"$some_prop": "some_val"}
)
sign_up_action = Action.objects.create(team=self.team, name="sign up")
ActionStep.objects.create(
action=sign_up_action, event="sign up", properties={"$current_url": "https://posthog.com/feedback/1234"}
)
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$current_url": "https://posthog.com/feedback/1234"},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"actions": [{"id": sign_up_action.id, "math": "dau"}],
"properties": [{"key": "$current_url", "value": "fake"}],
}
),
self.team,
)
# if the params were shared it would be 1 because action would take precedence
self.assertEqual(action_response[0]["count"], 0)
def test_combine_all_cohort_and_icontains(self):
# This caused some issues with SQL parsing
sign_up_action, _ = self._create_events()
cohort = Cohort.objects.create(team=self.team, name="a", groups=[{"properties": {"key": "value"}}])
action_response = ClickhouseTrends().run(
Filter(
data={
"actions": [{"id": sign_up_action.id, "math": "dau"}],
"properties": [{"key": "$current_url", "value": "ii", "operator": "icontains"}],
"breakdown": [cohort.pk, "all"],
"breakdown_type": "cohort",
}
),
self.team,
)
self.assertEqual(action_response[0]["count"], 0)
def test_breakdown_user_props_with_filter(self):
Person.objects.create(team_id=self.team.pk, distinct_ids=["person1"], properties={"email": "*****@*****.**"})
Person.objects.create(team_id=self.team.pk, distinct_ids=["person2"], properties={"email": "*****@*****.**"})
person = Person.objects.create(
team_id=self.team.pk, distinct_ids=["person3"], properties={"email": "*****@*****.**"}
)
create_person_distinct_id(person.id, self.team.pk, "person1", str(person.uuid))
_create_event(event="sign up", distinct_id="person1", team=self.team, properties={"key": "val"})
_create_event(event="sign up", distinct_id="person2", team=self.team, properties={"key": "val"})
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-14d",
"breakdown": "email",
"breakdown_type": "person",
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,}],
"properties": [
{"key": "email", "value": "@posthog.com", "operator": "not_icontains", "type": "person"},
{"key": "key", "value": "val"},
],
}
),
self.team,
)
self.assertEqual(len(response), 2)
self.assertEqual(response[1]["breakdown_value"], "*****@*****.**")
def _create_active_user_events(self):
p0 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p0"], properties={"name": "p1"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p0",
timestamp="2020-01-03T12:00:00Z",
properties={"key": "val"},
)
p1 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p1"], properties={"name": "p1"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-09T12:00:00Z",
properties={"key": "val"},
)
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-10T12:00:00Z",
properties={"key": "val"},
)
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-11T12:00:00Z",
properties={"key": "val"},
)
p2 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p2"], properties={"name": "p2"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p2",
timestamp="2020-01-09T12:00:00Z",
properties={"key": "val"},
)
_create_event(
team=self.team,
event="$pageview",
distinct_id="p2",
timestamp="2020-01-11T12:00:00Z",
properties={"key": "val"},
)
def test_active_user_math(self):
self._create_active_user_events()
data = {
"date_from": "2020-01-09T00:00:00Z",
"date_to": "2020-01-16T00:00:00Z",
"events": [{"id": "$pageview", "type": "events", "order": 0, "math": "weekly_active"}],
}
filter = Filter(data=data)
result = ClickhouseTrends().run(filter, self.team,)
self.assertEqual(result[0]["data"], [3.0, 2.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0])
def test_active_user_math_action(self):
action = _create_action(name="$pageview", team=self.team)
self._create_active_user_events()
data = {
"date_from": "2020-01-09T00:00:00Z",
"date_to": "2020-01-16T00:00:00Z",
"actions": [{"id": action.id, "type": "actions", "order": 0, "math": "weekly_active"}],
}
filter = Filter(data=data)
result = ClickhouseTrends().run(filter, self.team,)
self.assertEqual(result[0]["data"], [3.0, 2.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0])
def test_breakdown_active_user_math(self):
p1 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p1"], properties={"name": "p1"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-09T12:00:00Z",
properties={"key": "val"},
)
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-10T12:00:00Z",
properties={"key": "val"},
)
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-11T12:00:00Z",
properties={"key": "val"},
)
p2 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p2"], properties={"name": "p2"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p2",
timestamp="2020-01-09T12:00:00Z",
properties={"key": "val"},
)
_create_event(
team=self.team,
event="$pageview",
distinct_id="p2",
timestamp="2020-01-11T12:00:00Z",
properties={"key": "val"},
)
data = {
"date_from": "2020-01-01T00:00:00Z",
"date_to": "2020-01-12T00:00:00Z",
"breakdown": "key",
"events": [{"id": "$pageview", "type": "events", "order": 0, "math": "weekly_active"}],
}
filter = Filter(data=data)
result = ClickhouseTrends().run(filter, self.team,)
self.assertEqual(result[1]["data"], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 0.0])
def test_filter_test_accounts(self):
p1 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p1"], properties={"name": "p1"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p1",
timestamp="2020-01-11T12:00:00Z",
properties={"key": "val"},
)
p2 = Person.objects.create(team_id=self.team.pk, distinct_ids=["p2"], properties={"name": "p2"})
_create_event(
team=self.team,
event="$pageview",
distinct_id="p2",
timestamp="2020-01-11T12:00:00Z",
properties={"key": "val"},
)
self.team.test_account_filters = [{"key": "name", "value": "p1", "operator": "is_not", "type": "person"}]
self.team.save()
data = {
"date_from": "2020-01-01T00:00:00Z",
"date_to": "2020-01-12T00:00:00Z",
"events": [{"id": "$pageview", "type": "events", "order": 0}],
"filter_test_accounts": "true",
}
filter = Filter(data=data)
filter_2 = Filter(data={**data, "filter_test_accounts": "false",})
filter_3 = Filter(data={**data, "breakdown": "key"})
result = ClickhouseTrends().run(filter, self.team,)
self.assertEqual(result[0]["count"], 1)
result = ClickhouseTrends().run(filter_2, self.team,)
self.assertEqual(result[0]["count"], 2)
result = ClickhouseTrends().run(filter_3, self.team,)
self.assertEqual(result[1]["count"], 1)
def test_breakdown_filtering_bar_chart_by_value(self):
self._create_events()
# test breakdown filtering
with freeze_time("2020-01-04T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from": "-7d",
"breakdown": "$some_property",
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,},],
"display": TRENDS_BAR_VALUE,
}
),
self.team,
)
self.assertEqual(response[0]["aggregated_value"], 1)
self.assertEqual(response[1]["aggregated_value"], 1)
self.assertEqual(
response[0]["days"],
[
"2019-12-28",
"2019-12-29",
"2019-12-30",
"2019-12-31",
"2020-01-01",
"2020-01-02",
"2020-01-03",
"2020-01-04",
],
)
class TestClickhouseTrends(ClickhouseTestMixin,
trend_test_factory(ClickhouseTrends, _create_event,
Person.objects.create,
_create_action,
_create_cohort)): # type: ignore
def test_breakdown_by_person_property(self):
person1, person2, person3, person4 = self._create_multiple_people()
action = _create_action(name="watched movie", team=self.team)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"name",
"breakdown_type":
"person",
"actions": [{
"id": action.pk,
"type": "actions",
"order": 0
}],
}),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"name",
"breakdown_type":
"person",
"events": [{
"id": "watched movie",
"name": "watched movie",
"type": "events",
"order": 0,
}],
}),
self.team,
)
self.assertListEqual(
[res["breakdown_value"] for res in event_response],
["person1", "person2", "person3"])
for response in event_response:
if response["breakdown_value"] == "person1":
self.assertEqual(response["count"], 1)
self.assertEqual(response["label"], "watched movie - person1")
if response["breakdown_value"] == "person2":
self.assertEqual(response["count"], 3)
if response["breakdown_value"] == "person3":
self.assertEqual(response["count"], 3)
self.assertTrue(
self._compare_entity_response(
event_response,
action_response,
))
def test_breakdown_filtering(self):
self._create_events()
# test breakdown filtering
with freeze_time("2020-01-04T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"$some_property",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
},
{
"id": "no events"
},
],
}),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - value")
self.assertEqual(response[1]["label"], "sign up - other_value")
self.assertEqual(response[2]["label"], "no events - value")
self.assertEqual(response[3]["label"], "no events - other_value")
self.assertEqual(sum(response[0]["data"]), 2)
self.assertEqual(response[0]["breakdown_value"], "value")
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["breakdown_value"], "other_value")
def test_breakdown_filtering_with_properties(self):
with freeze_time("2020-01-03T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "first url",
"$browser": "Firefox",
"$os": "Mac"
},
)
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "first url",
"$browser": "Chrome",
"$os": "Windows"
},
)
with freeze_time("2020-01-04T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "second url",
"$browser": "Firefox",
"$os": "Mac"
},
)
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$current_url": "second url",
"$browser": "Chrome",
"$os": "Windows"
},
)
with freeze_time("2020-01-05T13:01:01Z"):
response = ClickhouseTrends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"$current_url",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
"properties": [{
"key": "$os",
"value": "Mac"
}],
},
],
"properties": [{
"key": "$browser",
"value": "Firefox"
}],
}),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - second url")
self.assertEqual(response[1]["label"], "sign up - first url")
self.assertEqual(sum(response[0]["data"]), 1)
self.assertEqual(response[0]["breakdown_value"], "second url")
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["breakdown_value"], "first url")
def test_dau_with_breakdown_filtering(self):
sign_up_action, _ = self._create_events()
with freeze_time("2020-01-02T13:01:01Z"):
_create_event(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$some_property": "other_value"},
)
with freeze_time("2020-01-04T13:01:01Z"):
action_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"actions": [{
"id": sign_up_action.id,
"math": "dau"
}]
}),
self.team,
)
event_response = ClickhouseTrends().run(
Filter(
data={
"breakdown": "$some_property",
"events": [{
"id": "sign up",
"math": "dau"
}]
}),
self.team,
)
self.assertEqual(event_response[0]["label"], "sign up - value")
self.assertEqual(event_response[1]["label"], "sign up - other_value")
self.assertEqual(sum(event_response[0]["data"]), 1)
self.assertEqual(event_response[0]["data"][4],
1) # property not defined
self.assertEqual(sum(event_response[1]["data"]), 1)
self.assertEqual(event_response[1]["data"][5], 1)
self.assertTrue(
self._compare_entity_response(action_response, event_response))
class TestClickhouseTrends(trend_test_factory(Trends)): # type: ignore
maxDiff = None
def _get_trend_people(self, filter, entity):
_, serialized_actors = TrendsActors(filter=filter, entity=entity, team=self.team).get_actors()
return serialized_actors
def _create_groups(self):
GroupTypeMapping.objects.create(team=self.team, group_type="organization", group_type_index=0)
GroupTypeMapping.objects.create(team=self.team, group_type="company", group_type_index=1)
create_group(team_id=self.team.pk, group_type_index=0, group_key="org:5", properties={"industry": "finance"})
create_group(team_id=self.team.pk, group_type_index=0, group_key="org:6", properties={"industry": "technology"})
create_group(team_id=self.team.pk, group_type_index=0, group_key="org:7", properties={"industry": "finance"})
create_group(
team_id=self.team.pk, group_type_index=1, group_key="company:10", properties={"industry": "finance"}
)
def test_breakdown_with_filter_groups(self):
self._create_groups()
_create_event(
event="sign up",
distinct_id="person1",
team=self.team,
properties={"key": "oh", "$group_0": "org:7", "$group_1": "company:10"},
timestamp="2020-01-02T12:00:00Z",
)
_create_event(
event="sign up",
distinct_id="person1",
team=self.team,
properties={"key": "uh", "$group_0": "org:5"},
timestamp="2020-01-02T12:00:01Z",
)
_create_event(
event="sign up",
distinct_id="person1",
team=self.team,
properties={"key": "uh", "$group_0": "org:6"},
timestamp="2020-01-02T12:00:02Z",
)
response = Trends().run(
Filter(
data={
"date_from": "2020-01-01T00:00:00Z",
"date_to": "2020-01-12T00:00:00Z",
"breakdown": "key",
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,}],
"properties": [{"key": "industry", "value": "finance", "type": "group", "group_type_index": 0}],
}
),
self.team,
)
self.assertEqual(len(response), 2)
self.assertEqual(response[0]["breakdown_value"], "oh")
self.assertEqual(response[0]["count"], 1)
self.assertEqual(response[1]["breakdown_value"], "uh")
self.assertEqual(response[1]["count"], 1)
@snapshot_clickhouse_queries
def test_breakdown_by_group_props(self):
self._create_groups()
journey = {
"person1": [
{
"event": "sign up",
"timestamp": datetime(2020, 1, 2, 12),
"properties": {"$group_0": "org:5"},
"group0_properties": {"industry": "finance"},
},
{
"event": "sign up",
"timestamp": datetime(2020, 1, 2, 13),
"properties": {"$group_0": "org:6"},
"group0_properties": {"industry": "technology"},
},
{
"event": "sign up",
"timestamp": datetime(2020, 1, 2, 15),
"properties": {"$group_0": "org:7", "$group_1": "company:10"},
"group0_properties": {"industry": "finance"},
"group1_properties": {"industry": "finance"},
},
],
}
journeys_for(events_by_person=journey, team=self.team)
filter = Filter(
data={
"date_from": "2020-01-01T00:00:00Z",
"date_to": "2020-01-12",
"breakdown": "industry",
"breakdown_type": "group",
"breakdown_group_type_index": 0,
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,}],
}
)
response = Trends().run(filter, self.team,)
self.assertEqual(len(response), 2)
self.assertEqual(response[0]["breakdown_value"], "finance")
self.assertEqual(response[0]["count"], 2)
self.assertEqual(response[1]["breakdown_value"], "technology")
self.assertEqual(response[1]["count"], 1)
filter = filter.with_data(
{"breakdown_value": "technology", "date_from": "2020-01-02T00:00:00Z", "date_to": "2020-01-03"}
)
entity = Entity({"id": "sign up", "name": "sign up", "type": "events", "order": 0,})
res = self._get_trend_people(filter, entity)
self.assertEqual(res[0]["distinct_ids"], ["person1"])
@snapshot_clickhouse_queries
def test_breakdown_by_group_props_with_person_filter(self):
self._create_groups()
Person.objects.create(team_id=self.team.pk, distinct_ids=["person1"], properties={"key": "value"})
_create_event(
event="sign up",
distinct_id="person1",
team=self.team,
properties={"$group_0": "org:5"},
timestamp="2020-01-02T12:00:00Z",
person_properties={"key": "value"},
group0_properties={"industry": "finance"},
)
_create_event(
event="sign up",
distinct_id="person2",
team=self.team,
properties={"$group_0": "org:6"},
timestamp="2020-01-02T12:00:00Z",
person_properties={},
group0_properties={"industry": "technology"},
)
filter = Filter(
data={
"date_from": "2020-01-01T00:00:00Z",
"date_to": "2020-01-12T00:00:00Z",
"breakdown": "industry",
"breakdown_type": "group",
"breakdown_group_type_index": 0,
"events": [{"id": "sign up", "name": "sign up", "type": "events", "order": 0,}],
"properties": [{"key": "key", "value": "value", "type": "person"}],
}
)
response = Trends().run(filter, self.team,)
self.assertEqual(len(response), 1)
self.assertEqual(response[0]["breakdown_value"], "finance")
self.assertEqual(response[0]["count"], 1)
@snapshot_clickhouse_queries
def test_filtering_with_group_props(self):
self._create_groups()
Person.objects.create(team_id=self.team.pk, distinct_ids=["person1"], properties={"key": "value"})
_create_event(
event="$pageview", distinct_id="person1", team=self.team, timestamp="2020-01-02T12:00:00Z",
)
_create_event(
event="$pageview",
distinct_id="person1",
team=self.team,
properties={"$group_0": "org:5"},
timestamp="2020-01-02T12:00:00Z",
)
_create_event(
event="$pageview",
distinct_id="person1",
team=self.team,
properties={"$group_0": "org:6"},
timestamp="2020-01-02T12:00:00Z",
)
_create_event(
event="$pageview",
distinct_id="person1",
team=self.team,
properties={"$group_0": "org:6", "$group_1": "company:10"},
timestamp="2020-01-02T12:00:00Z",
)
filter = Filter(
{
"date_from": "2020-01-01T00:00:00Z",
"date_to": "2020-01-12T00:00:00Z",
"events": [{"id": "$pageview", "type": "events", "order": 0}],
"properties": [
{"key": "industry", "value": "finance", "type": "group", "group_type_index": 0},
{"key": "key", "value": "value", "type": "person"},
],
},
team=self.team,
)
response = Trends().run(filter, self.team)
self.assertEqual(response[0]["count"], 1)