def test_simplify_cohorts(self):
cohort = Cohort.objects.create(
team=self.team,
groups=[{
"properties": [{
"key": "email",
"operator": "icontains",
"value": ".com",
"type": "person"
}]
}],
)
cohort.calculate_people_ch(pending_version=0)
filter = Filter(data={
"properties": [{
"type": "cohort",
"key": "id",
"value": cohort.pk
}]
})
filter_with_groups = Filter(
data={
"properties": {
"type": "AND",
"values": [{
"type": "cohort",
"key": "id",
"value": cohort.pk
}]
}
})
self.assertEqual(
filter.simplify(self.team).properties_to_dict(),
{
"properties": {
"type":
"AND",
"values": [{
"key": "email",
"value": ".com",
"operator": "icontains",
"type": "person"
}],
}
},
)
self.assertEqual(
filter_with_groups.simplify(self.team).properties_to_dict(),
{
"properties": {
"type":
"AND",
"values": [{
"key": "email",
"value": ".com",
"operator": "icontains",
"type": "person"
}],
}
},
)
with self.settings(USE_PRECALCULATED_CH_COHORT_PEOPLE=True):
self.assertEqual(
filter.simplify(self.team).properties_to_dict(),
{
"properties": {
"type":
"AND",
"values": [{
"key": "id",
"value": cohort.pk,
"operator": None,
"type": "precalculated-cohort"
}],
}
},
)
self.assertEqual(
filter_with_groups.simplify(self.team).properties_to_dict(),
{
"properties": {
"type":
"AND",
"values": [{
"key": "id",
"value": cohort.pk,
"operator": None,
"type": "precalculated-cohort"
}],
}
},
)
def test_person_cohort_properties(self):
person1_distinct_id = "person1"
person1 = Person.objects.create(team=self.team,
distinct_ids=[person1_distinct_id],
properties={"$some_prop": "something"})
cohort1 = Cohort.objects.create(
team=self.team,
groups=[{
"properties": [{
"type": "person",
"key": "$some_prop",
"value": "something"
}]
}],
name="cohort1",
)
person2_distinct_id = "person2"
person2 = Person.objects.create(team=self.team,
distinct_ids=[person2_distinct_id],
properties={"$some_prop": "different"})
cohort2 = Cohort.objects.create(
team=self.team,
groups=[{
"properties": [{
"type": "person",
"key": "$some_prop",
"value": "something",
"operator": "is_not"
}]
}],
name="cohort2",
)
filter = Filter(data={
"properties": [{
"key": "id",
"value": cohort1.pk,
"type": "cohort"
}],
},
team=self.team)
prop_clause, prop_clause_params = parse_prop_grouped_clauses(
property_group=filter.property_groups,
has_person_id_joined=False,
team_id=self.team.pk)
query = """
SELECT distinct_id FROM person_distinct_id WHERE team_id = %(team_id)s {prop_clause}
""".format(prop_clause=prop_clause)
# get distinct_id column of result
result = sync_execute(query, {
"team_id": self.team.pk,
**prop_clause_params
})[0][0]
self.assertEqual(result, person1_distinct_id)
# test cohort2 with negation
filter = Filter(data={
"properties": [{
"key": "id",
"value": cohort2.pk,
"type": "cohort"
}],
},
team=self.team)
prop_clause, prop_clause_params = parse_prop_grouped_clauses(
property_group=filter.property_groups,
has_person_id_joined=False,
team_id=self.team.pk)
query = """
SELECT distinct_id FROM person_distinct_id WHERE team_id = %(team_id)s {prop_clause}
""".format(prop_clause=prop_clause)
# get distinct_id column of result
result = sync_execute(query, {
"team_id": self.team.pk,
**prop_clause_params
})[0][0]
self.assertEqual(result, person2_distinct_id)
def test_user_properties(self):
person1 = _create_person(team_id=self.team.pk,
distinct_ids=["person1"],
properties={"group": "some group"})
person2 = _create_person(team_id=self.team.pk,
distinct_ids=["person2"],
properties={"group": "another group"})
event2_uuid = _create_event(
team=self.team,
distinct_id="person1",
event="$pageview",
properties={
"$current_url": "https://something.com",
"another_key": "value",
},
)
event_p2_uuid = _create_event(
team=self.team,
distinct_id="person2",
event="$pageview",
properties={"$current_url": "https://something.com"},
)
# test for leakage
_, _, team2 = Organization.objects.bootstrap(None)
person_team2 = _create_person(team_id=team2.pk,
distinct_ids=["person_team_2"],
properties={"group": "another group"})
event_team2 = _create_event(
team=team2,
distinct_id="person_team_2",
event="$pageview",
properties={
"$current_url": "https://something.com",
"another_key": "value",
},
)
filter = Filter(
data={
"properties": [{
"key": "group",
"value": "some group",
"type": "person"
}]
})
events = _filter_events(filter=filter, team=self.team, order_by=None)
self.assertEqual(len(events), 1)
self.assertEqual(events[0]["id"], event2_uuid)
filter = Filter(
data={
"properties": [{
"key": "group",
"operator": "is_not",
"value": "some group",
"type": "person"
}]
})
events = _filter_events(filter=filter, team=self.team, order_by=None)
self.assertEqual(events[0]["id"], event_p2_uuid)
self.assertEqual(len(events), 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[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_filter_out_team_members_with_grouped_properties(self):
_create_person(
team_id=self.team.pk,
distinct_ids=["person1"],
properties={
"email": "*****@*****.**",
"name": "test",
"age": "10"
},
)
_create_person(
team_id=self.team.pk,
distinct_ids=["person2"],
properties={
"email": "*****@*****.**",
"name": "test",
"age": "20"
},
)
_create_person(
team_id=self.team.pk,
distinct_ids=["person3"],
properties={
"email": "*****@*****.**",
"name": "test",
"age": "30"
},
)
_create_person(
team_id=self.team.pk,
distinct_ids=["person4"],
properties={
"email": "*****@*****.**",
"name": "test",
"age": "40"
},
)
_create_person(
team_id=self.team.pk,
distinct_ids=["person5"],
properties={
"email": "*****@*****.**",
"name": "test",
"age": "50"
},
)
self.team.test_account_filters = [{
"key": "email",
"value": "@posthog.com",
"operator": "not_icontains",
"type": "person"
}]
self.team.save()
journeys_for(
team=self.team,
create_people=False,
events_by_person={
"person1": [{
"event": "$pageview",
"properties": {
"key": "val",
"$browser": "Safari",
"$browser_version": 14
},
}],
"person2": [{
"event": "$pageview",
"properties": {
"key": "val",
"$browser": "Safari",
"$browser_version": 14
},
}],
"person3": [{
"event": "$pageview",
"properties": {
"key": "val",
"$browser": "Safari",
"$browser_version": 14
},
}],
"person4": [{
"event": "$pageview",
"properties": {
"key": "val",
"$browser": "Safari",
"$browser_version": 14
},
}],
"person5": [{
"event": "$pageview",
"properties": {
"key": "val",
"$browser": "Safari",
"$browser_version": 14
},
}],
},
)
filter = Filter(
data={
FILTER_TEST_ACCOUNTS: True,
"events": [{
"id": "$pageview"
}],
"properties": {
"type":
"OR",
"values": [
{
"type":
"OR",
"values": [
{
"key": "age",
"value": "10",
"operator": "exact",
"type": "person"
},
{
"key": "age",
"value": "20",
"operator": "exact",
"type": "person"
},
# choose person 1 and 2
],
},
{
"type":
"AND",
"values": [
{
"key": "$browser",
"value": "Safari",
"operator": "exact",
"type": "event"
},
{
"key": "age",
"value": "50",
"operator": "exact",
"type": "person"
},
# choose person 5
],
},
],
},
},
team=self.team,
)
events = _filter_events(filter=filter, team=self.team)
# test account filters delete person 5, so only 1 and 2 remain
self.assertEqual(len(events), 2)
def test_filter_missing_order(self):
filter = Filter({"foo": "bar"})
self.assertEqual(get_funnel_order_class(filter), ClickhouseFunnel)
def test_unordered_funnel_does_not_return_recordings(self):
p1 = _create_person(distinct_ids=[f"user_1"], team=self.team)
_create_event(
event="step two",
distinct_id="user_1",
team=self.team,
timestamp=timezone.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
properties={
"$session_id": "s1",
"$window_id": "w1"
},
event_uuid="21111111-1111-1111-1111-111111111111",
)
_create_event(
event="step one",
distinct_id="user_1",
team=self.team,
timestamp=(timezone.now() +
timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S.%f"),
properties={
"$session_id": "s1",
"$window_id": "w1"
},
event_uuid="11111111-1111-1111-1111-111111111111",
)
_create_session_recording_event(self.team.pk, "user_1", "s1",
timezone.now() + timedelta(days=1))
filter = Filter(
data={
"insight":
INSIGHT_FUNNELS,
"date_from":
"2021-01-01",
"date_to":
"2021-01-08",
"interval":
"day",
"funnel_window_days":
7,
"funnel_step":
1,
"events": [
{
"id": "step one",
"order": 0
},
{
"id": "step two",
"order": 1
},
{
"id": "step three",
"order": 2
},
],
"include_recordings":
"true", # <- The important line
})
_, results = ClickhouseFunnelUnorderedActors(filter,
self.team).get_actors()
self.assertEqual(results[0]["id"], p1.uuid)
self.assertEqual(
results[0]["matched_recordings"],
[],
)
def test_ordered(self):
filter = Filter({"funnel_order_type": FunnelOrderType.ORDERED})
self.assertEqual(get_funnel_order_class(filter), ClickhouseFunnel)
def test_strict(self):
filter = Filter({"funnel_order_type": FunnelOrderType.STRICT})
self.assertEqual(get_funnel_order_class(filter),
ClickhouseFunnelStrict)
"value": ["label"],
"operator": "exact",
"type": "element"
},
{
"key": "group_prop",
"value": ["value"],
"operator": "exact",
"type": "group",
"group_type_index": 2
},
]
BASE_FILTER = Filter(
{"events": [{
"id": "$pageview",
"type": "events",
"order": 0
}]})
FILTER_WITH_GROUPS = BASE_FILTER.with_data(
{"properties": {
"type": "AND",
"values": PROPERTIES_OF_ALL_TYPES
}})
TEAM_ID = 3
class TestPersonPropertySelector(unittest.TestCase):
def test_basic_selector(self):
filter = BASE_FILTER.with_data({
"properties": {
def test_funnel_no_events(self):
funnel = Funnel(filter=Filter(data={"some": "prop"}),
team=self.team)
self.assertEqual(funnel.run(), [])
def calculate_funnel(self, request: Request) -> Dict[str, Any]:
team = self.team
filter = Filter(request=request, data={"insight": INSIGHT_FUNNELS})
return {"result": ClickhouseFunnel(team=team, filter=filter).run()}
