def setUpTestData(cls):
random.seed(900)
super().setUpTestData()
cls.demo_team = create_demo_team(cls.organization)
calculate_event_property_usage_for_team(cls.demo_team.pk)
cls.user.current_team = cls.demo_team
cls.user.save()
def setUpTestData(cls):
random.seed(900)
super().setUpTestData()
cls.demo_team = create_demo_team(cls.organization)
calculate_event_property_usage_for_team(cls.demo_team.pk)
cls.user.current_team = cls.demo_team
cls.user.save()
EventProperty.objects.create(team=cls.demo_team, event="$pageview", property="$browser")
EventProperty.objects.create(team=cls.demo_team, event="$pageview", property="first_visit")
def fix_team_event_names(apps, schema_editor):
Team = apps.get_model("posthog", "Team")
for team in Team.objects.all():
old_event_names = team.event_names
team.event_names = list(event for event in old_event_names
if isinstance(event, str))
if len(team.event_names) != len(old_event_names):
from posthog.tasks.calculate_event_property_usage import calculate_event_property_usage_for_team
team.save()
calculate_event_property_usage_for_team(team.pk)
def test_updating_team_events_or_related_updates_event_definitions(self):
random.seed(900)
org = Organization.objects.create(name="Demo Org")
team = create_demo_team(org, None, None)
expected_events = ["watched_movie", "installed_app", "rated_app", "purchase", "entered_free_trial"]
self.assertEqual(EventDefinition.objects.filter(team=team).count(), len(expected_events))
for obj in EventDefinition.objects.filter(team=team):
self.assertIn(obj.name, expected_events)
self.assertEqual(obj.volume_30_day, None)
self.assertEqual(obj.query_usage_30_day, None)
# Test adding and removing one event
team.event_names.pop(0)
team.event_names.append("uninstalled_app")
team.save()
expected_events = ["installed_app", "rated_app", "purchase", "entered_free_trial", "uninstalled_app"]
self.assertEqual(
list(EventDefinition.objects.filter(team=team).values_list("name", flat=True)).sort(),
expected_events.sort(),
)
# Test events with usage
expected_event_definitions = [
{"name": "installed_app", "volume_30_day": 100, "query_usage_30_day": 0},
{"name": "rated_app", "volume_30_day": 73, "query_usage_30_day": 0},
{"name": "purchase", "volume_30_day": 16, "query_usage_30_day": 0},
{"name": "entered_free_trial", "volume_30_day": 0, "query_usage_30_day": 0},
{"name": "uninstalled_app", "volume_30_day": 0, "query_usage_30_day": 0},
{"name": "$pageview", "volume_30_day": 1822, "query_usage_30_day": 19292},
]
calculate_event_property_usage_for_team(team.pk)
team.refresh_from_db()
team.event_names.append("$pageview")
team.event_names_with_usage.append({"event": "$pageview", "volume": 1822, "usage_count": 19292})
team.save()
self.assertEqual(EventDefinition.objects.filter(team=team).count(), len(expected_event_definitions))
for item in expected_event_definitions:
instance = EventDefinition.objects.get(name=item["name"], team=team)
self.assertEqual(instance.volume_30_day, item["volume_30_day"])
self.assertEqual(instance.query_usage_30_day, item["query_usage_30_day"])
def setUpTestData(cls):
cls.organization = create_organization(name="test org")
cls.demo_team = create_team(organization=cls.organization)
cls.user = create_user("user", "pass", cls.organization)
for event_definition in cls.EXPECTED_EVENT_DEFINITIONS:
create_event_definitions(event_definition["name"],
team_id=cls.demo_team.pk)
for _ in range(event_definition["volume_30_day"]):
capture_event(event=EventData(
event=event_definition["name"],
team_id=cls.demo_team.pk,
distinct_id="abc",
timestamp=datetime(2020, 1, 1),
properties={},
))
# To ensure `volume_30_day` and `query_usage_30_day` are returned non
# None, we need to call this task to have them calculated.
calculate_event_property_usage_for_team(cls.demo_team.pk)
def test_updating_event_properties_or_related_updates_property_definitions(
self):
random.seed(900)
org = Organization.objects.create(name="Demo Org")
team = create_demo_team(org, None, None)
expected_properties = [
"purchase",
"$current_url",
"is_first_movie",
"app_rating",
"plan",
"first_visit",
"purchase_value",
]
numerical_properties = ["purchase", "app_rating", "purchase_value"]
self.assertEqual(
PropertyDefinition.objects.filter(team=team).count(),
len(expected_properties))
for obj in PropertyDefinition.objects.filter(team=team):
self.assertIn(obj.name, expected_properties)
self.assertEqual(obj.volume_30_day, None)
self.assertEqual(obj.query_usage_30_day, None)
self.assertEqual(obj.is_numerical, obj.name
in numerical_properties)
# Test adding and removing one event
team.event_properties.pop(-1)
team.event_properties.append("paid_tier")
team.save()
expected_properties = [
"purchase",
"$current_url",
"is_first_movie",
"app_rating",
"plan",
"first_visit",
"paid_tier",
]
self.assertEqual(
list(
PropertyDefinition.objects.filter(team=team).values_list(
"name", flat=True)).sort(),
expected_properties.sort(),
)
# Test events with usage
expected_property_definitions = [
{
"name": "$current_url",
"volume_30_day": 264,
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "is_first_movie",
"volume_30_day": 87,
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "app_rating",
"volume_30_day": 73,
"query_usage_30_day": 0,
"is_numerical": True
},
{
"name": "plan",
"volume_30_day": 14,
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "purchase",
"volume_30_day": 0,
"query_usage_30_day": 0,
"is_numerical": True
},
{
"name": "paid_tier",
"volume_30_day": 0,
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "first_visit",
"volume_30_day": 0,
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "$browser",
"volume_30_day": 166,
"query_usage_30_day": 349,
"is_numerical": True
},
]
calculate_event_property_usage_for_team(team.pk)
team.refresh_from_db()
team.event_properties.append("$browser")
team.event_properties_numerical.append("$browser")
team.event_properties_with_usage.append({
"key": "$browser",
"volume": 166,
"usage_count": 349
})
team.save()
self.assertEqual(
PropertyDefinition.objects.filter(team=team).count(),
len(expected_property_definitions))
for item in expected_property_definitions:
instance = PropertyDefinition.objects.get(name=item["name"],
team=team)
self.assertEqual(instance.volume_30_day, item["volume_30_day"])
self.assertEqual(instance.query_usage_30_day,
item["query_usage_30_day"])
self.assertEqual(instance.is_numerical, item["is_numerical"])
def test_calculate_usage(self) -> None:
self.team.event_names = ["$pageview", "custom event"]
self.team.event_properties = ["$current_url", "team_id", "value"]
self.team.save()
team2 = Team.objects.create()
with freeze_time("2020-08-01"):
# ignore stuff older than 30 days
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
with freeze_time("2020-10-01"):
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog2.com"
}],
},
)
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "custom event"
}],
"properties": [{
"key": "team_id",
"value": "3"
}]
},
)
DashboardItem.objects.create(
team=self.team,
filters={"events": [{
"id": "event that doesnt exist"
}]})
# broken dashboard item
DashboardItem.objects.create(team=self.team, filters={})
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog2.com"},
)
create_event(distinct_id="test",
team=self.team,
event="custom event",
properties={"team_id": "3"})
# team leakage
create_event(
distinct_id="test",
team=team2,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
DashboardItem.objects.create(
team=team2,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
calculate_event_property_usage_for_team(self.team.pk)
team = Team.objects.get(pk=self.team.pk)
self.assertEqual(
team.event_names_with_usage,
[
{
"event": "$pageview",
"usage_count": 2,
"volume": 2
},
{
"event": "custom event",
"usage_count": 1,
"volume": 1
},
],
)
self.assertEqual(
team.event_properties_with_usage,
[
{
"key": "$current_url",
"usage_count": 2,
"volume": 2
},
{
"key": "team_id",
"usage_count": 1,
"volume": 1
},
{
"key": "value",
"usage_count": 0,
"volume": 0
},
],
)
def test_updating_event_properties_or_related_updates_property_definitions(
self) -> None:
random.seed(900)
org = Organization.objects.create(name="Demo Org")
team = create_demo_team(org, None, None)
expected_properties = [
"purchase",
"$current_url",
"$browser",
"is_first_movie",
"app_rating",
"plan",
"first_visit",
"purchase_value",
]
numerical_properties = ["purchase", "app_rating", "purchase_value"]
self.assertCountEqual(
PropertyDefinition.objects.filter(team=team).values_list(
"name", flat=True),
expected_properties,
PropertyDefinition.objects.filter(team=team).values("name"),
)
for obj in PropertyDefinition.objects.filter(team=team):
self.assertIn(obj.name, expected_properties)
self.assertEqual(obj.volume_30_day, None)
self.assertEqual(obj.query_usage_30_day, None)
self.assertEqual(obj.is_numerical, obj.name
in numerical_properties)
DashboardItem.objects.create(team=team,
filters={
"properties": [{
"key": "$browser",
"value": "Safari"
}]
})
# Test events with usage
expected_property_definitions = [
{
"name": "$current_url",
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "is_first_movie",
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "app_rating",
"query_usage_30_day": 0,
"is_numerical": True
},
{
"name": "plan",
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "purchase",
"query_usage_30_day": 0,
"is_numerical": True
},
{
"name": "purchase_value",
"query_usage_30_day": 0,
"is_numerical": True
},
{
"name": "first_visit",
"query_usage_30_day": 0,
"is_numerical": False
},
{
"name": "$browser",
"query_usage_30_day": 1,
"is_numerical": False
},
]
calculate_event_property_usage_for_team(team.pk)
self.assertEqual(
PropertyDefinition.objects.filter(team=team).count(),
len(expected_property_definitions))
for item in expected_property_definitions:
instance = PropertyDefinition.objects.get(name=item["name"],
team=team)
self.assertEqual(instance.query_usage_30_day,
item["query_usage_30_day"], item)
self.assertEqual(instance.is_numerical, item["is_numerical"],
item)
def test_calculate_usage(self) -> None:
EventDefinition.objects.create(team=self.team, name="$pageview")
EventDefinition.objects.create(team=self.team, name="custom event")
PropertyDefinition.objects.create(team=self.team,
name="$current_url")
PropertyDefinition.objects.create(team=self.team, name="team_id")
PropertyDefinition.objects.create(team=self.team, name="value")
team2 = Organization.objects.bootstrap(None)[2]
with freeze_time("2020-08-01"):
# ignore stuff older than 30 days
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
with freeze_time("2020-10-01"):
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog2.com"
}],
},
)
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "custom event"
}],
"properties": [{
"key": "team_id",
"value": "3"
}]
},
)
DashboardItem.objects.create(
team=self.team,
filters={"events": [{
"id": "event that doesnt exist"
}]})
# broken dashboard item
DashboardItem.objects.create(team=self.team, filters={})
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog2.com"},
)
create_event(distinct_id="test",
team=self.team,
event="custom event",
properties={"team_id": "3"})
# team leakage
create_event(
distinct_id="test",
team=team2,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
DashboardItem.objects.create(
team=team2,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
calculate_event_property_usage_for_team(self.team.pk)
self.assertEqual(
2,
EventDefinition.objects.get(
team=self.team, name="$pageview").query_usage_30_day)
self.assertEqual(
2,
EventDefinition.objects.get(team=self.team,
name="$pageview").volume_30_day)
self.assertEqual(
1,
EventDefinition.objects.get(
team=self.team, name="custom event").query_usage_30_day)
self.assertEqual(
1,
EventDefinition.objects.get(team=self.team,
name="custom event").volume_30_day)
self.assertEqual(
2,
PropertyDefinition.objects.get(
team=self.team, name="$current_url").query_usage_30_day)
self.assertEqual(
1,
PropertyDefinition.objects.get(
team=self.team, name="team_id").query_usage_30_day)
self.assertEqual(
0,
PropertyDefinition.objects.get(
team=self.team, name="value").query_usage_30_day)
def test_updating_team_events_or_related_updates_event_definitions(
self) -> None:
random.seed(900) # ensure random data is consistent
org = Organization.objects.create(name="Demo Org")
team = create_demo_team(org, None, None)
expected_events = [
"watched_movie",
"installed_app",
"rated_app",
"purchase",
"entered_free_trial",
"$pageview",
]
self.assertEqual(
EventDefinition.objects.filter(team=team).count(),
len(expected_events))
for obj in EventDefinition.objects.filter(team=team):
self.assertIn(obj.name, expected_events)
self.assertEqual(obj.volume_30_day, None)
self.assertEqual(obj.query_usage_30_day, None)
DashboardItem.objects.create(
team=team, filters={"events": [{
"id": "$pageview"
}]})
# Test events with usage
expected_event_definitions = [
{
"name": "installed_app",
"volume_30_day": 100,
"query_usage_30_day": 0
},
{
"name": "rated_app",
"volume_30_day": 73,
"query_usage_30_day": 0
},
{
"name": "purchase",
"volume_30_day": 16,
"query_usage_30_day": 0
},
{
"name": "entered_free_trial",
"volume_30_day": 0,
"query_usage_30_day": 0
},
{
"name": "watched_movie",
"volume_30_day": 87,
"query_usage_30_day": 0
},
{
"name": "$pageview",
"volume_30_day": 327,
"query_usage_30_day": 1
},
]
calculate_event_property_usage_for_team(team.pk)
self.assertEqual(
EventDefinition.objects.filter(team=team).count(),
len(expected_event_definitions))
for item in expected_event_definitions:
instance = EventDefinition.objects.get(name=item["name"],
team=team)
self.assertEqual(instance.volume_30_day, item["volume_30_day"],
item)
self.assertEqual(instance.query_usage_30_day,
item["query_usage_30_day"], item)
