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.

18.6 KB
Raw Blame
import datetime as dt

import time_machine
from unittest import mock
from unittest.mock import ANY, call, patch

from rest_framework import status

from posthog.constants import AvailableFeature
from posthog.models import Team, User
from posthog.models.organization import Organization, OrganizationMembership
from posthog.tasks.tasks import sync_all_organization_available_product_features

from products.access_control.backend.models.access_control import AccessControl

from ee.api.test.base import APILicensedTest
from ee.models.license import License


class TestOrganizationEnterpriseAPI(APILicensedTest):
    def test_create_organization(self):
        response = self.client.post("/api/organizations/", {"name": "Test"})
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(Organization.objects.count(), 2)
        response_data = response.json()
        self.assertEqual(response_data.get("name"), "Test")
        self.assertEqual(
            OrganizationMembership.objects.filter(organization_id=response_data.get("id")).count(),
            1,
        )
        self.assertEqual(
            OrganizationMembership.objects.get(organization_id=response_data.get("id"), user=self.user).level,
            OrganizationMembership.Level.OWNER,
        )

    @patch("posthog.models.utils.generate_random_short_suffix", return_value="YYYY")
    def test_create_two_similarly_named_organizations(self, mock_choice):
        response = self.client.post(
            "/api/organizations/",
            {"name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},
        )
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertLessEqual(
            {
                "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                "slug": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
            }.items(),
            response.json().items(),
        )

        response = self.client.post(
            "/api/organizations/",
            {"name": "#XXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxX"},
        )
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertLessEqual(
            {
                "name": "#XXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxX",
                "slug": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-yyyy",
            }.items(),
            response.json().items(),
        )

    @patch("posthog.temporal.delete_teams.dispatch.start_delete_organization_workflow")
    @patch("posthoganalytics.capture")
    def test_delete_second_managed_organization(self, mock_capture, mock_delete_task):
        organization, _, team = Organization.objects.bootstrap(self.user, name="X")
        organization_props = organization.get_analytics_metadata()
        self.assertTrue(Organization.objects.filter(id=organization.id).exists())
        self.assertTrue(Team.objects.filter(id=team.id).exists())
        response = self.client.delete(f"/api/organizations/{organization.id}")
        self.assertEqual(response.status_code, 204)
        # Organization and team records are now deleted asynchronously by the task
        # so we can't assert they're gone immediately - verify task was called instead

        mock_capture.assert_any_call(
            event="organization deleted",
            distinct_id=self.user.distinct_id,
            properties=organization_props,
            groups={"instance": ANY, "organization": str(organization.id)},
        )
        mock_capture.assert_any_call(
            event="organization deletion initiated",
            distinct_id=self.user.distinct_id,
            properties=organization_props,
            groups={"instance": ANY, "organization": str(organization.id)},
        )
        mock_delete_task.assert_called_once_with(
            team_ids=[team.id],
            organization_id=str(organization.id),
            user_id=self.user.id,
            organization_name="X",
            project_names=[team.name],
        )

    @patch("posthog.temporal.delete_teams.dispatch.start_delete_organization_workflow")
    @patch("posthoganalytics.capture")
    def test_delete_last_organization(self, mock_capture, mock_delete_task):
        org_id = self.organization.id
        organization_props = self.organization.get_analytics_metadata()
        self.assertTrue(Organization.objects.filter(id=org_id).exists())

        self.organization_membership.level = OrganizationMembership.Level.OWNER
        self.organization_membership.save()

        response = self.client.delete(f"/api/organizations/{org_id}")

        self.assertEqual(
            response.status_code,
            204,
            "Did not successfully delete last organization on the instance",
        )
        # Org stays but is marked as pending deletion
        self.assertTrue(Organization.objects.filter(id=org_id).exists())
        org = Organization.objects.get(id=org_id)
        self.assertTrue(org.is_pending_deletion)

        # Trying to delete again returns 400
        response_bis = self.client.delete(f"/api/organizations/{org_id}")
        self.assertEqual(response_bis.status_code, 400)

        mock_capture.assert_has_calls(
            [
                call(
                    distinct_id=self.user.distinct_id,
                    event="membership level changed",
                    properties={"new_level": 15, "previous_level": 1, "$set": mock.ANY},
                    groups=mock.ANY,
                ),
                call(
                    distinct_id=self.user.distinct_id,
                    event="organization deleted",
                    properties=organization_props,
                    groups={"instance": mock.ANY, "organization": str(org_id)},
                ),
            ]
        )

    def test_no_delete_organization_not_owning(self):
        for level in (
            OrganizationMembership.Level.MEMBER,
            OrganizationMembership.Level.ADMIN,
        ):
            self.organization_membership.level = level
            self.organization_membership.save()
            response = self.client.delete(f"/api/organizations/{self.organization.id}")
            potential_err_message = f"Somehow managed to delete the org as a level {level} (which is not owner)"
            self.assertEqual(
                response.json(),
                {
                    "attr": None,
                    "detail": "You do not have admin access to this resource."
                    if level == OrganizationMembership.Level.MEMBER
                    else "Your organization access level is insufficient.",
                    "code": "permission_denied",
                    "type": "authentication_error",
                },
                potential_err_message,
            )
            self.assertEqual(response.status_code, 403, potential_err_message)
            self.assertTrue(self.organization.name, self.CONFIG_ORGANIZATION_NAME)

    @patch("posthog.temporal.delete_teams.dispatch.start_delete_organization_workflow")
    def test_delete_organization_owning(self, mock_delete_task):
        self.organization_membership.level = OrganizationMembership.Level.OWNER
        self.organization_membership.save()

        response = self.client.delete(f"/api/organizations/{self.organization.id}")

        potential_err_message = "Somehow did not delete the org as the owner"
        self.assertEqual(response.status_code, 204, potential_err_message)
        # Org is now marked as pending deletion, not immediately deleted
        self.organization.refresh_from_db()
        self.assertTrue(self.organization.is_pending_deletion)
        # Memberships are preserved so users can still switch orgs
        self.assertTrue(OrganizationMembership.objects.filter(organization=self.organization).exists())
        self.assertTrue(User.objects.filter(id=self.user.pk).exists())

    def test_no_delete_organization_not_belonging_to(self):
        for level in OrganizationMembership.Level:
            self.organization_membership.level = level
            self.organization_membership.save()
            organization = Organization.objects.create(name="Some Other Org")
            response = self.client.delete(f"/api/organizations/{organization.id}")
            potential_err_message = f"Somehow managed to delete someone else's org as a level {level} in own org"
            self.assertEqual(
                response.json(),
                {
                    "attr": None,
                    "detail": "Not found.",
                    "code": "not_found",
                    "type": "invalid_request",
                },
                potential_err_message,
            )
            self.assertEqual(response.status_code, 404, potential_err_message)
            self.assertTrue(
                Organization.objects.filter(id=organization.id).exists(),
                potential_err_message,
            )

    def test_update_org(self):
        for level in OrganizationMembership.Level:
            self.organization_membership.level = level
            self.organization_membership.save()
            response_rename = self.client.patch(f"/api/organizations/{self.organization.id}", {"name": "Woof"})
            response_email = self.client.patch(
                f"/api/organizations/{self.organization.id}",
                {"is_member_join_email_enabled": False},
            )
            self.organization.refresh_from_db()

            expected_response = {
                "attr": None,
                "detail": "Your organization access level is insufficient.",
                "code": "permission_denied",
                "type": "authentication_error",
            }
            if level < OrganizationMembership.Level.ADMIN:
                potential_err_message = f"Somehow managed to update the org as a level {level} (which is below admin)"
                self.assertEqual(response_rename.json(), expected_response, potential_err_message)
                self.assertEqual(response_rename.status_code, 403, potential_err_message)
                self.assertTrue(self.organization.name, self.CONFIG_ORGANIZATION_NAME)
                self.assertEqual(response_email.json(), expected_response, potential_err_message)
                self.assertEqual(response_email.status_code, 403, potential_err_message)
            else:
                potential_err_message = f"Somehow did not update the org as a level {level} (which is at least admin)"
                self.assertEqual(response_rename.status_code, 200, potential_err_message)
                self.assertEqual(response_email.status_code, 200, potential_err_message)
                self.assertTrue(self.organization.name, "Woof")

    def test_no_update_organization_not_belonging_to(self):
        for level in OrganizationMembership.Level:
            self.organization_membership.level = level
            self.organization_membership.save()
            organization = Organization.objects.create(name="Meow")
            response = self.client.patch(f"/api/organizations/{organization.id}", {"name": "Mooooooooo"})
            potential_err_message = f"Somehow managed to update someone else's org as a level {level} in own org"
            self.assertEqual(
                response.json(),
                {
                    "attr": None,
                    "detail": "Not found.",
                    "code": "not_found",
                    "type": "invalid_request",
                },
                potential_err_message,
            )
            self.assertEqual(response.status_code, 404, potential_err_message)
            organization.refresh_from_db()
            self.assertTrue(organization.name, "Meow")

    def test_feature_available_self_hosted_has_license(self):
        current_plans = License.PLANS
        License.PLANS = {"enterprise": ["whatever"]}  # type: ignore
        with self.is_cloud(False):
            License.objects.create(
                key="key",
                plan="enterprise",
                valid_until=dt.datetime.now() + dt.timedelta(days=1),
            )

            # Still only old, empty available_product_features field value known
            self.assertIsNone(self.organization.get_available_feature("whatever"))
            self.assertFalse(self.organization.is_feature_available("whatever"))
            self.assertIsNone(self.organization.get_available_feature("feature-doesnt-exist"))
            self.assertFalse(self.organization.is_feature_available("feature-doesnt-exist"))

            # New available_product_features field value that was updated in DB on license creation is known after refresh
            self.organization.refresh_from_db()
            self.assertEqual(
                {"key": "whatever", "name": "Whatever"}, self.organization.get_available_feature("whatever")
            )
            self.assertTrue(self.organization.is_feature_available("whatever"))
            self.assertFalse(self.organization.get_available_feature("feature-doesnt-exist"))
            self.assertFalse(self.organization.is_feature_available("feature-doesnt-exist"))
        License.PLANS = current_plans

    def test_feature_available_self_hosted_no_license(self):
        current_plans = License.PLANS
        License.PLANS = {"enterprise": ["whatever"]}  # type: ignore

        self.assertIsNone(self.organization.get_available_feature("whatever"))
        self.assertFalse(self.organization.is_feature_available("whatever"))
        self.assertIsNone(self.organization.get_available_feature("feature-doesnt-exist"))
        self.assertFalse(self.organization.is_feature_available("feature-doesnt-exist"))
        License.PLANS = current_plans

    def test_feature_available_self_hosted_license_expired(self):
        current_plans = License.PLANS
        License.PLANS = {"enterprise": ["whatever"]}  # type: ignore

        with time_machine.travel(
            "2070-01-01T12:00:00.000Z", tick=False
        ):  # LicensedTestMixin enterprise license expires in 2038
            sync_all_organization_available_product_features()  # This is normally ran every hour
            self.organization.refresh_from_db()
            self.assertIsNone(self.organization.get_available_feature("whatever"))
            self.assertFalse(self.organization.is_feature_available("whatever"))
        License.PLANS = current_plans

    def test_get_organization_restricted_teams_hidden(self):
        self.organization_membership.level = OrganizationMembership.Level.MEMBER
        self.organization_membership.save()
        forbidden_team = Team.objects.create(
            organization=self.organization,
            name="FORBIDDEN",
        )

        # Set up new access control system - restrict project to no default access
        AccessControl.objects.create(
            team=forbidden_team,
            access_level="none",
            resource="project",
            resource_id=str(forbidden_team.id),
        )

        response = self.client.get(f"/api/organizations/{self.organization.id}")

        self.assertEqual(response.status_code, 200)
        self.assertListEqual(
            [team["name"] for team in response.json()["teams"]],
            [self.team.name],  # "FORBIDDEN" excluded
        )

    def test_member_cannot_update_members_can_invite_on_org(self):
        """Test that members cannot update members_can_invite when ORGANIZATION_INVITE_SETTINGS is available."""
        self.organization_membership.level = OrganizationMembership.Level.MEMBER
        self.organization_membership.save()

        # Enable ORGANIZATION_INVITE_SETTINGS feature
        self.organization.available_product_features = [{"key": AvailableFeature.ORGANIZATION_INVITE_SETTINGS}]
        self.organization.save()

        response = self.client.patch(f"/api/organizations/{self.organization.id}", {"members_can_invite": True})
        self.assertEqual(response.status_code, 403)

    def test_organization_api_includes_default_role_id(self):
        """Test that the organization API includes the default_role_id field"""
        from products.access_control.backend.models.role import Role

        # Create a role and set it as default
        role = Role.objects.create(name="Default Role", organization=self.organization)
        self.organization.default_role_id = role.id
        self.organization.save()

        response = self.client.get(f"/api/organizations/{self.organization.id}/")

        self.assertEqual(response.status_code, 200)
        data = response.json()
        self.assertIn("default_role_id", data)
        self.assertEqual(data["default_role_id"], str(role.id))

    def test_set_default_role_via_api(self):
        """Test that the default role can be set via the organization API"""
        from products.access_control.backend.models.role import Role

        self.organization_membership.level = OrganizationMembership.Level.ADMIN
        self.organization_membership.save()

        # Create a role
        role = Role.objects.create(name="API Default Role", organization=self.organization)

        response = self.client.patch(f"/api/organizations/{self.organization.id}/", {"default_role_id": str(role.id)})

        self.assertEqual(response.status_code, 200)

        # Check that it was set
        self.organization.refresh_from_db()
        self.assertEqual(self.organization.default_role_id, role.id)

    def test_clear_default_role_via_api(self):
        """Test that the default role can be cleared via the organization API"""
        from products.access_control.backend.models.role import Role

        self.organization_membership.level = OrganizationMembership.Level.ADMIN
        self.organization_membership.save()

        # Create a role and set it as default
        role = Role.objects.create(name="To Be Cleared", organization=self.organization)
        self.organization.default_role_id = role.id
        self.organization.save()

        response = self.client.patch(f"/api/organizations/{self.organization.id}/", {"default_role_id": None})

        self.assertEqual(response.status_code, 200)

        # Check that it was cleared
        self.organization.refresh_from_db()
        self.assertIsNone(self.organization.default_role_id)

    def test_role_serializer_includes_is_default_field(self):
        """Test that the role serializer includes is_default field"""
        from products.access_control.backend.models.role import Role

        # Create a role and set it as default
        role = Role.objects.create(name="Default Role", organization=self.organization)
        self.organization.default_role_id = role.id
        self.organization.save()

        response = self.client.get(f"/api/organizations/{self.organization.id}/roles/")

        self.assertEqual(response.status_code, 200)
        data = response.json()

        # Find our role in the results
        default_role = next(r for r in data["results"] if r["id"] == str(role.id))
        self.assertTrue(default_role["is_default"])