Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

30.2 KB
Raw Blame
import datetime
from typing import Any, Optional, cast

import pytest
import time_machine
from posthog.test.base import APIBaseTest

from django.db import connection
from django.db.utils import IntegrityError
from django.utils import timezone

from parameterized import parameterized
from rest_framework import status

from posthog.api.test.test_property_definition import exclude_virtual_properties
from posthog.models import ActivityLog, Tag

from products.event_definitions.backend.models import EventProperty
from products.event_definitions.backend.models.property_definition import PropertyDefinition

from ee.models.license import License, LicenseManager
from ee.models.property_definition import EnterprisePropertyDefinition


class TestPropertyDefinitionEnterpriseAPI(APIBaseTest):
    def test_can_set_and_query_property_type_and_format(self):
        property = EnterprisePropertyDefinition.objects.create(
            team=self.team, name="a timestamp", property_type="DateTime"
        )
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["property_type"] == "DateTime"

        query_list_response = self.client.get(f"/api/projects/@current/property_definitions")
        self.assertEqual(query_list_response.status_code, status.HTTP_200_OK)
        matches = [p["name"] for p in query_list_response.json()["results"] if p["name"] == "a timestamp"]
        assert len(matches) == 1

    def test_errors_on_invalid_property_type(self):
        with pytest.raises(IntegrityError):
            EnterprisePropertyDefinition.objects.create(
                team=self.team,
                name="a timestamp",
                property_type="not an allowed option",
            )

    def test_retrieve_existing_property_definition(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        property = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        tag = Tag.objects.create(name="deprecated", team_id=self.team.id)
        property.tagged_items.create(tag_id=tag.id)
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(response_data["name"], "enterprise property")
        self.assertEqual(response_data["description"], "")
        self.assertEqual(response_data["tags"], ["deprecated"])

    def test_retrieve_create_property_definition(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        property = PropertyDefinition.objects.create(team=self.team, name="property")
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        enterprise_property = EnterprisePropertyDefinition.objects.all().first()
        property.refresh_from_db()
        self.assertEqual(enterprise_property.propertydefinition_ptr_id, property.id)  # type: ignore
        self.assertEqual(enterprise_property.name, property.name)  # type: ignore
        self.assertEqual(enterprise_property.team.id, property.team.id)  # type: ignore

    def test_search_property_definition(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        tag = Tag.objects.create(name="deprecated", team_id=self.team.id)
        EventProperty.objects.create(team=self.team, event="$pageview", property="enterprise property")
        enterprise_property = EnterprisePropertyDefinition.objects.create(
            team=self.team, name="enterprise property", description=""
        )
        enterprise_property.tagged_items.create(tag_id=tag.id)
        other_property = EnterprisePropertyDefinition.objects.create(
            team=self.team, name="other property", description=""
        )
        other_property.tagged_items.create(tag_id=tag.id)
        set_property = EnterprisePropertyDefinition.objects.create(team=self.team, name="$set", description="")
        set_property.tagged_items.create(tag_id=tag.id)

        response = self.client.get(f"/api/projects/@current/property_definitions/?search=enter")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 1)

        self.assertEqual(response_data["results"][0]["name"], "enterprise property")
        self.assertEqual(response_data["results"][0]["description"], "")
        self.assertEqual(response_data["results"][0]["tags"], ["deprecated"])

        response = self.client.get(f"/api/projects/@current/property_definitions/?search=enterprise")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 1)
        # always True if not scoping by event names
        self.assertEqual(response_data["results"][0]["is_seen_on_filtered_events"], None)

        # add event_names=['$pageview'] to get properties that have been seen by this event
        response = self.client.get(
            f"/api/projects/@current/property_definitions/?search=property&event_names=%5B%22%24pageview%22%5D"
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 2)
        self.assertEqual(response_data["results"][0]["name"], "enterprise property")
        self.assertEqual(response_data["results"][0]["is_seen_on_filtered_events"], True)
        self.assertEqual(response_data["results"][1]["name"], "other property")
        self.assertEqual(response_data["results"][1]["is_seen_on_filtered_events"], False)

        response = self.client.get(
            f"/api/projects/@current/property_definitions/?search=property&event_names=%5B%22%24pageview%22%5D&filter_by_event_names=true"
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 1)

        response = self.client.get(f"/api/projects/@current/property_definitions/?search=er pr")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 2)

        response = self.client.get(f"/api/projects/@current/property_definitions/?search=bust")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 0)

        response = self.client.get(f"/api/projects/@current/property_definitions/?search=set")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(len(response_data["results"]), 0)

        response = self.client.get(f"/api/projects/@current/property_definitions/?search=")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        db_results = [r for r in response_data["results"] if not r.get("name", "").startswith("$virt_")]
        self.assertEqual(len(db_results), 2)

    @parameterized.expand(
        [
            ("verified_only", "true", ["verified_prop"]),
            ("unverified_only", "false", ["unverified_prop"]),
            ("all_when_not_specified", None, ["unverified_prop", "verified_prop"]),
        ]
    )
    def test_filter_property_definitions_by_verified(
        self, _name: str, verified_param: Optional[str], expected_names: list[str]
    ):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )

        EnterprisePropertyDefinition.objects.create(team=self.team, name="verified_prop", verified=True)
        EnterprisePropertyDefinition.objects.create(team=self.team, name="unverified_prop", verified=False)

        url = "/api/projects/@current/property_definitions/"
        if verified_param is not None:
            url += f"?verified={verified_param}"

        response = self.client.get(url)

        assert response.status_code == status.HTTP_200_OK
        assert sorted([r["name"] for r in exclude_virtual_properties(response.json()["results"])]) == expected_names

    def test_update_property_definition(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2038, 1, 19, 3, 14, 7)
        )
        property = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{str(property.id)}/",
            {"description": "This is a description.", "tags": ["official", "internal"]},
        )
        response_data = response.json()
        self.assertEqual(response_data["description"], "This is a description.")
        self.assertEqual(response_data["updated_by"]["first_name"], self.user.first_name)
        self.assertEqual(set(response_data["tags"]), {"official", "internal"})

        property.refresh_from_db()
        self.assertEqual(
            set(property.tagged_items.values_list("tag__name", flat=True)),
            {"official", "internal"},
        )

        activity_log: Optional[ActivityLog] = ActivityLog.objects.filter(scope="PropertyDefinition").first()
        assert activity_log is not None
        detail = cast(dict[str, Any], activity_log.detail)
        changes = cast(list[dict[str, Any]], detail["changes"])
        self.assertEqual(activity_log.scope, "PropertyDefinition")
        self.assertEqual(activity_log.activity, "changed")
        self.assertEqual(detail["name"], "enterprise property")
        self.assertEqual(detail["type"], "event")
        self.assertEqual(activity_log.user, self.user)
        assert sorted(changes, key=lambda x: x["field"]) == [
            {
                "action": "changed",
                "after": "This is a description.",
                "before": "",
                "field": "description",
                "type": "PropertyDefinition",
            },
            {
                "action": "changed",
                "after": ["official", "internal"],
                "before": [],
                "field": "tags",
                "type": "PropertyDefinition",
            },
        ]

    def test_update_property_definition_property_type(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2038, 1, 19, 3, 14, 7)
        )

        property = PropertyDefinition.objects.create(team=self.team, name="property")

        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{str(property.id)}/",
            {"property_type": "Numeric"},
        )

        response_data = response.json()
        self.assertEqual(response_data["property_type"], "Numeric")
        self.assertEqual(response_data["is_numerical"], True)
        self.assertEqual(response_data["updated_by"]["first_name"], self.user.first_name)

    def test_update_property_definition_non_numeric(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2038, 1, 19, 3, 14, 7)
        )

        property = PropertyDefinition.objects.create(
            team=self.team, name="property", property_type="Numeric", is_numerical=True
        )

        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{str(property.id)}/",
            {"property_type": "DateTime"},
        )

        response_data = response.json()
        self.assertEqual(response_data["property_type"], "DateTime")
        self.assertEqual(response_data["is_numerical"], False)
        self.assertEqual(response_data["updated_by"]["first_name"], self.user.first_name)

    def test_can_update_property_type_without_license(self):
        property = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{str(property.id)}/",
            data={"property_type": "DateTime"},
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(response_data["property_type"], "DateTime")

    def test_can_update_property_type_and_unchanged_keys_without_license(self):
        property = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{str(property.id)}/",
            data={
                "id": property.id,
                "name": "enterprise property",
                "is_numerical": False,
                "property_type": "DateTime",
                "is_seen_on_filtered_events": None,
                "tags": [],
            },
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertEqual(response_data["property_type"], "DateTime")

    def test_filter_property_definitions(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        EnterprisePropertyDefinition.objects.create(team=self.team, name="plan")
        EnterprisePropertyDefinition.objects.create(team=self.team, name="purchase")
        EnterprisePropertyDefinition.objects.create(team=self.team, name="app_rating")

        response = self.client.get("/api/projects/@current/property_definitions/?properties=plan,app_rating")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        self.assertEqual(response.json()["count"], 2)
        for item in response.json()["results"]:
            self.assertIn(item["name"], ["plan", "app_rating"])

    def test_event_property_definition_no_duplicate_tags(self):
        from ee.models.license import License, LicenseManager

        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            key="key_123",
            plan="enterprise",
            valid_until=datetime.datetime(2038, 1, 19, 3, 14, 7),
        )
        property = EnterprisePropertyDefinition.objects.create(team=self.team, name="description test")
        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{str(property.id)}/",
            data={"tags": ["a", "b", "a"]},
        )

        self.assertListEqual(sorted(response.json()["tags"]), ["a", "b"])

    @time_machine.travel("2021-08-25T22:09:14.252Z", tick=False)
    def test_can_get_property_verification_data(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        self.client.force_login(self.user)
        event = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is False
        assert response.json()["verified_by"] is None
        assert response.json()["verified_at"] is None
        assert response.json()["updated_at"] == "2021-08-25T22:09:14.252000Z"

        query_list_response = self.client.get(f"/api/projects/@current/property_definitions")
        matches = [p["name"] for p in query_list_response.json()["results"] if p["name"] == "enterprise property"]
        assert len(matches) == 1

    @time_machine.travel("2021-08-25T22:09:14.252Z", tick=False)
    def test_verify_then_unverify(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        self.client.force_login(self.user)
        event = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is False
        assert response.json()["verified_by"] is None
        assert response.json()["verified_at"] is None

        # Verify the event
        self.client.patch(
            f"/api/projects/@current/property_definitions/{event.id}",
            {"verified": True},
        )
        response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is True
        assert response.json()["verified_by"]["id"] == self.user.id
        assert response.json()["verified_at"] == "2021-08-25T22:09:14.252000Z"

        # Unverify the event
        self.client.patch(
            f"/api/projects/@current/property_definitions/{event.id}",
            {"verified": False},
        )
        response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is False
        assert response.json()["verified_by"] is None
        assert response.json()["verified_at"] is None

    @time_machine.travel("2021-08-25T22:09:14.252Z", tick=False)
    def test_hidden_property_behavior(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        self.client.force_login(self.user)
        property = EnterprisePropertyDefinition.objects.create(team=self.team, name="hidden test property")
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["hidden"] is False
        assert response.json()["verified"] is False

        # Hide the property
        self.client.patch(
            f"/api/projects/@current/property_definitions/{property.id}",
            {"hidden": True},
        )
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["hidden"] is True
        assert response.json()["verified"] is False  # Hiding should ensure verified is False

        # Try to verify and hide a property at the same time (should fail)
        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{property.id}",
            {"verified": True, "hidden": True},
        )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertIn("cannot be both hidden and verified", response.json()["detail"].lower())

        # Unhide the property
        self.client.patch(
            f"/api/projects/@current/property_definitions/{property.id}",
            {"hidden": False},
        )
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["hidden"] is False
        assert response.json()["verified"] is False

    @time_machine.travel("2021-08-25T22:09:14.252Z", tick=False)
    def test_marking_hidden_removes_verified_status(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        self.client.force_login(self.user)
        property = EnterprisePropertyDefinition.objects.create(
            team=self.team, name="verified test property", verified=True
        )
        response = self.client.get(f"/api/projects/@current/property_definitions/{property.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["hidden"] is False
        assert response.json()["verified"] is True

        response = self.client.patch(
            f"/api/projects/@current/property_definitions/{property.id}",
            {"hidden": True},
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        property.refresh_from_db()
        assert property.hidden is True
        assert property.verified is False

    @time_machine.travel("2021-08-25T22:09:14.252Z", tick=False)
    def test_verify_then_verify_again_no_change(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        event = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is False
        assert response.json()["verified_by"] is None
        assert response.json()["verified_at"] is None

        with time_machine.travel("2021-08-25T22:09:14.252Z", tick=False):
            self.client.patch(
                f"/api/projects/@current/property_definitions/{event.id}",
                {"verified": True},
            )
            response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
            self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is True
        assert response.json()["verified_by"]["id"] == self.user.id
        assert response.json()["verified_at"] == "2021-08-25T22:09:14.252000Z"
        assert response.json()["updated_at"] == "2021-08-25T22:09:14.252000Z"

        with time_machine.travel("2021-10-26T22:09:14.252Z", tick=False):
            self.client.patch(
                f"/api/projects/@current/property_definitions/{event.id}",
                {"verified": True},
            )
            response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
            self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is True
        assert response.json()["verified_by"]["id"] == self.user.id
        assert response.json()["verified_at"] == "2021-08-25T22:09:14.252000Z"  # Note `verified_at` did not change
        # updated_at automatically updates on every patch request
        assert response.json()["updated_at"] == "2021-10-26T22:09:14.252000Z"

    @time_machine.travel("2021-08-25T22:09:14.252Z", tick=False)
    def test_cannot_update_verified_meta_properties_directly(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        self.client.force_login(self.user)
        event = EnterprisePropertyDefinition.objects.create(team=self.team, name="enterprise property")
        response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is False
        assert response.json()["verified_by"] is None
        assert response.json()["verified_at"] is None

        with time_machine.travel("2021-08-25T22:09:14.252Z", tick=False):
            self.client.patch(
                f"/api/projects/@current/property_definitions/{event.id}",
                {
                    "verified_by": self.user.id,
                    "verified_at": timezone.now(),
                },  # These properties are ignored by the serializer
            )
            response = self.client.get(f"/api/projects/@current/property_definitions/{event.id}")
            self.assertEqual(response.status_code, status.HTTP_200_OK)

        assert response.json()["verified"] is False
        assert response.json()["verified_by"] is None
        assert response.json()["verified_at"] is None

    def test_list_filters_stay_unambiguous_when_both_tables_have_the_columns(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        EnterprisePropertyDefinition.objects.create(team=self.team, name="billing_plan_tier", verified=True)
        with connection.cursor() as cursor:
            # Run the deferred FK checks of the inserts above, or Postgres refuses the ALTER TABLE.
            cursor.execute("SET CONSTRAINTS ALL IMMEDIATE")
            cursor.execute(
                "ALTER TABLE posthog_propertydefinition ADD COLUMN IF NOT EXISTS description text,"
                " ADD COLUMN IF NOT EXISTS verified boolean, ADD COLUMN IF NOT EXISTS hidden boolean"
            )

        response = self.client.get(
            "/api/projects/@current/property_definitions/?verified=true&exclude_hidden=true&search=billing_plan_tier"
        )

        assert response.status_code == status.HTTP_200_OK
        assert [row["name"] for row in response.json()["results"]] == ["billing_plan_tier"]

    def test_list_property_definitions_verified_ordering(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )

        properties: list[dict] = [
            {"name": "1_when_verified", "verified": True},
            {"name": "2_when_verified", "verified": True},
            {"name": "3_when_verified", "verified": True},
            {"name": "4_when_verified", "verified": False},
            {"name": "5_when_verified", "verified": False},
            {"name": "6_when_verified", "verified": False},
        ]

        for property in properties:
            EnterprisePropertyDefinition.objects.create(team=self.team, name=property["name"])

        response = self.client.get("/api/projects/@current/property_definitions/")
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        db_results = exclude_virtual_properties(response.json()["results"])
        assert [(r["name"], r["verified"], r["is_seen_on_filtered_events"]) for r in db_results] == [
            ("1_when_verified", False, None),
            ("2_when_verified", False, None),
            ("3_when_verified", False, None),
            ("4_when_verified", False, None),
            ("5_when_verified", False, None),
            ("6_when_verified", False, None),
        ]

        for property in properties:
            definition = EnterprisePropertyDefinition.objects.filter(name=property["name"], team=self.team).first()
            if definition is None:
                raise AssertionError(f"Property definition {property['name']} not found")
            definition.verified = property["verified"] or False
            definition.save()

        response = self.client.get("/api/projects/@current/property_definitions/")

        db_results = exclude_virtual_properties(response.json()["results"])
        assert [(r["name"], r["verified"], r["is_seen_on_filtered_events"]) for r in db_results] == [
            ("1_when_verified", True, None),
            ("2_when_verified", True, None),
            ("3_when_verified", True, None),
            ("4_when_verified", False, None),
            ("5_when_verified", False, None),
            ("6_when_verified", False, None),
        ]

        # We should prefer properties that have been seen on an event if that is available
        EventProperty.objects.get_or_create(team=self.team, event="$pageview", property="3_when_verified")
        EventProperty.objects.get_or_create(team=self.team, event="$pageview", property="4_when_verified")

        response = self.client.get("/api/projects/@current/property_definitions/?event_names=%5B%22%24pageview%22%5D")

        db_results = exclude_virtual_properties(response.json()["results"])
        assert [(r["name"], r["verified"], r["is_seen_on_filtered_events"]) for r in db_results] == [
            ("3_when_verified", True, True),
            ("4_when_verified", False, True),
            ("1_when_verified", True, False),
            ("2_when_verified", True, False),
            ("5_when_verified", False, False),
            ("6_when_verified", False, False),
        ]

    def test_exclude_hidden_properties(self):
        super(LicenseManager, cast(LicenseManager, License.objects)).create(
            plan="enterprise", valid_until=datetime.datetime(2500, 1, 19, 3, 14, 7)
        )
        # Create some properties with hidden flag
        EnterprisePropertyDefinition.objects.create(team=self.team, name="visible_property", property_type="String")
        EnterprisePropertyDefinition.objects.create(
            team=self.team, name="hidden_property1", property_type="String", hidden=True
        )
        EnterprisePropertyDefinition.objects.create(
            team=self.team, name="hidden_property2", property_type="String", hidden=True
        )

        response = self.client.get(f"/api/projects/{self.team.pk}/property_definitions/?exclude_hidden=true")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        property_names = {p["name"] for p in response.json()["results"]}
        self.assertIn("visible_property", property_names)
        self.assertNotIn("hidden_property1", property_names)
        self.assertNotIn("hidden_property2", property_names)

        # Test with exclude_hidden=false (should be same as not setting it)
        response = self.client.get(f"/api/projects/{self.team.pk}/property_definitions/?exclude_hidden=false")
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        property_names = {p["name"] for p in response.json()["results"]}
        self.assertIn("visible_property", property_names)
        self.assertIn("hidden_property1", property_names)
        self.assertIn("hidden_property2", property_names)