test_unit_features_views.py

import json
import typing
import uuid
from datetime import date, datetime, timedelta
from unittest import mock

import pytest
import pytz
from common.environments.permissions import (
    MANAGE_SEGMENT_OVERRIDES,
    UPDATE_FEATURE_STATE,
    VIEW_ENVIRONMENT,
)
from common.projects.permissions import (
    CREATE_FEATURE,
    VIEW_PROJECT,
)
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.forms import model_to_dict
from django.urls import reverse
from django.utils import timezone
from freezegun import freeze_time
from pytest_django import DjangoAssertNumQueries
from pytest_django.fixtures import SettingsWrapper
from pytest_lazyfixture import lazy_fixture  # type: ignore[import-untyped]
from pytest_mock import MockerFixture
from rest_framework import status
from rest_framework.test import APIClient

from app_analytics.dataclasses import FeatureEvaluationData
from audit.constants import (
    FEATURE_DELETED_MESSAGE,
    IDENTITY_FEATURE_STATE_DELETED_MESSAGE,
    IDENTITY_FEATURE_STATE_UPDATED_MESSAGE,
)
from audit.models import AuditLog, RelatedObjectType  # type: ignore[attr-defined]
from core.constants import FLAGSMITH_UPDATED_AT_HEADER, SDK_ENVIRONMENT_KEY_HEADER
from environments.dynamodb import (
    DynamoEnvironmentV2Wrapper,
    DynamoIdentityWrapper,
)
from environments.identities.models import Identity
from environments.models import Environment, EnvironmentAPIKey
from environments.permissions.models import UserEnvironmentPermission
from features import views
from features.dataclasses import EnvironmentFeatureOverridesData
from features.feature_types import MULTIVARIATE, STANDARD
from features.models import Feature, FeatureSegment, FeatureState
from features.multivariate.models import MultivariateFeatureOption
from features.value_types import STRING
from features.versioning.models import EnvironmentFeatureVersion
from metadata.models import (
    MetadataField,
    MetadataModelField,
    MetadataModelFieldRequirement,
)
from organisations.models import Organisation, OrganisationRole
from permissions.models import PermissionModel
from projects.code_references.models import FeatureFlagCodeReferencesScan
from projects.models import Project, UserProjectPermission
from projects.tags.models import Tag
from segments.models import Segment
from tests.types import (
    EnableFeaturesFixture,
    WithEnvironmentPermissionsCallable,
    WithProjectPermissionsCallable,
)
from users.models import FFAdminUser, UserPermissionGroup
from util.mappers import (
    map_engine_feature_state_to_identity_override,
    map_engine_identity_to_identity_document,
    map_identity_override_to_identity_override_document,
    map_identity_to_engine,
)
from webhooks.webhooks import WebhookEventType

if typing.TYPE_CHECKING:
    from mypy_boto3_dynamodb.service_resource import Table


now = timezone.now()
two_hours_ago = now - timedelta(hours=2)
one_hour_ago = now - timedelta(hours=1)


def test_create_feature__with_owners_field__owners_is_read_only(
    project: Project,
    admin_client_original: APIClient,
    admin_user: FFAdminUser,
) -> None:
    # Given
    default_value = "This is a value"
    data = {
        "name": "test feature",
        "initial_value": default_value,
        "project": project.id,
        "owners": [
            {
                "id": 2,
                "email": "fake_user@mail.com",
                "first_name": "fake",
                "last_name": "user",
            }
        ],
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_original.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert len(response.json()["owners"]) == 1
    assert response.json()["owners"][0]["id"] == admin_user.id
    assert response.json()["owners"][0]["email"] == admin_user.email


@mock.patch("features.views.trigger_feature_state_change_webhooks")
def test_delete_feature__with_feature_states__triggers_webhooks(
    mocked_trigger_fs_change_webhook: mock.MagicMock,
    project: Project,
    feature: Feature,
    admin_client_new: APIClient,
) -> None:
    # Given
    feature_states = list(feature.feature_states.all())
    url = reverse(
        "api-v1:projects:project-features-detail", args=[project.id, feature.id]
    )

    # When
    admin_client_new.delete(url)

    # Then
    mock_calls = [mock.call(fs, WebhookEventType.FLAG_DELETED) for fs in feature_states]
    mocked_trigger_fs_change_webhook.assert_has_calls(mock_calls)


def test_remove_owners__specified_owner__removes_only_specified(
    feature: Feature,
    project: Project,
    admin_client_new: APIClient,
) -> None:
    # Given
    user_2 = FFAdminUser.objects.create_user(email="user2@mail.com")  # type: ignore[no-untyped-call]
    user_3 = FFAdminUser.objects.create_user(email="user3@mail.com")  # type: ignore[no-untyped-call]
    feature.owners.add(user_2, user_3)

    url = reverse(
        "api-v1:projects:project-features-remove-owners",
        args=[project.id, feature.id],
    )
    data = {"user_ids": [user_2.id]}

    # When
    json_response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    ).json()

    # Then
    assert len(json_response["owners"]) == 1
    assert json_response["owners"][0] == {
        "id": user_3.id,
        "email": user_3.email,
        "first_name": user_3.first_name,
        "last_name": user_3.last_name,
        "last_login": None,
        "uuid": mock.ANY,
    }


def test_create_identity_feature_state__valid_data__creates_audit_log(
    feature: Feature,
    project: Project,
    identity: Identity,
    environment: Environment,
    admin_client_new: APIClient,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:identity-featurestates-list",
        args=[environment.api_key, identity.id],
    )
    data = {"feature": feature.id, "enabled": True}

    # When
    admin_client_new.post(url, data=json.dumps(data), content_type="application/json")

    # Then
    assert (
        AuditLog.objects.filter(
            related_object_type=RelatedObjectType.FEATURE_STATE.name
        ).count()
        == 1
    )

    expected_log_message = IDENTITY_FEATURE_STATE_UPDATED_MESSAGE % (
        feature.name,
        identity.identifier,
    )
    audit_log = AuditLog.objects.get(
        related_object_type=RelatedObjectType.FEATURE_STATE.name
    )
    assert audit_log.log == expected_log_message


def test_update_identity_feature_state__valid_data__creates_audit_log(
    feature: Feature,
    project: Project,
    environment: Environment,
    identity: Identity,
    admin_client_new: APIClient,
) -> None:
    # Given
    feature_state = FeatureState.objects.create(
        feature=feature,
        environment=environment,
        identity=identity,
        enabled=True,
    )
    url = reverse(
        "api-v1:environments:identity-featurestates-detail",
        args=[environment.api_key, identity.id, feature_state.id],
    )
    data = {"feature": feature.id, "enabled": False}

    # When
    admin_client_new.put(url, data=json.dumps(data), content_type="application/json")

    # Then
    assert (
        AuditLog.objects.filter(
            related_object_type=RelatedObjectType.FEATURE_STATE.name
        ).count()
        == 1
    )

    expected_log_message = IDENTITY_FEATURE_STATE_UPDATED_MESSAGE % (
        feature.name,
        identity.identifier,
    )
    audit_log = AuditLog.objects.get(
        related_object_type=RelatedObjectType.FEATURE_STATE.name
    )
    assert audit_log.log == expected_log_message


def test_delete_identity_feature_state__existing_state__creates_audit_log(
    feature: Feature,
    project: Project,
    environment: Environment,
    identity: Identity,
    admin_client_new: APIClient,
) -> None:
    # Given
    feature_state = FeatureState.objects.create(
        feature=feature,
        environment=environment,
        identity=identity,
        enabled=True,
    )
    url = reverse(
        "api-v1:environments:identity-featurestates-detail",
        args=[environment.api_key, identity.id, feature_state.id],
    )

    # When
    admin_client_new.delete(url)

    # Then
    assert (
        AuditLog.objects.filter(
            log=IDENTITY_FEATURE_STATE_DELETED_MESSAGE
            % (
                feature.name,
                identity.identifier,
            )
        ).count()
        == 1
    )


def test_create_feature__tags_from_different_project__returns_400(
    project: Project,
    admin_client_new: APIClient,
    organisation: Organisation,
) -> None:
    # Given
    project2 = Project.objects.create(name="Test project2", organisation=organisation)
    tag_other_project = Tag.objects.create(
        label="Wrong Tag",
        color="#fffff",
        description="Test Tag description",
        project=project2,
    )
    feature_name = "test feature"
    data = {
        "name": feature_name,
        "project": project.id,
        "initial_value": "test",
        "tags": [tag_other_project.id],
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.post(
        url,
        data=json.dumps(data),
        content_type="application/json",
    )

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST

    # Check that no features were created successfully.
    assert Feature.objects.filter(name=feature_name, project=project.id).count() == 0


def test_update_feature__with_tags__returns_200(
    project: Project,
    feature: Feature,
    tag_one: Tag,
    admin_client_new: APIClient,
) -> None:
    # Given
    data = {
        "name": feature.name,
        "project": project.id,
        "tags": [tag_one.id],
    }

    url = reverse(
        "api-v1:projects:project-features-detail", args=[project.id, feature.id]
    )

    # When
    response = admin_client_new.put(
        url,
        data=json.dumps(data),
        content_type="application/json",
    )

    # Then
    assert response.status_code == status.HTTP_200_OK

    # check feature was created successfully
    check_feature = Feature.objects.filter(
        name=feature.name, project=project.id
    ).first()

    # check tags added
    assert check_feature.tags.count() == 1


def test_update_feature__tags_from_different_project__returns_400(
    feature: Feature,
    project: Project,
    admin_client_new: APIClient,
    organisation: Organisation,
) -> None:
    # Given
    project2 = Project.objects.create(name="Test project2", organisation=organisation)
    tag_other_project = Tag.objects.create(
        label="Wrong Tag",
        color="#fffff",
        description="Test Tag description",
        project=project2,
    )

    data = {
        "name": feature.name,
        "project": project.id,
        "tags": [tag_other_project.id],
    }
    url = reverse(
        "api-v1:projects:project-features-detail", args=[project.id, feature.id]
    )

    # When
    response = admin_client_new.put(
        url,
        data=json.dumps(data),
        content_type="application/json",
    )

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST

    # check feature was created successfully
    check_feature = Feature.objects.filter(
        name=feature.name, project=project.id
    ).first()

    # check tags not added
    assert check_feature.tags.count() == 0


def test_list_features__is_archived_filter__returns_filtered_results(
    feature: Feature,
    project: Project,
    admin_client_new: APIClient,
    organisation: Organisation,
) -> None:
    # Given
    archived_feature = Feature.objects.create(
        name="archived_feature", project=project, is_archived=True
    )
    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # First test the filter set to true.
    url = f"{base_url}?is_archived=true"

    # When
    response = admin_client_new.get(url)

    # Then
    assert len(response.json()["results"]) == 1
    assert response.json()["results"][0]["id"] == archived_feature.id

    # Finally test the filter set to false.
    url = f"{base_url}?is_archived=false"
    response = admin_client_new.get(url)
    assert len(response.json()["results"]) == 1
    assert response.json()["results"][0]["id"] == feature.id


def test_update_feature__default_enabled_changed__does_not_update_feature_states(
    feature: Feature,
    project: Project,
    admin_client_new: APIClient,
    organisation: Organisation,
) -> None:
    # Given
    feature.default_enabled = False
    feature.save()

    url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, feature.id],
    )
    data = model_to_dict(feature)
    data["default_enabled"] = True

    # When
    response = admin_client_new.put(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert all(fs.enabled is False for fs in feature.feature_states.all())


@pytest.mark.freeze_time("2023-01-19T09:09:47.325132+00:00")
@mock.patch("features.views.get_multiple_event_list_for_feature")
def test_get_influx_data__default_period__calls_with_one_day(
    mock_get_event_list: mock.MagicMock,
    feature: Feature,
    project: Project,
    environment: Environment,
    admin_client_new: APIClient,
) -> None:
    # Given
    base_url = reverse(
        "api-v1:projects:project-features-get-influx-data",
        args=[project.id, feature.id],
    )
    url = f"{base_url}?environment_id={environment.id}"

    mock_get_event_list.return_value = [
        {
            feature.name: 1,
            "datetime": datetime(2021, 2, 26, 12, 0, 0, tzinfo=pytz.UTC),
        }
    ]
    one_day_ago = timezone.now() - timedelta(days=1)

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    mock_get_event_list.assert_called_once_with(
        feature_name=feature.name,
        environment_id=str(environment.id),  # provided as a GET param
        date_start=one_day_ago,  # this is the default but can be provided as a GET param
        aggregate_every="24h",  # this is the default but can be provided as a GET param
    )


@pytest.mark.freeze_time("2023-01-19T09:09:47.325132+00:00")
@mock.patch("features.views.get_multiple_event_list_for_feature")
def test_get_influx_data__two_week_period__calls_with_fourteen_days(
    mock_get_event_list: mock.MagicMock,
    feature: Feature,
    project: Project,
    environment: Environment,
    admin_client_new: APIClient,
) -> None:
    # Given
    base_url = reverse(
        "api-v1:projects:project-features-get-influx-data",
        args=[project.id, feature.id],
    )
    url = f"{base_url}?environment_id={environment.id}&period=14d"
    date_start = timezone.now() - timedelta(days=14)

    mock_get_event_list.return_value = [
        {
            feature.name: 1,
            "datetime": datetime(2021, 2, 26, 12, 0, 0, tzinfo=pytz.UTC),
        }
    ]

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    mock_get_event_list.assert_called_once_with(
        feature_name=feature.name,
        environment_id=str(environment.id),
        date_start=date_start,
        aggregate_every="24h",
    )


@pytest.mark.freeze_time("2023-01-19T09:09:47.325132+00:00")
def test_get_influx_data__malformed_period__returns_400(
    feature: Feature,
    project: Project,
    environment: Environment,
    admin_client_new: APIClient,
) -> None:
    # Given
    base_url = reverse(
        "api-v1:projects:project-features-get-influx-data",
        args=[project.id, feature.id],
    )
    url = f"{base_url}?environment_id={environment.id}&period=baddata"

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert response.data[0] == "Malformed period supplied"


def test_create_feature__regular_user_with_mv_options__returns_403(
    staff_client: APIClient,
    with_project_permissions: WithProjectPermissionsCallable,
    project: Project,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT, CREATE_FEATURE])  # type: ignore[call-arg]
    data = {
        "name": "test_feature",
        "default_enabled": True,
        "multivariate_options": [{"type": "unicode", "string_value": "test-value"}],
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = staff_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_403_FORBIDDEN
    detail = "User must be project admin to modify / create MV options."
    assert response.json()["detail"] == detail


def test_update_feature__regular_user_with_mv_options__returns_403(
    staff_client: APIClient,
    with_project_permissions: WithProjectPermissionsCallable,
    project: Project,
    feature: Feature,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT, CREATE_FEATURE])  # type: ignore[call-arg]

    feature.default_enabled = True
    feature.save()

    data = {
        "name": feature.name,
        "default_enabled": feature.default_enabled,
        "multivariate_options": [{"type": "unicode", "string_value": "test-value"}],
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = staff_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_403_FORBIDDEN
    detail = "User must be project admin to modify / create MV options."
    assert response.json()["detail"] == detail


def test_update_feature__regular_user_with_description__returns_200(
    staff_client: APIClient,
    with_project_permissions: WithProjectPermissionsCallable,
    project: Project,
    feature: Feature,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT, CREATE_FEATURE])  # type: ignore[call-arg]
    feature.default_enabled = True
    feature.save()
    new_description = "a new description"
    data = {
        "name": feature.name,
        "default_enabled": feature.default_enabled,
        "description": new_description,
    }

    url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, feature.id],
    )

    # When
    response = staff_client.put(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK

    feature.refresh_from_db()
    assert feature.description == new_description


@mock.patch("environments.models.environment_wrapper")
def test_create_feature__dynamo_enabled__triggers_single_dynamo_write(
    mock_dynamo_environment_wrapper: mock.MagicMock,
    project: Project,
    admin_client_new: APIClient,
    environment: Environment,
) -> None:
    # Given
    project.enable_dynamo_db = True
    project.save()

    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {"name": "Test feature flag", "type": STANDARD, "project": project.id}

    mock_dynamo_environment_wrapper.is_enabled = True
    mock_dynamo_environment_wrapper.reset_mock()

    # When
    admin_client_new.post(url, data=data)

    # Then
    mock_dynamo_environment_wrapper.write_environments.assert_called_once()


def test_get_flags__environment_with_overrides__returns_environment_default(
    api_client: APIClient,
    environment: Environment,
    project: Project,
    identity: Identity,
) -> None:
    # Given
    url = reverse("api-v1:flags")
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    environment_fs_value = "environment"
    feature = Feature.objects.create(
        name="Test feature",
        project=project,
        initial_value=environment_fs_value,
    )

    segment = Segment.objects.create(name="Test segment", project=project)
    feature_segment = FeatureSegment.objects.create(
        segment=segment,
        feature=feature,
        environment=environment,
    )

    FeatureState.objects.create(
        feature=feature,
        feature_segment=feature_segment,
        environment=environment,
    )
    FeatureState.objects.create(
        identity=identity, environment=environment, feature=feature
    )

    # When
    response = api_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    # We only get a single flag back and that is the environment default
    response_json = response.json()
    assert len(response_json) == 1
    assert response_json[0]["feature"]["id"] == feature.id
    assert response_json[0]["feature_state_value"] == environment_fs_value

    # Check that headers set the refreshed last_updated_at.
    environment.refresh_from_db()
    assert response.headers[FLAGSMITH_UPDATED_AT_HEADER] == str(
        environment.updated_at.timestamp()
    )


@pytest.mark.parametrize("cache_flags_seconds", [0, 30])
def test_sdk_feature_states_get__no_identifier__returns_feature_list(
    api_client: APIClient,
    cache_flags_seconds: int,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
    mocker: MockerFixture,
    settings: SettingsWrapper,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    settings.CACHE_FLAGS_SECONDS = cache_flags_seconds

    # When
    response = api_client.get("/api/v1/flags/")

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json() == [
        {
            "id": feature_state.id,
            "enabled": feature_state.enabled,
            "environment": environment.id,
            "feature": mocker.ANY,
            "feature_segment": None,
            "feature_state_value": None,
            "identity": None,
        },
    ]
    assert response.json()[0]["feature"]["name"] == feature.name


# NOTE: DEPRECATED
@pytest.mark.parametrize(
    ["use_replica", "is_new_identity", "num_queries"],
    [
        pytest.param(False, True, 9, id="default_database,new_identity"),
        pytest.param(False, False, 8, id="default_database,existing_identity"),
        pytest.param(True, True, 9, id="replica_database,new_identity"),
        pytest.param(True, False, 7, id="replica_database,existing_identity"),
    ],
)
def test_SDKFeatureStates_get__given_identifier__responds_200_with_feature_list(
    api_client: APIClient,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
    feature: Feature,
    identity: Identity,
    is_new_identity: bool,
    mocker: MockerFixture,
    num_queries: int,
    use_replica: bool,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    mocker.patch.object(views, "is_database_replica_setup", return_value=use_replica)
    identifier = "morpheus" if is_new_identity else identity.identifier
    feature_state = FeatureState.objects.create(
        feature=feature,
        environment=environment,
        identity=identity,
        enabled=True,
    )

    # When
    with django_assert_num_queries(num_queries):
        response = api_client.get(f"/api/v1/flags/{identifier}")

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json() == [
        {
            "id": mocker.ANY if is_new_identity else feature_state.id,
            "enabled": not is_new_identity,
            "environment": environment.id,
            "feature": mocker.ANY,
            "feature_segment": None,
            "feature_state_value": None,
            "identity": None if is_new_identity else identity.id,
        },
    ]
    assert response.json()[0]["feature"]["name"] == feature.name
    assert Identity.objects.filter(identifier=identifier).exists()


# NOTE: DEPRECATED
@pytest.mark.parametrize(
    ["use_replica", "is_new_identity", "num_queries"],
    [
        pytest.param(False, True, 9, id="default_database,new_identity"),
        pytest.param(False, False, 8, id="default_database,existing_identity"),
        pytest.param(True, True, 9, id="replica_database,new_identity"),
        pytest.param(True, False, 7, id="replica_database,existing_identity"),
    ],
)
def test_sdk_feature_states_get__identifier_and_existing_feature__returns_feature(
    api_client: APIClient,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
    feature: Feature,
    identity: Identity,
    is_new_identity: bool,
    mocker: MockerFixture,
    num_queries: int,
    use_replica: bool,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    mocker.patch.object(views, "is_database_replica_setup", return_value=use_replica)
    identifier = "morpheus" if is_new_identity else identity.identifier
    feature_state = FeatureState.objects.create(
        feature=feature,
        environment=environment,
        identity=identity,
        enabled=True,
    )

    # When
    with django_assert_num_queries(num_queries):
        response = api_client.get(f"/api/v1/flags/{identifier}?feature={feature.name}")

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json() == {
        "id": mocker.ANY if is_new_identity else feature_state.id,
        "enabled": not is_new_identity,
        "environment": environment.id,
        "feature": mocker.ANY,
        "feature_segment": None,
        "feature_state_value": None,
        "identity": None if is_new_identity else identity.id,
    }
    assert response.json()["feature"]["name"] == feature.name
    assert Identity.objects.filter(identifier=identifier).exists()


# NOTE: DEPRECATED
@pytest.mark.parametrize(
    ["use_replica", "is_new_identity", "num_queries"],
    [
        pytest.param(False, True, 8, id="default_database,new_identity"),
        pytest.param(False, False, 7, id="default_database,existing_identity"),
        pytest.param(True, True, 8, id="replica_database,new_identity"),
        pytest.param(True, False, 6, id="replica_database,existing_identity"),
    ],
)
def test_sdk_feature_states_get__identifier_and_missing_feature__returns_404(
    api_client: APIClient,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
    identity: Identity,
    is_new_identity: bool,
    mocker: MockerFixture,
    num_queries: int,
    use_replica: bool,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    mocker.patch.object(views, "is_database_replica_setup", return_value=use_replica)
    identifier = "morpheus" if is_new_identity else identity.identifier

    # When
    with django_assert_num_queries(num_queries):
        response = api_client.get(f"/api/v1/flags/{identifier}?feature=turbo_mode")

    # Then
    assert response.status_code == status.HTTP_404_NOT_FOUND
    assert Identity.objects.filter(identifier=identifier).exists()


def test_sdk_feature_states_get__existing_feature_filter__returns_feature(
    api_client: APIClient,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
    mocker: MockerFixture,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)

    # When
    response = api_client.get(f"/api/v1/flags/?feature={feature.name}")

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json() == {
        "id": feature_state.id,
        "enabled": feature.default_enabled,
        "environment": environment.id,
        "feature": mocker.ANY,
        "feature_segment": None,
        "feature_state_value": None,
        "identity": None,
    }


def test_sdk_feature_states_get__missing_feature_filter__returns_404(
    api_client: APIClient,
    environment: Environment,
    mocker: MockerFixture,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)

    # When
    response = api_client.get("/api/v1/flags/?feature=turbo_mode")

    # Then
    assert response.status_code == status.HTTP_404_NOT_FOUND


@pytest.mark.parametrize(
    "environment_value, project_value, disabled_flag_returned",
    (
        (True, True, False),
        (True, False, False),
        (False, True, True),
        (False, False, True),
        (None, True, False),
        (None, False, True),
    ),
)
def test_get_flags__hide_disabled_flags_setting__returns_expected_flags(
    environment_value: bool | None,
    project_value: bool,
    disabled_flag_returned: bool,
    project: Project,
    environment: Environment,
    api_client: APIClient,
) -> None:
    # Given
    project.hide_disabled_flags = project_value
    project.save()

    environment.hide_disabled_flags = environment_value
    environment.save()

    Feature.objects.create(name="disabled_flag", project=project, default_enabled=False)
    Feature.objects.create(name="enabled_flag", project=project, default_enabled=True)

    url = reverse("api-v1:flags")

    # When
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    response = api_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert len(response.json()) == (2 if disabled_flag_returned else 1)


def test_get_flags__hide_sensitive_data_enabled__returns_nulled_fields(
    api_client: APIClient,
    environment: Environment,
    feature: Feature,
) -> None:
    # Given
    environment.hide_sensitive_data = True
    environment.save()

    url = reverse("api-v1:flags")

    # When
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    response = api_client.get(url)
    feature_sensitive_fields = [
        "created_date",
        "description",
        "initial_value",
        "default_enabled",
    ]
    fs_sensitive_fields = ["id", "environment", "identity", "feature_segment"]

    # Then
    assert response.status_code == status.HTTP_200_OK
    # Check that the sensitive fields are None
    for flag in response.json():
        for field in fs_sensitive_fields:
            assert flag[field] is None

        for field in feature_sensitive_fields:
            assert flag["feature"][field] is None


def test_get_flags__server_key_only_feature__return_expected(
    api_client: APIClient,
    environment: Environment,
    feature: Feature,
) -> None:
    # Given
    feature.is_server_key_only = True
    feature.save()

    url = reverse("api-v1:flags")

    # When
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    response = api_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert not response.json()


def test_get_flags__cached_responses__returns_correct_per_environment(
    environment: Environment,
    feature: Feature,
    django_assert_num_queries: DjangoAssertNumQueries,
    project_two_feature: Feature,
    project_two_environment: Environment,
    use_local_mem_cache_for_cache_middleware: None,
) -> None:
    # Given
    url = reverse("api-v1:flags")

    # Create clients for two separate environments
    environment_one_client = APIClient(
        headers={SDK_ENVIRONMENT_KEY_HEADER: environment.api_key}
    )
    project_two_environment_client = APIClient(
        headers={SDK_ENVIRONMENT_KEY_HEADER: project_two_environment.api_key}
    )
    # Fetch flags for both environments once to warm the cache
    environment_one_response = environment_one_client.get(url)
    assert environment_one_response.status_code == status.HTTP_200_OK

    project_two_environment_response = project_two_environment_client.get(url)
    assert project_two_environment_response.status_code == status.HTTP_200_OK

    #  When
    with django_assert_num_queries(0):
        for _ in range(10):
            environment_one_response = environment_one_client.get(url)
            assert environment_one_response.status_code == status.HTTP_200_OK

            project_two_environment_response = project_two_environment_client.get(url)
            assert project_two_environment_response.status_code == status.HTTP_200_OK

            # Then
            # Each response must return the correct feature for its environment
            assert environment_one_response.json()[0]["feature"]["id"] == feature.id
            assert (
                project_two_environment_response.json()[0]["feature"]["id"]
                == project_two_feature.id
            )


def test_get_flags__server_key_only_with_server_auth__returns_feature(
    api_client: APIClient,
    environment_api_key: EnvironmentAPIKey,
    feature: Feature,
) -> None:
    # Given
    feature.is_server_key_only = True
    feature.save()

    url = reverse("api-v1:flags")

    # When
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment_api_key.key)
    response = api_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json()


def test_get_flags__server_key_only_feature__cache_isolation_between_client_and_server_keys(
    environment: Environment,
    environment_api_key: EnvironmentAPIKey,
    feature: Feature,
    settings: SettingsWrapper,
    use_local_mem_cache_for_cache_middleware: None,
) -> None:
    # Given
    feature.is_server_key_only = True
    feature.save()

    # Enable caching
    settings.CACHE_FLAGS_SECONDS = 30

    url = reverse("api-v1:flags")

    # Create clients for server and client keys
    server_client = APIClient(
        headers={SDK_ENVIRONMENT_KEY_HEADER: environment_api_key.key}
    )
    client_client = APIClient(headers={SDK_ENVIRONMENT_KEY_HEADER: environment.api_key})

    # When - First request with SERVER key (populates cache)
    server_response = server_client.get(url)

    # Then - Server should see the server-only feature
    assert server_response.status_code == status.HTTP_200_OK
    server_flags = server_response.json()
    server_feature_names = [flag["feature"]["name"] for flag in server_flags]
    assert feature.name in server_feature_names

    # When - Second request with CLIENT key (should not get server-only from cache)
    client_response = client_client.get(url)

    # Then - Client should NOT see the server-only feature
    assert client_response.status_code == status.HTTP_200_OK
    client_flags = client_response.json()
    client_feature_names = [flag["feature"]["name"] for flag in client_flags]
    assert feature.name not in client_feature_names


def test_get_feature_state_by_uuid__existing_state__returns_200(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
) -> None:
    # Given
    url = reverse(
        "api-v1:features:get-feature-state-by-uuid", args=[feature_state.uuid]
    )

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["uuid"] == str(feature_state.uuid)


def test_list_features__deleted_feature__returns_empty(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    feature: Feature,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    feature.delete()

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json()["count"] == 0


def test_get_evaluation_data__valid_request__returns_evaluation_data(
    project: Project,
    feature: Feature,
    environment: Environment,
    mocker: MockerFixture,
    admin_client_new: APIClient,
) -> None:
    # Given
    base_url = reverse(
        "api-v1:projects:project-features-get-evaluation-data",
        args=[project.id, feature.id],
    )
    url = f"{base_url}?environment_id={environment.id}"
    mocked_get_feature_evaluation_data = mocker.patch(
        "features.views.get_feature_evaluation_data",
        autospec=True,
    )
    today = date.today()
    mocked_get_feature_evaluation_data.return_value = [
        FeatureEvaluationData(count=10, day=today),
        FeatureEvaluationData(
            count=10,
            day=today,
            labels={"client_application_name": "web"},
        ),
        FeatureEvaluationData(count=10, day=today - timedelta(days=1)),
    ]
    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json() == [
        {
            "count": 10,
            "day": str(today),
            "labels": None,
        },
        {
            "count": 10,
            "day": str(today),
            "labels": {
                "client_application_name": "web",
                "client_application_version": None,
                "user_agent": None,
            },
        },
        {
            "count": 10,
            "day": str(today - timedelta(days=1)),
            "labels": None,
        },
    ]
    mocked_get_feature_evaluation_data.assert_called_with(
        feature=feature, period_days=30, environment_id=environment.id
    )


def test_get_feature_evaluation_data__labels_filter__returns_expected(
    project: Project,
    feature: Feature,
    environment: Environment,
    mocker: MockerFixture,
    admin_client_new: APIClient,
) -> None:
    # Given
    base_url = reverse(
        "api-v1:projects:project-features-get-evaluation-data",
        args=[project.id, feature.id],
    )
    url = f"{base_url}?environment_id={environment.id}&client_application_name=web"
    mocked_get_feature_evaluation_data = mocker.patch(
        "features.views.get_feature_evaluation_data",
        autospec=True,
    )
    today = date.today()
    mocked_get_feature_evaluation_data.return_value = [
        FeatureEvaluationData(
            count=10,
            day=today,
            labels={"client_application_name": "web"},
        ),
    ]

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json() == [
        {
            "count": 10,
            "day": str(today),
            "labels": {
                "client_application_name": "web",
                "client_application_version": None,
                "user_agent": None,
            },
        },
    ]
    mocked_get_feature_evaluation_data.assert_called_with(
        feature=feature,
        period_days=30,
        environment_id=environment.id,
        labels_filter={"client_application_name": "web"},
    )


def test_create_segment_override__no_permission__returns_403(
    feature: Feature,
    segment: Segment,
    environment: Environment,
    staff_user: FFAdminUser,
    staff_client: APIClient,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:create-segment-override",
        args=[environment.api_key, feature.id],
    )

    # When
    enabled = True
    string_value = "foo"
    data = {
        "feature_state_value": {"string_value": string_value},
        "enabled": enabled,
        "feature_segment": {"segment": segment.id},
    }

    # Staff client lacks permission to create segment.
    response = staff_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == 403
    assert response.data == {
        "detail": "You do not have permission to perform this action."
    }


def test_create_segment_override__staff_with_permission__returns_201(
    feature: Feature,
    segment: Segment,
    environment: Environment,
    staff_user: FFAdminUser,
    staff_client: APIClient,
    manage_segment_overrides_permission: PermissionModel,
    user_environment_permission: UserEnvironmentPermission,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:create-segment-override",
        args=[environment.api_key, feature.id],
    )

    # When
    enabled = True
    string_value = "foo"
    data = {
        "feature_state_value": {"string_value": string_value},
        "enabled": enabled,
        "feature_segment": {"segment": segment.id},
    }
    user_environment_permission.permissions.add(manage_segment_overrides_permission)

    response = staff_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )
    # Then
    assert response.status_code == 201
    assert response.data["feature_segment"]["segment"] == segment.id


def test_create_segment_override__admin_user__creates_override(
    admin_client_new: APIClient,
    feature: Feature,
    segment: Segment,
    environment: Environment,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:create-segment-override",
        args=[environment.api_key, feature.id],
    )

    enabled = True
    string_value = "foo"
    data = {
        "feature_state_value": {"string_value": string_value},
        "enabled": enabled,
        "feature_segment": {"segment": segment.id},
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED

    created_override = FeatureState.objects.filter(
        feature=feature, environment=environment, feature_segment__segment=segment
    ).first()
    assert created_override is not None
    assert created_override.enabled is enabled
    assert created_override.get_feature_state_value() == string_value


def test_get_flags__user_throttle_set__is_not_throttled(  # type: ignore[no-untyped-def]
    api_client: APIClient,
    environment: Environment,
    feature: Feature,
    settings: SettingsWrapper,
):
    # Given
    settings.REST_FRAMEWORK = {"DEFAULT_THROTTLE_RATES": {"user": "1/minute"}}
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)

    url = reverse("api-v1:flags")

    # When
    for _ in range(10):
        response = api_client.get(url)

        # Then
        assert response.status_code == status.HTTP_200_OK


def test_list_feature_states__simple_view_set__returns_expected_count(
    environment: Environment,
    feature: Feature,
    admin_user: FFAdminUser,
    admin_client_new: APIClient,
    django_assert_num_queries: DjangoAssertNumQueries,
) -> None:
    # Given
    base_url = reverse("api-v1:features:featurestates-list")
    url = f"{base_url}?environment={environment.id}"

    # add another feature
    feature2 = Feature.objects.create(
        name="another_feature", project=environment.project
    )

    # and a new version for the same feature to check for N+1 issues
    v1_feature_state = FeatureState.objects.get(
        environment=environment, feature=feature2
    )
    v1_feature_state.clone(env=environment, version=2, live_from=timezone.now())

    # add another organisation with a project, environment and feature (which should be
    # excluded)
    another_organisation = Organisation.objects.create(name="another_organisation")
    admin_user.add_organisation(another_organisation)
    another_project = Project.objects.create(
        name="another_project", organisation=another_organisation
    )
    Environment.objects.create(name="another_environment", project=another_project)
    Feature.objects.create(project=another_project, name="another_projects_feature")
    UserProjectPermission.objects.create(
        user=admin_user, project=another_project, admin=True
    )

    # add another feature with multivariate options
    mv_feature = Feature.objects.create(
        name="mv_feature", project=environment.project, type=MULTIVARIATE
    )
    MultivariateFeatureOption.objects.create(
        feature=mv_feature,
        default_percentage_allocation=10,
        type="unicode",
        string_value="foo",
    )

    # When
    with django_assert_num_queries(9):
        response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 3


def test_list_feature_states__nested_environment_view_set__returns_expected_count(
    environment: Environment,
    project: Project,
    feature: Feature,
    admin_client_new: APIClient,
    django_assert_num_queries: DjangoAssertNumQueries,
) -> None:
    # Given
    base_url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )

    # Add an MV feature
    mv_feature = Feature.objects.create(
        name="mv_feature", project=project, type=MULTIVARIATE
    )
    MultivariateFeatureOption.objects.create(
        feature=mv_feature,
        default_percentage_allocation=10,
        type="unicode",
        string_value="foo",
    )

    # Add another feature
    second_feature = Feature.objects.create(name="another_feature", project=project)

    # create some new versions to test N+1 issues
    v1_feature_state = FeatureState.objects.get(
        feature=second_feature, environment=environment
    )
    v2_feature_state = v1_feature_state.clone(
        env=environment, version=2, live_from=timezone.now()
    )
    v2_feature_state.clone(env=environment, version=3, live_from=timezone.now())

    # When
    with django_assert_num_queries(8):
        response = admin_client_new.get(base_url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 3


def test_list_environment_feature_states__feature_name_filter__returns_matching(
    environment: Environment,
    project: Project,
    feature: Feature,
    admin_client_new: APIClient,
) -> None:
    # Given
    Feature.objects.create(name="another_feature", project=project)
    base_url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    url = f"{base_url}?feature_name={feature.name}"

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json()["count"] == 1
    assert response.json()["results"][0]["feature"] == feature.id


def test_list_environment_feature_states__identity_override_filter__returns_override(
    environment: Environment,
    feature: Feature,
    admin_client_new: APIClient,
) -> None:
    # Given
    FeatureState.objects.get(environment=environment, feature=feature)

    identifier = "test-identity"
    identity = Identity.objects.create(identifier=identifier, environment=environment)
    FeatureState.objects.create(
        environment=environment, feature=feature, identity=identity
    )

    base_url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    url = base_url + "?anyIdentity&feature=" + str(feature.id)

    # When
    res = admin_client_new.get(url)

    # Then
    assert res.status_code == status.HTTP_200_OK
    assert len(res.json().get("results")) == 1
    assert res.json()["results"][0]["identity"]["identifier"] == identifier


def test_list_environment_feature_states__multiple_versions__returns_latest(
    environment: Environment,
    feature: Feature,
    admin_client_new: APIClient,
) -> None:
    # Given
    feature_state = FeatureState.objects.get(environment=environment, feature=feature)
    feature_state_v2 = feature_state.clone(
        env=environment, live_from=timezone.now(), version=2
    )

    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert len(response_json["results"]) == 1
    assert response_json["results"][0]["id"] == feature_state_v2.id


def test_list_environment_feature_states__null_version__excludes_null(
    environment: Environment,
    feature: Feature,
    admin_client_new: APIClient,
) -> None:
    # Given
    feature_state = FeatureState.objects.get(environment=environment, feature=feature)

    FeatureState.objects.create(environment=environment, feature=feature, version=None)

    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert len(response_json["results"]) == 1
    assert response_json["results"][0]["id"] == feature_state.id


def test_create_feature__default_values__is_archived_false(
    admin_client_new: APIClient, project: Project
) -> None:
    # Given
    data = {
        "name": "test feature",
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    ).json()

    # Then
    assert response["is_archived"] is False


def test_update_feature__set_is_archived__returns_archived(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
) -> None:
    # Given
    feature = Feature.objects.create(name="test feature", project=project)
    url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, feature.id],
    )
    data = {"name": "test feature", "is_archived": True}

    # When
    response = admin_client_new.put(url, data=data).json()

    # Then
    assert response["is_archived"] is True


def test_create_feature__multiple_environments__creates_feature_states(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
) -> None:
    # Given - set up data
    environment_2 = Environment.objects.create(
        name="Test environment 2", project=project
    )
    default_value = "This is a value"
    data = {
        "name": "test feature",
        "initial_value": default_value,
        "project": project.id,
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    # check feature was created successfully
    assert Feature.objects.filter(name="test feature", project=project.id).count() == 1

    # check feature was added to environment
    assert FeatureState.objects.filter(environment=environment).count() == 1
    assert FeatureState.objects.filter(environment=environment_2).count() == 1

    # check that value was correctly added to feature state
    feature_state = FeatureState.objects.filter(environment=environment).first()
    assert feature_state.get_feature_state_value() == default_value


@pytest.mark.parametrize("default_value", [(12), (True), ("test")])
def test_create_feature__with_initial_value__creates_feature_state_with_value(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    default_value: int | bool | str,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {
        "name": "test feature",
        "initial_value": default_value,
        "project": project.id,
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    # check feature was created successfully
    assert Feature.objects.filter(name="test feature", project=project.id).count() == 1

    # check feature was added to environment
    assert FeatureState.objects.filter(environment=environment).count() == 1

    # check that value was correctly added to feature state
    feature_state = FeatureState.objects.filter(environment=environment).first()
    assert feature_state.get_feature_state_value() == default_value


def test_delete_feature__existing_feature__removes_feature_states(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
    environment: Environment,
) -> None:
    # Given
    url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, feature.id],
    )

    # When
    response = admin_client_new.delete(url)

    # Then
    assert response.status_code == status.HTTP_204_NO_CONTENT
    # check feature was deleted successfully
    assert Feature.objects.filter(name="test feature", project=project.id).count() == 0

    # check feature was removed from all environments
    assert (
        FeatureState.objects.filter(environment=environment, feature=feature).count()
        == 0
    )
    assert (
        FeatureState.objects.filter(environment=environment, feature=feature).count()
        == 0
    )


def test_create_feature__name_matches_regex__returns_201(
    admin_client_new: APIClient, project: Project
) -> None:
    # Given
    project.feature_name_regex = "^[a-z_]{18}$"
    project.save()

    # feature name that has 18 characters
    feature_name = "valid_feature_name"

    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {"name": feature_name, "type": STANDARD, "project": project.id}

    # When
    response = admin_client_new.post(url, data=data)

    # Then
    assert response.status_code == status.HTTP_201_CREATED


def test_create_feature__name_does_not_match_regex__returns_400(
    admin_client_new: APIClient, project: Project
) -> None:
    # Given
    project.feature_name_regex = "^[a-z]{18}$"
    project.save()

    # feature name longer than 18 characters
    feature_name = "not_a_valid_feature_name"

    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {"name": feature_name, "type": STANDARD, "project": project.id}

    # When
    response = admin_client_new.post(url, data=data)

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert (
        response.json()["name"][0]
        == f"Feature name must match regex: {project.feature_name_regex}"
    )


def test_create_feature__valid_data__creates_audit_log(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {"name": "Test feature flag", "type": STANDARD, "project": project.id}

    # When
    response = admin_client_new.post(url, data=data)
    feature_id = response.json()["id"]

    # Then
    # Audit log exists for the feature
    assert (
        AuditLog.objects.filter(
            related_object_type=RelatedObjectType.FEATURE.name,
            related_object_id=feature_id,
        ).count()
        == 1
    )
    # and Audit log exists for every environment
    assert AuditLog.objects.filter(
        related_object_type=RelatedObjectType.FEATURE_STATE.name,
        project=project,
        environment__in=project.environments.all(),
    ).count() == len(project.environments.all())


def test_update_feature__valid_data__creates_audit_log(
    admin_client_new: APIClient, project: Project, feature: Feature
) -> None:
    # Given
    url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, feature.id],
    )
    data = {
        "name": feature.name,
        "description": "Updated description",
        "project": project.id,
    }

    # When
    admin_client_new.put(url, data=data)

    # Then
    assert (
        AuditLog.objects.filter(
            related_object_type=RelatedObjectType.FEATURE.name
        ).count()
        == 1
    )


def test_delete_feature__existing_feature__creates_audit_logs(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
) -> None:
    # Given
    url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, feature.id],
    )
    feature_states_ids = list(feature.feature_states.values_list("id", flat=True))

    # When
    admin_client_new.delete(url)

    # Then
    # Audit log exists for the feature
    assert AuditLog.objects.get(
        related_object_type=RelatedObjectType.FEATURE.name,
        related_object_id=feature.id,
        log=FEATURE_DELETED_MESSAGE % feature.name,
    )
    # and audit logs exists for all feature states for that feature
    assert AuditLog.objects.filter(
        related_object_type=RelatedObjectType.FEATURE_STATE.name,
        related_object_id__in=feature_states_ids,
        log=FEATURE_DELETED_MESSAGE % feature.name,
    ).count() == len(feature_states_ids)


def test_create_feature__with_tags__creates_tagged_feature(
    admin_client_new: APIClient,
    project: Project,
    tag_one: Tag,
    tag_two: Tag,
) -> None:
    # Given - set up data
    default_value = "Test"
    feature_name = "Test feature"
    data = {
        "name": feature_name,
        "project": project.id,
        "initial_value": default_value,
        "tags": [tag_one.id, tag_two.id],
    }

    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.post(
        url,
        data=json.dumps(data),
        content_type="application/json",
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED

    # check feature was created successfully
    feature = Feature.objects.filter(name=feature_name, project=project.id).first()

    # check feature is tagged
    assert feature.tags.count() == 2
    assert list(feature.tags.all()) == [tag_one, tag_two]


def test_add_owners__users_not_in_project__returns_400(
    admin_client_new: APIClient, project: Project
) -> None:
    # Given
    feature = Feature.objects.create(name="Test Feature", project=project)

    # Users have no association to the project or organisation.
    user_1 = FFAdminUser.objects.create_user(email="user1@mail.com")  # type: ignore[no-untyped-call]
    user_2 = FFAdminUser.objects.create_user(email="user2@mail.com")  # type: ignore[no-untyped-call]
    url = reverse(
        "api-v1:projects:project-features-add-owners",
        args=[project.id, feature.id],
    )
    data = {"user_ids": [user_1.id, user_2.id]}

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )
    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert response.data == ["Some users not found"]
    assert feature.owners.filter(id__in=[user_1.id, user_2.id]).count() == 0


def test_add_owners__valid_users__adds_owners(
    staff_user: FFAdminUser,
    admin_user: FFAdminUser,
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    feature = Feature.objects.create(name="Test Feature", project=project)
    UserProjectPermission.objects.create(
        user=staff_user, project=project
    ).add_permission(VIEW_PROJECT)

    url = reverse(
        "api-v1:projects:project-features-add-owners",
        args=[project.id, feature.id],
    )
    data = {"user_ids": [staff_user.id, admin_user.id]}

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    json_response = response.json()
    # Then
    assert len(json_response["owners"]) == 2
    assert json_response["owners"][0] == {
        "id": staff_user.id,
        "email": staff_user.email,
        "first_name": staff_user.first_name,
        "last_name": staff_user.last_name,
        "last_login": None,
        "uuid": mock.ANY,
    }
    assert json_response["owners"][1] == {
        "id": admin_user.id,
        "email": admin_user.email,
        "first_name": admin_user.first_name,
        "last_name": admin_user.last_name,
        "last_login": None,
        "uuid": mock.ANY,
    }


def test_add_group_owners__valid_groups__adds_group_owners(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    feature = Feature.objects.create(name="Test Feature", project=project)
    user_1 = FFAdminUser.objects.create_user(email="user1@mail.com")  # type: ignore[no-untyped-call]
    organisation = project.organisation
    group_1 = UserPermissionGroup.objects.create(
        name="Test Group", organisation=organisation
    )
    group_2 = UserPermissionGroup.objects.create(
        name="Second Group", organisation=organisation
    )
    user_1.add_organisation(organisation, OrganisationRole.ADMIN)
    group_1.users.add(user_1)
    group_2.users.add(user_1)

    url = reverse(
        "api-v1:projects:project-features-add-group-owners",
        args=[project.id, feature.id],
    )

    data = {"group_ids": [group_1.id, group_2.id]}

    # When
    json_response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    ).json()

    # Then
    assert len(json_response["group_owners"]) == 2
    assert json_response["group_owners"][0] == {
        "id": group_1.id,
        "name": group_1.name,
    }
    assert json_response["group_owners"][1] == {
        "id": group_2.id,
        "name": group_2.name,
    }


def test_remove_group_owners__existing_group__removes_specified_group(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    feature = Feature.objects.create(name="Test Feature", project=project)
    user_1 = FFAdminUser.objects.create_user(email="user1@mail.com")  # type: ignore[no-untyped-call]
    organisation = project.organisation
    group_1 = UserPermissionGroup.objects.create(
        name="To be removed group", organisation=organisation
    )
    group_2 = UserPermissionGroup.objects.create(
        name="To be kept group", organisation=organisation
    )
    user_1.add_organisation(organisation, OrganisationRole.ADMIN)
    group_1.users.add(user_1)
    group_2.users.add(user_1)

    feature.group_owners.add(group_1.id, group_2.id)

    url = reverse(
        "api-v1:projects:project-features-remove-group-owners",
        args=[project.id, feature.id],
    )

    # Note that only group_1 is set to be removed.
    data = {"group_ids": [group_1.id]}

    # When
    json_response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    ).json()

    # Then
    assert len(json_response["group_owners"]) == 1
    assert json_response["group_owners"][0] == {
        "id": group_2.id,
        "name": group_2.name,
    }


def test_remove_group_owners__nonexistent_group__succeeds(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    feature = Feature.objects.create(name="Test Feature", project=project)
    user_1 = FFAdminUser.objects.create_user(email="user1@mail.com")  # type: ignore[no-untyped-call]
    organisation = project.organisation
    group_1 = UserPermissionGroup.objects.create(
        name="To be removed group", organisation=organisation
    )
    user_1.add_organisation(organisation, OrganisationRole.ADMIN)
    group_1.users.add(user_1)

    assert feature.group_owners.count() == 0

    url = reverse(
        "api-v1:projects:project-features-remove-group-owners",
        args=[project.id, feature.id],
    )

    # Note that group_1 is not present, but it should work
    # anyway since there may have been a double request or two
    # users working at the same time.
    data = {"group_ids": [group_1.id]}

    # When
    json_response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    ).json()

    # Then
    assert len(json_response["group_owners"]) == 0


def test_add_group_owners__wrong_organisation_group__returns_400(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    feature = Feature.objects.create(name="Test Feature", project=project)
    user_1 = FFAdminUser.objects.create_user(email="user1@mail.com")  # type: ignore[no-untyped-call]
    user_2 = FFAdminUser.objects.create_user(email="user2@mail.com")  # type: ignore[no-untyped-call]
    organisation = project.organisation
    other_organisation = Organisation.objects.create(name="Orgy")

    group_1 = UserPermissionGroup.objects.create(
        name="Valid Group", organisation=organisation
    )
    group_2 = UserPermissionGroup.objects.create(
        name="Invalid Group", organisation=other_organisation
    )
    user_1.add_organisation(organisation, OrganisationRole.ADMIN)
    user_2.add_organisation(other_organisation, OrganisationRole.ADMIN)
    group_1.users.add(user_1)
    group_2.users.add(user_2)

    url = reverse(
        "api-v1:projects:project-features-add-group-owners",
        args=[project.id, feature.id],
    )

    data = {"group_ids": [group_1.id, group_2.id]}

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == 400
    response.json() == {"non_field_errors": ["Some groups not found"]}


def test_list_features__with_tags__returns_tags_in_response(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
) -> None:
    # Given
    Feature.objects.create(name="test_feature", project=project)
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()

    feature = response_json["results"][0]
    assert "tags" in feature


def test_list_features__with_group_owners__returns_group_owners(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    feature = Feature.objects.create(name="test_feature", project=project)
    organisation = project.organisation
    group_1 = UserPermissionGroup.objects.create(
        name="Test Group", organisation=organisation
    )
    group_2 = UserPermissionGroup.objects.create(
        name="Second Group", organisation=organisation
    )
    feature.group_owners.add(group_1.id, group_2.id)

    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()

    feature = response_json["results"][1]
    assert feature["group_owners"][0] == {
        "id": group_1.id,
        "name": group_1.name,
    }
    assert feature["group_owners"][1] == {
        "id": group_2.id,
        "name": group_2.name,
    }


def test_create_feature__admin_with_mv_options__returns_201(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    data = {
        "name": "test_feature",
        "default_enabled": True,
        "multivariate_options": [{"type": "unicode", "string_value": "test-value"}],
    }
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED

    response_json = response.json()
    assert len(response_json["multivariate_options"]) == 1


def test_get_feature_by_uuid__existing_feature__returns_200(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
) -> None:
    # Given
    url = reverse("api-v1:features:get-feature-by-uuid", args=[feature.uuid])

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json()["id"] == feature.id
    assert response.json()["uuid"] == str(feature.uuid)


def test_get_feature_by_uuid__nonexistent_feature__returns_404(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    url = reverse("api-v1:features:get-feature-by-uuid", args=[uuid.uuid4()])

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_404_NOT_FOUND


def test_update_feature_state_value__dynamo_enabled__triggers_rebuild(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
    settings: SettingsWrapper,
    mocker: MockerFixture,
) -> None:
    # Given
    project.enable_dynamo_db = True
    project.save()

    url = reverse(
        "api-v1:environments:environment-featurestates-detail",
        args=[environment.api_key, feature_state.id],
    )
    mock_dynamo_environment_wrapper = mocker.patch(
        "environments.models.environment_wrapper"
    )

    # When
    response = admin_client_new.patch(
        url,
        data=json.dumps({"feature_state_value": "new value"}),
        content_type="application/json",
    )

    # Then
    assert response.status_code == 200
    mock_dynamo_environment_wrapper.write_environments.assert_called_once()


def test_create_segment_overrides__multiple_segments__creates_audit_logs(
    admin_client_new: APIClient,
    feature: Feature,
    segment: Segment,
    environment: Environment,
) -> None:
    # Given
    another_segment = Segment.objects.create(
        name="Another segment", project=segment.project
    )

    feature_segments_url = reverse("api-v1:features:feature-segment-list")
    feature_states_url = reverse("api-v1:features:featurestates-list")

    # When
    # we create 2 segment overrides for the feature
    for _segment in (segment, another_segment):
        feature_segment_response = admin_client_new.post(
            feature_segments_url,
            data={
                "feature": feature.id,
                "segment": _segment.id,
                "environment": environment.id,
            },
        )
        assert feature_segment_response.status_code == status.HTTP_201_CREATED
        feature_segment_id = feature_segment_response.json()["id"]
        feature_state_response = admin_client_new.post(
            feature_states_url,
            data={
                "feature": feature.id,
                "feature_segment": feature_segment_id,
                "environment": environment.id,
                "enabled": True,
            },
        )
        assert feature_state_response.status_code == status.HTTP_201_CREATED

    # Then
    assert AuditLog.objects.count() == 2
    assert (
        AuditLog.objects.filter(
            log=f"Flag state / Remote config value updated for feature "
            f"'{feature.name}' and segment '{segment.name}'"
        ).count()
        == 1
    )
    assert (
        AuditLog.objects.filter(
            log=f"Flag state / Remote config value updated for feature "
            f"'{feature.name}' and segment '{another_segment.name}'"
        ).count()
        == 1
    )


def test_list_features__with_overrides__returns_override_counts(
    feature: Feature,
    segment: Segment,
    segment_featurestate: FeatureState,
    identity: Identity,
    identity_featurestate: FeatureState,
    project: Project,
    environment: Environment,
    admin_client_new: APIClient,
) -> None:
    # Given
    url = "%s?environment=%d" % (
        reverse("api-v1:projects:project-features-list", args=[project.id]),
        environment.id,
    )

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 1
    assert response_json["results"][0]["num_segment_overrides"] == 1
    assert response_json["results"][0]["num_identity_overrides"] == 1


def test_list_features__v2_versioning_with_removed_override__returns_zero_overrides(  # type: ignore[no-untyped-def]
    feature: Feature,
    segment: Segment,
    project: Project,
    environment_v2_versioning: Environment,
    admin_client_new: APIClient,
    admin_user: FFAdminUser,
):
    # Given
    url = "%s?environment=%d" % (
        reverse("api-v1:projects:project-features-list", args=[project.id]),
        environment_v2_versioning.id,
    )

    # let's create a new version with a segment override
    version_2 = EnvironmentFeatureVersion.objects.create(
        environment=environment_v2_versioning, feature=feature
    )
    FeatureState.objects.create(
        feature=feature,
        environment=environment_v2_versioning,
        feature_segment=FeatureSegment.objects.create(
            feature=feature,
            environment=environment_v2_versioning,
            segment=segment,
        ),
        environment_feature_version=version_2,
    )
    version_2.publish(admin_user)

    # and now let's create a new version which removes the segment override
    version_3 = EnvironmentFeatureVersion.objects.create(
        environment=environment_v2_versioning, feature=feature
    )
    FeatureState.objects.filter(
        environment_feature_version=version_3,
        feature_segment__segment=segment,
    ).delete()
    version_3.publish(admin_user)

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 1

    # The number of segment overrides in the latest version should be 0
    assert response_json["results"][0]["num_segment_overrides"] == 0


def test_list_features__dynamo_enabled_project__returns_segment_override_count(
    dynamo_enabled_project: Project,
    dynamo_enabled_project_environment_one: Environment,
    dynamodb_wrapper_v2: DynamoEnvironmentV2Wrapper,
    admin_client_new: APIClient,
) -> None:
    # Given
    feature = Feature.objects.create(
        name="test_feature", project=dynamo_enabled_project
    )
    segment = Segment.objects.create(
        name="test_segment", project=dynamo_enabled_project
    )
    feature_segment = FeatureSegment.objects.create(
        feature=feature,
        segment=segment,
        environment=dynamo_enabled_project_environment_one,
    )
    FeatureState.objects.create(
        feature=feature,
        environment=dynamo_enabled_project_environment_one,
        feature_segment=feature_segment,
    )
    url = "%s?environment=%d" % (
        reverse(
            "api-v1:projects:project-features-list", args=[dynamo_enabled_project.id]
        ),
        dynamo_enabled_project_environment_one.id,
    )

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 1
    assert response_json["results"][0]["num_segment_overrides"] == 1
    assert response_json["results"][0]["num_identity_overrides"] is None


def test_list_features__dynamo_enabled__calls_get_overrides_data(
    dynamo_enabled_project: Project,
    dynamo_enabled_project_environment_one: Environment,
    admin_client_new: APIClient,
    mocker: MockerFixture,
) -> None:
    # Given
    feature = Feature.objects.create(
        name="test_feature", project=dynamo_enabled_project
    )
    url = "%s?environment=%d" % (
        reverse(
            "api-v1:projects:project-features-list", args=[dynamo_enabled_project.id]
        ),
        dynamo_enabled_project_environment_one.id,
    )
    mock_get_overrides_data = mocker.patch("features.views.get_overrides_data")
    mock_get_overrides_data.return_value = {
        feature.id: EnvironmentFeatureOverridesData()
    }

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    mock_get_overrides_data.assert_called_once_with(
        dynamo_enabled_project_environment_one,
    )


def test_create_segment_override__max_limit_reached__returns_400(
    admin_client_new: APIClient,
    feature: Feature,
    segment: Segment,
    project: Project,
    environment: Environment,
    settings: SettingsWrapper,
) -> None:
    # Given
    project.max_segment_overrides_allowed = 1
    project.save()

    url = reverse(
        "api-v1:environments:create-segment-override",
        args=[environment.api_key, feature.id],
    )

    data = {
        "feature_state_value": {"string_value": "value"},
        "enabled": True,
        "feature_segment": {"segment": segment.id},
    }

    # Now, create the first override
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )
    assert response.status_code == status.HTTP_201_CREATED

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert (
        response.json()["environment"]
        == "The environment has reached the maximum allowed segments overrides limit."
    )
    assert environment.feature_segments.count() == 1


def test_create_feature__max_limit_reached__returns_400(
    admin_client_new: APIClient,
    project: Project,
    settings: SettingsWrapper,
) -> None:
    # Given
    project.max_features_allowed = 1
    project.save()

    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # Now, create the first feature
    response = admin_client_new.post(
        url, data={"name": "test_feature", "project": project.id}
    )
    assert response.status_code == status.HTTP_201_CREATED

    # When
    response = admin_client_new.post(
        url, data={"name": "second_feature", "project": project.id}
    )

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert (
        response.json()["project"]
        == "The Project has reached the maximum allowed features limit."
    )


def test_create_segment_override__environment_viewset__returns_201(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_segment: FeatureSegment,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    new_value = "new-value"
    data = {
        "feature_state_value": new_value,
        "enabled": False,
        "feature": feature.id,
        "environment": environment.id,
        "identity": None,
        "feature_segment": feature_segment.id,
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    response.json()["feature_state_value"] == new_value


def test_create_feature_state__feature_from_different_project__returns_403(
    admin_client_new: APIClient,
    environment: Environment,
    project_two_feature: Feature,
    feature_segment: FeatureSegment,
    project_two: Project,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    new_value = "new-value"
    data = {
        "feature_state_value": new_value,
        "enabled": False,
        "feature": project_two_feature.id,
        "environment": environment.id,
        "identity": None,
        "feature_segment": feature_segment.id,
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_403_FORBIDDEN


def test_create_feature_state__different_environment_in_body__uses_url_environment(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_segment: FeatureSegment,
    environment_two: Environment,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    new_value = "new-value"
    data = {
        "feature_state_value": new_value,
        "enabled": False,
        "feature": feature.id,
        "environment": environment_two.id,
        "feature_segment": feature_segment.id,
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert response.json()["environment"] == environment.id


def test_create_feature_state__cross_project_feature__returns_403(
    admin_client_new: APIClient,
    environment: Environment,
    project_two_feature: Feature,
    feature_segment: FeatureSegment,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    new_value = "new-value"
    data = {
        "feature_state_value": new_value,
        "enabled": False,
        "feature": project_two_feature.id,
        "environment": environment.id,
        "identity": None,
        "feature_segment": feature_segment.id,
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_403_FORBIDDEN


def test_create_feature_state__environment_field_override__ignores_override(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_segment: FeatureSegment,
    environment_two: Environment,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-list",
        args=[environment.api_key],
    )
    new_value = "new-value"
    data = {
        "feature_state_value": new_value,
        "enabled": False,
        "feature": feature.id,
        "environment": environment_two.id,
        "feature_segment": feature_segment.id,
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert response.json()["environment"] == environment.id


def test_update_feature_state__change_environment__returns_400(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
    environment_two: Environment,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-detail",
        args=[environment.api_key, feature_state.id],
    )
    new_value = "new-value"
    data = {
        "id": feature_state.id,
        "feature_state_value": new_value,
        "enabled": False,
        "feature": feature.id,
        "environment": environment_two.id,
        "identity": None,
        "feature_segment": None,
    }

    # When
    response = admin_client_new.put(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then - it did not change the environment field on the feature state
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert (
        response.json()["environment"][0]
        == "Cannot change the environment of a feature state"
    )


def test_update_feature_state__no_fsv_history__returns_200(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
) -> None:
    # Given
    url = reverse(
        "api-v1:environments:environment-featurestates-detail",
        args=[environment.api_key, feature_state.id],
    )
    new_value = "new-value"

    # Remove historical feature state value
    feature_state.feature_state_value.history.all().delete()

    data = {
        "id": feature_state.id,
        "feature_state_value": new_value,
        "enabled": False,
        "feature": feature.id,
        "environment": environment.id,
        "identity": None,
        "feature_segment": None,
    }
    # When
    response = admin_client_new.put(
        url, data=json.dumps(data), content_type="application/json"
    )
    # Then
    assert response.status_code == status.HTTP_200_OK


def test_update_feature_state__change_feature__returns_400(
    admin_client_new: APIClient,
    environment: Environment,
    feature: Feature,
    feature_state: FeatureState,
    identity: Identity,
    project: Project,
) -> None:
    # Given
    another_feature = Feature.objects.create(
        name="another_feature", project=project, initial_value="initial_value"
    )
    url = reverse("api-v1:features:featurestates-detail", args=[feature_state.id])

    feature_state_value = "New value"
    data = {
        "enabled": True,
        "feature_state_value": {"type": "unicode", "string_value": feature_state_value},
        "environment": environment.id,
        "feature": another_feature.id,
    }

    # When
    response = admin_client_new.put(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert another_feature.feature_states.count() == 1
    assert response.status_code == status.HTTP_400_BAD_REQUEST
    assert (
        response.json()["feature"][0] == "Cannot change the feature of a feature state"
    )


@pytest.mark.parametrize(
    "client",
    [lazy_fixture("admin_master_api_key_client"), lazy_fixture("admin_client")],
)
def test_create_feature__missing_required_metadata__returns_400(
    project: Project,
    client: APIClient,
    required_a_feature_metadata_field: MetadataModelField,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    description = "This is the description"
    data = {
        "name": "Test feature",
        "description": description,
    }

    # When
    response = client.post(url, data=json.dumps(data), content_type="application/json")

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST


@pytest.mark.parametrize(
    "client",
    [lazy_fixture("admin_master_api_key_client"), lazy_fixture("admin_client")],
)
def test_create_feature__with_optional_metadata__returns_201(
    project: Project,
    client: APIClient,
    optional_b_feature_metadata_field: MetadataModelField,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    description = "This is the description"
    field_value = 10
    data = {
        "name": "Test feature",
        "description": description,
        "metadata": [
            {
                "model_field": optional_b_feature_metadata_field.id,
                "field_value": field_value,
            },
        ],
    }

    # When
    response = client.post(url, data=json.dumps(data), content_type="application/json")

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert (
        response.json()["metadata"][0]["model_field"]
        == optional_b_feature_metadata_field.id
    )
    assert response.json()["metadata"][0]["field_value"] == str(field_value)


@pytest.mark.parametrize(
    "client",
    [lazy_fixture("admin_master_api_key_client"), lazy_fixture("admin_client")],
)
def test_create_feature__with_required_metadata__returns_201(
    project: Project,
    client: APIClient,
    required_a_feature_metadata_field: MetadataModelField,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    description = "This is the description"
    field_value = 10
    data = {
        "name": "Test feature",
        "description": description,
        "metadata": [
            {
                "model_field": required_a_feature_metadata_field.id,
                "field_value": field_value,
            },
        ],
    }

    # When
    response = client.post(url, data=json.dumps(data), content_type="application/json")

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert (
        response.json()["metadata"][0]["model_field"]
        == required_a_feature_metadata_field.id
    )
    assert response.json()["metadata"][0]["field_value"] == str(field_value)


@pytest.mark.parametrize(
    "client",
    [lazy_fixture("admin_master_api_key_client"), lazy_fixture("admin_client")],
)
def test_create_feature__required_metadata_org_content_type__returns_201(
    project: Project,
    client: APIClient,
    required_a_feature_metadata_field_using_organisation_content_type: MetadataModelField,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    description = "This is the description"
    field_value = 10
    data = {
        "name": "Test feature",
        "description": description,
        "metadata": [
            {
                "model_field": required_a_feature_metadata_field_using_organisation_content_type.id,
                "field_value": field_value,
            },
        ],
    }

    # When
    response = client.post(url, data=json.dumps(data), content_type="application/json")

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert (
        response.json()["metadata"][0]["model_field"]
        == required_a_feature_metadata_field_using_organisation_content_type.id
    )
    assert response.json()["metadata"][0]["field_value"] == str(field_value)


def test_create_segment_override__using_simple_feature_state_viewset__allows_manage_segment_overrides(
    staff_client: APIClient,
    with_environment_permissions: WithEnvironmentPermissionsCallable,
    environment: Environment,
    feature: Feature,
    segment: Segment,
    feature_segment: FeatureSegment,
) -> None:
    # Given
    with_environment_permissions([MANAGE_SEGMENT_OVERRIDES])  # type: ignore[call-arg]

    url = reverse("api-v1:features:featurestates-list")

    data = {
        "feature": feature.id,
        "environment": environment.id,
        "feature_segment": feature_segment.id,
        "enabled": True,
        "feature_state_value": {
            "type": "unicode",
            "string_value": "foo",
        },
    }

    # When
    response = staff_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED

    assert FeatureState.objects.filter(
        feature=feature, environment=environment, feature_segment=feature_segment
    ).exists()


def test_create_segment_override__using_simple_feature_state_viewset__denies_update_feature_state(
    staff_client: APIClient,
    with_environment_permissions: WithEnvironmentPermissionsCallable,
    environment: Environment,
    feature: Feature,
    segment: Segment,
    feature_segment: FeatureSegment,
) -> None:
    # Given
    with_environment_permissions([UPDATE_FEATURE_STATE])  # type: ignore[call-arg]

    url = reverse("api-v1:features:featurestates-list")

    data = {
        "feature": feature.id,
        "environment": environment.id,
        "feature_segment": feature_segment.id,
        "enabled": True,
        "feature_state_value": {
            "type": "unicode",
            "string_value": "foo",
        },
    }

    # When
    response = staff_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_403_FORBIDDEN


def test_update_segment_override__using_simple_feature_state_viewset__allows_manage_segment_overrides(
    staff_client: APIClient,
    with_environment_permissions: WithEnvironmentPermissionsCallable,
    environment: Environment,
    feature: Feature,
    segment: Segment,
    feature_segment: FeatureSegment,
    segment_featurestate: FeatureState,
) -> None:
    # Given
    with_environment_permissions([MANAGE_SEGMENT_OVERRIDES])  # type: ignore[call-arg]

    url = reverse(
        "api-v1:features:featurestates-detail", args=[segment_featurestate.id]
    )

    data = {
        "feature": feature.id,
        "environment": environment.id,
        "feature_segment": feature_segment.id,
        "enabled": True,
        "feature_state_value": {
            "type": "unicode",
            "string_value": "foo",
        },
    }

    # When
    response = staff_client.put(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK

    assert FeatureState.objects.filter(
        feature=feature,
        environment=environment,
        feature_segment=feature_segment,
        enabled=True,
        feature_state_value__string_value="foo",
    ).exists()


def test_update_segment_override__using_simple_feature_state_viewset__denies_update_feature_state(
    staff_client: APIClient,
    with_environment_permissions: WithEnvironmentPermissionsCallable,
    environment: Environment,
    feature: Feature,
    segment: Segment,
    feature_segment: FeatureSegment,
    segment_featurestate: FeatureState,
) -> None:
    # Given
    with_environment_permissions([UPDATE_FEATURE_STATE])  # type: ignore[call-arg]

    url = reverse(
        "api-v1:features:featurestates-detail", args=[segment_featurestate.id]
    )

    data = {
        "feature": feature.id,
        "environment": environment.id,
        "feature_segment": feature_segment.id,
        "enabled": True,
        "feature_state_value": {
            "type": "unicode",
            "string_value": "foo",
        },
    }

    # When
    response = staff_client.put(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_403_FORBIDDEN


@pytest.mark.skipif(
    settings.IS_RBAC_INSTALLED is True,
    reason="Skip this test if RBAC is installed",
)
def test_list_features__without_rbac__no_n_plus_1(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
) -> None:
    """
    TODO: When running locally, this test can come up with an extra query.
          It should be tested against CI to ensure it passes, but it would
          be even better to solve the underlying issue while runnig locally.
          See: https://github.com/Flagsmith/flagsmith/issues/4898
    """
    # Given / When
    # Then
    _assert_list_feature_n_plus_1(
        staff_client,
        project,
        feature,
        with_project_permissions,
        django_assert_num_queries,
        environment,
        num_queries=18,
    )


@pytest.mark.skipif(
    settings.IS_RBAC_INSTALLED is False,
    reason="Skip this test if RBAC is not installed",
)
def test_list_features__with_rbac__no_n_plus_1(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
) -> None:  # pragma: no cover
    # Given / When
    # Then
    _assert_list_feature_n_plus_1(
        staff_client,
        project,
        feature,
        with_project_permissions,
        django_assert_num_queries,
        environment,
        num_queries=19,
    )


def _assert_list_feature_n_plus_1(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
    num_queries: int,
) -> None:
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = f"{base_url}?environment={environment.id}"

    # add some more versions to test for N+1 issues
    v1_feature_state = FeatureState.objects.get(
        feature=feature, environment=environment
    )
    for i in range(2, 4):
        v1_feature_state.clone(env=environment, version=i, live_from=timezone.now())

    # When
    with django_assert_num_queries(num_queries):
        response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK


def test_list_features__different_project__returns_404(
    staff_client: APIClient,
    organisation_two_project_two: Project,
    with_project_permissions: WithProjectPermissionsCallable,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    url = reverse(
        "api-v1:projects:project-features-list", args=[organisation_two_project_two.id]
    )

    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_404_NOT_FOUND


def test_list_features__union_tag_filter__returns_matching_features(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    tag1 = Tag.objects.create(
        label="Test Tag",
        color="#fffff",
        description="Test Tag description",
        project=project,
    )
    tag2 = Tag.objects.create(
        label="Test Tag2",
        color="#fffff",
        description="Test Tag2 description",
        project=project,
    )
    feature2 = Feature.objects.create(
        name="another_feature", project=project, initial_value="initial_value"
    )
    feature3 = Feature.objects.create(
        name="missing_feature", project=project, initial_value="gone"
    )
    feature2.tags.add(tag1)
    feature3.tags.add(tag2)

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = (
        f"{base_url}?environment={environment.id}&tags={tag1.id}"
        f",{tag2.id}&tag_strategy=UNION"
    )
    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    # The first feature has been filtered out of the results.
    assert len(response.data["results"]) == 2

    assert response.data["results"][0]["id"] == feature2.id
    assert response.data["results"][0]["tags"] == [tag1.id]
    assert response.data["results"][1]["id"] == feature3.id
    assert response.data["results"][1]["tags"] == [tag2.id]


def test_list_features__intersection_tag_filter__returns_matching_features(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    tag1 = Tag.objects.create(
        label="Test Tag",
        color="#fffff",
        description="Test Tag description",
        project=project,
    )
    tag2 = Tag.objects.create(
        label="Test Tag2",
        color="#fffff",
        description="Test Tag2 description",
        project=project,
    )
    feature2 = Feature.objects.create(
        name="another_feature", project=project, initial_value="initial_value"
    )
    feature3 = Feature.objects.create(
        name="missing_feature", project=project, initial_value="gone"
    )
    feature2.tags.add(tag1, tag2)
    feature3.tags.add(tag2)

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = (
        f"{base_url}?environment={environment.id}&tags={tag1.id}"
        f",{tag2.id}&tag_strategy=INTERSECTION"
    )
    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    # Only feature2 has both tags, so it is the only result.
    assert len(response.data["results"]) == 1

    assert response.data["results"][0]["id"] == feature2.id
    assert response.data["results"][0]["tags"] == [tag1.id, tag2.id]


def test_list_features__with_environment__returns_feature_state_data(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    environment: Environment,
    identity: Identity,
    feature_segment: FeatureSegment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    feature2 = Feature.objects.create(
        name="another_feature", project=project, initial_value="initial_value"
    )
    feature3 = Feature.objects.create(
        name="fancy_feature", project=project, initial_value="gone"
    )

    Environment.objects.create(
        name="Out of test scope environment",
        project=project,
    )

    # This should be ignored due to versioning.
    feature_state1 = feature.feature_states.filter(environment=environment).first()
    feature_state1.enabled = True  # type: ignore[union-attr]
    feature_state1.version = 1  # type: ignore[union-attr]
    feature_state1.save()  # type: ignore[union-attr]

    # This should be ignored due to less recent live_from compared to the next feature state
    # event though it has a higher version.
    FeatureState.objects.create(
        feature=feature,
        environment=environment,
        live_from=two_hours_ago,
        enabled=True,
        version=101,
    )
    # This should be returned
    feature_state_versioned = FeatureState.objects.create(
        feature=feature,
        environment=environment,
        enabled=True,
        version=100,
    )
    feature_state_value_versioned = feature_state_versioned.feature_state_value
    feature_state_value_versioned.set_value("2005", "integer")
    feature_state_value_versioned.save()

    feature_state2 = feature2.feature_states.filter(environment=environment).first()
    feature_state2.enabled = True
    feature_state2.save()

    feature_state_value2 = feature_state2.feature_state_value
    feature_state_value2.set_value("true", "boolean")
    feature_state_value2.save()

    feature_state_value3 = (
        feature3.feature_states.filter(environment=environment)
        .first()
        .feature_state_value
    )
    feature_state_value3.set_value("present", "string")
    feature_state_value3.save()

    # This should be ignored due to identity being set.
    FeatureState.objects.create(
        feature=feature2,
        environment=environment,
        identity=identity,
    )

    # This should be ignored due to feature segment being set.
    FeatureState.objects.create(
        feature=feature2,
        environment=environment,
        feature_segment=feature_segment,
    )

    # Multivariate should be ignored.
    MultivariateFeatureOption.objects.create(
        feature=feature2,
        default_percentage_allocation=30,
        type=STRING,
        string_value="mv_feature_option1",
    )
    MultivariateFeatureOption.objects.create(
        feature=feature2,
        default_percentage_allocation=70,
        type=STRING,
        string_value="mv_feature_option2",
    )

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = f"{base_url}?environment={environment.id}"

    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    assert len(response.data["results"]) == 3
    results = response.data["results"]
    assert results[0]["environment_feature_state"]["enabled"] is True
    assert results[0]["environment_feature_state"]["id"] == feature_state_versioned.id
    assert results[0]["environment_feature_state"]["feature_state_value"] == 2005
    assert results[0]["name"] == feature.name
    assert results[1]["environment_feature_state"]["enabled"] is True
    assert results[1]["environment_feature_state"]["feature_state_value"] is True
    assert results[1]["name"] == feature2.name
    assert results[2]["environment_feature_state"]["enabled"] is False
    assert results[2]["environment_feature_state"]["feature_state_value"] == "present"
    assert results[2]["name"] == feature3.name


def test_list_features__value_search_string_and_int__returns_matching(
    staff_client: APIClient,
    staff_user: FFAdminUser,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    environment_v2_versioning: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    environment = environment_v2_versioning

    feature2 = Feature.objects.create(
        name="another_feature", project=project, initial_value="initial_value"
    )
    feature3 = Feature.objects.create(
        name="missing_feature", project=project, initial_value="gone"
    )
    feature4 = Feature.objects.create(
        name="fancy_feature", project=project, initial_value="fancy"
    )

    Environment.objects.create(
        name="Out of test scope environment",
        project=project,
    )

    environment_feature_version1 = EnvironmentFeatureVersion.objects.create(
        environment=environment,
        feature=feature,
    )

    feature_state1 = FeatureState.objects.filter(
        environment_feature_version=environment_feature_version1
    ).first()
    feature_state1.enabled = True
    feature_state1.save()

    # Create a secondary feature state that will be versioned in the past.
    environment_feature_version1b = EnvironmentFeatureVersion.objects.create(
        environment=environment,
        feature=feature,
    )

    feature_state1b = FeatureState.objects.filter(
        environment_feature_version=environment_feature_version1b
    ).first()
    feature_state1b.enabled = False
    feature_state1b.save()

    environment_feature_version1b.publish(staff_user)

    environment_feature_version1.publish(staff_user)

    feature_state_value1 = feature_state1.feature_state_value
    feature_state_value1.set_value("1945", "integer")
    feature_state_value1.save()

    feature_state2 = feature2.feature_states.filter(environment=environment).first()
    feature_state2.enabled = True
    feature_state2.save()

    feature_state_value2 = feature_state2.feature_state_value
    feature_state_value2.set_value("true", "boolean")
    feature_state_value2.save()

    feature_state_value3 = (
        feature3.feature_states.filter(environment=environment)
        .first()
        .feature_state_value
    )
    feature_state_value3.set_value("present", "string")
    feature_state_value3.save()

    feature_state4 = feature4.feature_states.filter(environment=environment).first()
    feature_state4.enabled = True
    feature_state4.save()

    feature_state_value4 = feature_state4.feature_state_value
    feature_state_value4.set_value("year 1945", "string")
    feature_state_value4.save()

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = f"{base_url}?environment={environment.id}&value_search=1945&is_enabled=true"

    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    # Only two features met the criteria.
    assert len(response.data["results"]) == 2
    features = {result["name"] for result in response.data["results"]}
    assert feature.name in features
    assert feature4.name in features


def test_list_features__value_search_boolean__returns_matching(
    staff_client: APIClient,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    environment: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    feature2 = Feature.objects.create(
        name="another_feature", project=project, initial_value="initial_value"
    )
    feature3 = Feature.objects.create(
        name="missing_feature", project=project, initial_value="gone"
    )
    feature4 = Feature.objects.create(
        name="fancy_feature", project=project, initial_value="fancy"
    )

    Environment.objects.create(
        name="Out of test scope environment",
        project=project,
    )

    feature_state1 = feature.feature_states.filter(environment=environment).first()
    feature_state1.enabled = True  # type: ignore[union-attr]
    feature_state1.save()  # type: ignore[union-attr]

    feature_state_value1 = feature_state1.feature_state_value  # type: ignore[union-attr]
    feature_state_value1.set_value("1945", "integer")
    feature_state_value1.save()

    feature_state2 = feature2.feature_states.filter(environment=environment).first()
    feature_state2.enabled = False
    feature_state2.save()

    feature_state_value2 = feature_state2.feature_state_value
    feature_state_value2.set_value("true", "boolean")
    feature_state_value2.save()

    feature_state_value3 = (
        feature3.feature_states.filter(environment=environment)
        .first()
        .feature_state_value
    )
    feature_state_value3.set_value("present", "string")
    feature_state_value3.save()

    feature_state4 = feature4.feature_states.filter(environment=environment).first()
    feature_state4.enabled = True
    feature_state4.save()

    feature_state_value4 = feature_state4.feature_state_value
    feature_state_value4.set_value("year 1945", "string")
    feature_state_value4.save()

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = f"{base_url}?environment={environment.id}&value_search=true&is_enabled=false"

    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    assert len(response.data["results"]) == 1
    assert response.data["results"][0]["name"] == feature2.name


def test_list_features__with_code_references__returns_counts(
    enable_features: EnableFeaturesFixture,
    feature: Feature,
    project: Project,
    staff_client: APIClient,
    with_project_permissions: WithProjectPermissionsCallable,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    enable_features("code_references_ui_stats")
    with freeze_time("2099-01-01T10:00:00-0300"):
        FeatureFlagCodeReferencesScan.objects.create(
            project=project,
            repository_url="https://github.flagsmith.com/backend/",
            revision="backend-1",
            code_references=[
                {
                    "feature_name": feature.name,
                    "file_path": "path/to/file.py",
                    "line_number": 42,
                },
            ],
        )
        FeatureFlagCodeReferencesScan.objects.create(
            project=project,
            repository_url="https://gitlab.flagsmith.com/frontend/",
            revision="frontend-1",
            code_references=[
                {
                    "feature_name": feature.name,
                    "file_path": "path/to/file.js",
                    "line_number": 23,
                },
            ],
        )
    with freeze_time("2099-01-02T11:00:00-0300"):
        FeatureFlagCodeReferencesScan.objects.create(
            project=project,
            repository_url="https://github.flagsmith.com/backend/",
            revision="backend-2",
            code_references=[
                {
                    "feature_name": f"Another {feature.name}",
                    "file_path": "path/to/another/file.py",
                    "line_number": 11,
                },
            ],
        )
        FeatureFlagCodeReferencesScan.objects.create(
            project=project,
            repository_url="https://gitlab.flagsmith.com/frontend/",
            revision="frontend-2",
            code_references=[
                {
                    "feature_name": feature.name,
                    "file_path": "path/to/file.js",
                    "line_number": 23,
                },
                {
                    "feature_name": feature.name,
                    "file_path": "path/to/another/file.js",
                    "line_number": 50,
                },
            ],
        )

    # When
    response = staff_client.get(f"/api/v1/projects/{project.pk}/features/")

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert response.json()["results"][0]["code_references_counts"] == [
        {
            "repository_url": "https://github.flagsmith.com/backend/",
            "count": 0,
            "last_successful_repository_scanned_at": "2099-01-02T14:00:00+00:00",
            "last_feature_found_at": "2099-01-01T13:00:00+00:00",
        },
        {
            "repository_url": "https://gitlab.flagsmith.com/frontend/",
            "count": 2,
            "last_successful_repository_scanned_at": "2099-01-02T14:00:00+00:00",
            "last_feature_found_at": "2099-01-02T14:00:00+00:00",
        },
    ]


@pytest.mark.usefixtures("feature")
def test_list_features__without_code_references__returns_empty_counts(
    enable_features: EnableFeaturesFixture,
    environment: Environment,
    project: Project,
    staff_client: APIClient,
    with_project_permissions: WithProjectPermissionsCallable,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    enable_features("code_references_ui_stats")

    # When
    response = staff_client.get(
        f"/api/v1/projects/{project.id}/features/?environment={environment.id}"
    )

    # Then
    assert response.status_code == 200
    results = response.json()["results"]
    assert len(results) == 1
    assert results[0]["code_references_counts"] == []


# TODO: Delete this after https://github.com/flagsmith/flagsmith/issues/6832 is resolved
def test_list_features__code_references_ui_stats_disabled__returns_empty_counts(
    enable_features: EnableFeaturesFixture,
    environment: Environment,
    feature: Feature,
    project: Project,
    staff_client: APIClient,
    with_project_permissions: WithProjectPermissionsCallable,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]
    enable_features()  # code_references_ui_stats not enabled
    FeatureFlagCodeReferencesScan.objects.create(
        project=project,
        repository_url="https://github.flagsmith.com/backend/",
        revision="rev-1",
        code_references=[
            {
                "feature_name": feature.name,
                "file_path": "path/to/file.py",
                "line_number": 42,
            },
        ],
    )

    # When
    response = staff_client.get(
        f"/api/v1/projects/{project.id}/features/?environment={environment.id}"
    )

    # Then
    assert response.status_code == 200
    results = response.json()["results"]
    assert len(results) == 1
    assert results[0]["code_references_counts"] == []


def test_list_feature_states__v2_versioning__returns_latest_versions(
    staff_client: APIClient,
    staff_user: FFAdminUser,
    with_environment_permissions: WithEnvironmentPermissionsCallable,
    environment_v2_versioning: Environment,
    feature: Feature,
    segment: Segment,
) -> None:
    # Given
    url = "%s?environment=%d" % (
        reverse("api-v1:features:featurestates-list"),
        environment_v2_versioning.id,
    )

    with_environment_permissions(  # type: ignore[call-arg]
        [VIEW_ENVIRONMENT], environment_id=environment_v2_versioning.id
    )

    # Let's create some new versions, with some segment overrides
    version_2 = EnvironmentFeatureVersion.objects.create(
        environment=environment_v2_versioning, feature=feature
    )
    feature_segment_v2 = FeatureSegment.objects.create(
        feature=feature,
        segment=segment,
        environment=environment_v2_versioning,
        environment_feature_version=version_2,
    )
    FeatureState.objects.create(
        feature_segment=feature_segment_v2,
        feature=feature,
        environment=environment_v2_versioning,
        environment_feature_version=version_2,
    )
    version_2.publish(staff_user)

    version_3 = EnvironmentFeatureVersion.objects.create(
        environment=environment_v2_versioning, feature=feature
    )
    version_3.publish(staff_user)

    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 2


@pytest.mark.skipif(
    settings.IS_RBAC_INSTALLED is True,
    reason="Skip this test if RBAC is installed",
)
@pytest.mark.freeze_time(two_hours_ago)
def test_list_features__last_modified_without_rbac__returns_expected(
    staff_client: APIClient,
    staff_user: FFAdminUser,
    environment_v2_versioning: Environment,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
) -> None:
    # Given / When
    # Then
    _assert_feature_list_last_modified_values(
        staff_client,
        staff_user,
        environment_v2_versioning,
        project,
        feature,
        with_project_permissions,
        django_assert_num_queries,
        num_queries=20,
    )


@pytest.mark.skipif(
    settings.IS_RBAC_INSTALLED is False,
    reason="Skip this test if RBAC is not installed",
)
@pytest.mark.freeze_time(two_hours_ago)
def test_list_features__last_modified_with_rbac__returns_expected(
    staff_client: APIClient,
    staff_user: FFAdminUser,
    environment_v2_versioning: Environment,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
) -> None:  # pragma: no cover
    # Given / When
    # Then
    _assert_feature_list_last_modified_values(
        staff_client,
        staff_user,
        environment_v2_versioning,
        project,
        feature,
        with_project_permissions,
        django_assert_num_queries,
        num_queries=21,
    )


def _assert_feature_list_last_modified_values(  # type: ignore[no-untyped-def]
    staff_client: APIClient,
    staff_user: FFAdminUser,
    environment_v2_versioning: Environment,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    django_assert_num_queries: DjangoAssertNumQueries,
    num_queries: int,
):
    # Given
    # another v2 versioning environment
    environment_v2_versioning_2 = Environment.objects.create(
        name="environment 2", project=project, use_v2_feature_versioning=True
    )

    url = "{base_url}?environment={environment_id}".format(
        base_url=reverse("api-v1:projects:project-features-list", args=[project.id]),
        environment_id=environment_v2_versioning.id,
    )

    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    with freeze_time(one_hour_ago):
        # create a new published version in another environment, simulated to be one hour ago
        environment_v2_versioning_2_version_2 = (
            EnvironmentFeatureVersion.objects.create(
                environment=environment_v2_versioning_2, feature=feature
            )
        )
        environment_v2_versioning_2_version_2.publish(staff_user)

    with freeze_time(now):
        # and create a new unpublished version in the current environment, simulated to be now
        # this shouldn't affect the values returned
        EnvironmentFeatureVersion.objects.create(
            environment=environment_v2_versioning, feature=feature
        )

    # let's add a few more features to ensure we aren't adding N+1 issues
    for i in range(2):
        Feature.objects.create(name=f"feature_{i}", project=project)

    # When
    with django_assert_num_queries(num_queries):  # TODO: reduce this number of queries!
        response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    response_json = response.json()
    assert response_json["count"] == 3

    feature_data = next(
        filter(lambda r: r["id"] == feature.id, response_json["results"])
    )
    assert feature_data["last_modified_in_any_environment"] == one_hour_ago.isoformat()
    assert (
        feature_data["last_modified_in_current_environment"]
        == two_hours_ago.isoformat()
    )


def test_list_features__owners_filter__returns_matching_features(
    staff_client: APIClient,
    staff_user: FFAdminUser,
    admin_user: FFAdminUser,
    project: Project,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    environment: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    feature2 = Feature.objects.create(
        name="included_feature", project=project, initial_value="initial_value"
    )
    Feature.objects.create(
        name="not_included_feature", project=project, initial_value="gone"
    )

    # Include admin only in the first feature.
    feature.owners.add(admin_user)

    # Include staff only in the second feature.
    feature2.owners.add(staff_user)

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # Search for both users in the owners query param.
    url = (
        f"{base_url}?environment={environment.id}&"
        f"owners={admin_user.id},{staff_user.id}"
    )
    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    assert len(response.data["results"]) == 2
    assert response.data["results"][0]["id"] == feature.id
    assert response.data["results"][1]["id"] == feature2.id


def test_list_features__group_owners_filter__returns_matching_features(
    staff_client: APIClient,
    project: Project,
    organisation: Organisation,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    environment: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    feature2 = Feature.objects.create(
        name="included_feature", project=project, initial_value="initial_value"
    )
    Feature.objects.create(
        name="not_included_feature", project=project, initial_value="gone"
    )

    group_1 = UserPermissionGroup.objects.create(
        name="Test Group", organisation=organisation
    )
    group_2 = UserPermissionGroup.objects.create(
        name="Second Group", organisation=organisation
    )

    feature.group_owners.add(group_1)
    feature2.group_owners.add(group_2)

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # Search for both users in the owners query param.
    url = (
        f"{base_url}?environment={environment.id}&"
        f"group_owners={group_1.id},{group_2.id}"
    )
    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    assert len(response.data["results"]) == 2
    assert response.data["results"][0]["id"] == feature.id
    assert response.data["results"][1]["id"] == feature2.id


def test_list_features__owners_and_group_owners_filter__returns_matching(
    staff_client: APIClient,
    staff_user: FFAdminUser,
    project: Project,
    organisation: Organisation,
    feature: Feature,
    with_project_permissions: WithProjectPermissionsCallable,
    environment: Environment,
) -> None:
    # Given
    with_project_permissions([VIEW_PROJECT])  # type: ignore[call-arg]

    feature2 = Feature.objects.create(
        name="included_feature", project=project, initial_value="initial_value"
    )
    Feature.objects.create(
        name="not_included_feature", project=project, initial_value="gone"
    )

    group_1 = UserPermissionGroup.objects.create(
        name="Test Group", organisation=organisation
    )

    feature.group_owners.add(group_1)
    feature2.owners.add(staff_user)

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # Search for both users in the owners query param.
    url = (
        f"{base_url}?environment={environment.id}&"
        f"group_owners={group_1.id}&owners={staff_user.id}"
    )
    # When
    response = staff_client.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK

    assert len(response.data["results"]) == 2
    assert response.data["results"][0]["id"] == feature.id
    assert response.data["results"][1]["id"] == feature2.id


def test_delete_feature__dynamo_identity_overrides__deletes_overrides(
    flagsmith_environments_v2_table: "Table",
    flagsmith_identities_table: "Table",
    dynamodb_identity_wrapper: DynamoIdentityWrapper,
    dynamodb_wrapper_v2: DynamoEnvironmentV2Wrapper,
    environment: Environment,
    feature: Feature,
    identity_featurestate: FeatureState,
    identity: Identity,
    admin_client_new: APIClient,
) -> None:
    # Given
    engine_identity = map_identity_to_engine(identity, with_overrides=True)
    dynamodb_identity_wrapper.put_item(
        map_engine_identity_to_identity_document(engine_identity)
    )
    dynamodb_wrapper_v2.write_environments(environments=[environment])
    flagsmith_environments_v2_table.put_item(
        Item=map_identity_override_to_identity_override_document(
            map_engine_feature_state_to_identity_override(
                feature_state=engine_identity.identity_features[0],
                identity_uuid=str(engine_identity.identity_uuid),
                identifier=engine_identity.identifier,
                environment_api_key=environment.api_key,
                environment_id=environment.id,
            ),
        )
    )

    feature.project.enable_dynamo_db = True
    feature.project.save()

    delete_feature_url = reverse(
        "api-v1:projects:project-features-detail", args=[feature.project_id, feature.id]
    )

    # When
    delete_feature_response = admin_client_new.delete(delete_feature_url)

    # Then
    assert delete_feature_response.status_code == status.HTTP_204_NO_CONTENT

    assert (
        flagsmith_environments_v2_table.query(
            KeyConditionExpression=dynamodb_wrapper_v2.get_identity_overrides_key_condition_expression(  # type: ignore[arg-type]  # noqa: E501
                environment_id=environment.id, feature_id=feature.id
            )
        )["Count"]
        == 0
    )


def test_get_multivariate_options__existing_feature__returns_control_and_options(
    api_client: APIClient,
    environment: Environment,
    multivariate_feature: Feature,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)

    mv_options = list(multivariate_feature.multivariate_options.all())
    expected_option_values = [opt.string_value for opt in mv_options]

    # When
    response = api_client.get(
        f"/api/v1/flags/{multivariate_feature.id}/multivariate-options/"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK
    data = response.json()
    assert data["control_value"] == "control"
    assert len(data["options"]) == 3

    actual_option_values = [opt["value"] for opt in data["options"]]
    for expected_value in expected_option_values:
        assert expected_value in actual_option_values


def test_get_multivariate_options__nonexistent_feature__returns_404(
    api_client: APIClient,
    environment: Environment,
) -> None:
    # Given
    api_client.credentials(HTTP_X_ENVIRONMENT_KEY=environment.api_key)
    non_existent_feature_id = 99999

    # When
    response = api_client.get(
        f"/api/v1/flags/{non_existent_feature_id}/multivariate-options/"
    )

    # Then
    assert response.status_code == status.HTTP_404_NOT_FOUND


def test_list_features__valid_segment_query_param__returns_segment_override(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
    environment: Environment,
    segment: Segment,
) -> None:
    # Given
    feature_segment = FeatureSegment.objects.create(
        feature=feature,
        segment=segment,
        environment=environment,
    )
    segment_override = FeatureState.objects.create(
        feature=feature,
        feature_segment=feature_segment,
        environment=environment,
        enabled=True,
    )
    segment_override.feature_state_value.set_value("segment_value", "string")
    segment_override.feature_state_value.save()

    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    url = f"{base_url}?environment={environment.id}&segment={segment.id}"

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    response_json = response.json()
    feature_data = next(
        filter(lambda r: r["id"] == feature.id, response_json["results"])
    )

    assert "environment_feature_state" in feature_data
    segment_state = feature_data["segment_feature_state"]

    assert segment_state is not None
    assert segment_state["id"] == segment_override.id
    assert segment_state["feature_state_value"] == "segment_value"
    assert segment_state["enabled"] is True


def test_list_features__invalid_segment_query_param__returns_null_segment_state(
    admin_client_new: APIClient,
    project: Project,
    feature: Feature,
    environment: Environment,
    segment: Segment,
) -> None:
    # Given
    base_url = reverse("api-v1:projects:project-features-list", args=[project.id])
    invalid_segment_id = segment.id + 9999
    url = f"{base_url}?environment={environment.id}&segment={invalid_segment_id}"

    # When
    response = admin_client_new.get(url)

    # Then
    assert response.status_code == status.HTTP_200_OK
    response_json = response.json()
    feature_data = next(
        filter(lambda r: r["id"] == feature.id, response_json["results"])
    )

    assert "segment_feature_state" in feature_data
    assert feature_data["segment_feature_state"] is None


@pytest.mark.parametrize("sort_field", ["name", "created_date"])
def test_list_features__segment_query__sorts_by_field_with_overrides_first(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    segment: Segment,
    sort_field: str,
) -> None:
    # Given
    Feature.objects.create(project=project, name="feature_a")
    feature_b = Feature.objects.create(project=project, name="feature_b")
    feature_c = Feature.objects.create(project=project, name="feature_c")
    other_environment = Environment.objects.create(
        project=project, name="other_environment"
    )

    # feature_c has a segment override in the requested environment
    FeatureSegment.objects.create(
        feature=feature_c, segment=segment, environment=environment
    )
    # feature_b has a segment override in a different environment
    FeatureSegment.objects.create(
        feature=feature_b, segment=segment, environment=other_environment
    )

    # When
    response = admin_client_new.get(
        f"/api/v1/projects/{project.id}/features/"
        f"?environment={environment.id}"
        f"&segment={segment.id}"
        f"&sort_field={sort_field}&sort_direction=ASC"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert ["feature_c", "feature_a", "feature_b"] == [
        f["name"] for f in response.json()["results"]
    ]


@pytest.mark.parametrize("sort_field", ["name", "created_date"])
def test_list_features__identity_query__sorts_by_field_with_overrides_first(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    identity: Identity,
    sort_field: str,
) -> None:
    # Given
    Feature.objects.create(project=project, name="feature_a")
    Feature.objects.create(project=project, name="feature_b")
    feature_c = Feature.objects.create(project=project, name="feature_c")

    # feature_c has an identity override
    FeatureState.objects.create(
        feature=feature_c, environment=environment, identity=identity
    )

    # When
    response = admin_client_new.get(
        f"/api/v1/projects/{project.id}/features/"
        f"?environment={environment.id}"
        f"&identity={identity.id}"
        f"&sort_field={sort_field}&sort_direction=ASC"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert ["feature_c", "feature_a", "feature_b"] == [
        f["name"] for f in response.json()["results"]
    ]


@pytest.mark.parametrize("sort_field", ["name", "created_date"])
def test_list_features__edge_identity_query__sorts_by_field_with_overrides_first(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    sort_field: str,
    mocker: MockerFixture,
) -> None:
    # Given
    project.enable_dynamo_db = True
    project.save()

    Feature.objects.create(project=project, name="feature_a")
    feature_b = Feature.objects.create(project=project, name="feature_b")
    Feature.objects.create(project=project, name="feature_c")
    mocker.patch.object(
        views,
        "get_overridden_feature_ids_for_edge_identity",
        return_value={feature_b.id},
    )

    # When
    response = admin_client_new.get(
        f"/api/v1/projects/{project.id}/features/"
        f"?environment={environment.id}"
        f"&identity=59efa2a7-6a45-46d6-b953-a7073a90eacf"
        f"&sort_field={sort_field}&sort_direction=ASC"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert ["feature_b", "feature_a", "feature_c"] == [
        f["name"] for f in response.json()["results"]
    ]


@pytest.mark.parametrize(
    "enable_dynamo_db, identity_value",
    [
        (False, "not-an-integer"),
        (True, "0"),
    ],
)
def test_list_features__identity_query_invalid_format__returns_400(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    enable_dynamo_db: bool,
    identity_value: str,
) -> None:
    # Given
    project.enable_dynamo_db = enable_dynamo_db
    project.save()

    # When
    response = admin_client_new.get(
        f"/api/v1/projects/{project.id}/features/"
        f"?environment={environment.id}"
        f"&identity={identity_value}"
    )

    # Then
    assert response.status_code == status.HTTP_400_BAD_REQUEST


def test_list_features__edge_identity_nonexistent__returns_features_unsorted(
    admin_client_new: APIClient,
    project: Project,
    environment: Environment,
    mocker: MockerFixture,
) -> None:
    # Given
    project.enable_dynamo_db = True
    project.save()
    Feature.objects.create(project=project, name="feature_a")
    Feature.objects.create(project=project, name="feature_b")
    Feature.objects.create(project=project, name="feature_c")
    mocker.patch.object(
        views,
        "get_overridden_feature_ids_for_edge_identity",
        return_value=set(),
    )

    # When
    response = admin_client_new.get(
        f"/api/v1/projects/{project.id}/features/"
        f"?environment={environment.id}"
        f"&identity=59efa2a7-6a45-46d6-b953-a7073a90eacf"
        f"&sort_field=name&sort_direction=ASC"
    )

    # Then
    assert response.status_code == status.HTTP_200_OK
    assert ["feature_a", "feature_b", "feature_c"] == [
        f["name"] for f in response.json()["results"]
    ]


def test_create_feature__duplicate_metadata_id__keeps_metadata_isolated(
    admin_client_new: APIClient,
    project: Project,
    optional_b_feature_metadata_field: MetadataModelField,
) -> None:
    """
    Test that creating multiple features with metadata keeps metadata properly isolated.
    This is a regression test for the bug where creating a second feature would remove
    metadata from the first feature if the user sent the first feature's metadata ID.
    """
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # Create first feature with metadata
    first_feature_data = {
        "name": "First Feature",
        "description": "First feature description",
        "metadata": [
            {
                "model_field": optional_b_feature_metadata_field.id,
                "field_value": "100",
            },
        ],
    }

    # When - Create first feature
    first_response = admin_client_new.post(
        url, data=json.dumps(first_feature_data), content_type="application/json"
    )

    # Then - First feature should be created successfully
    assert first_response.status_code == status.HTTP_201_CREATED
    first_feature_id = first_response.json()["id"]
    first_metadata = first_response.json()["metadata"]
    assert len(first_metadata) == 1
    assert first_metadata[0]["field_value"] == "100"
    first_metadata_id = first_metadata[0]["id"]

    # Given - Create second feature
    second_feature_data = {
        "name": "Second Feature",
        "description": "Second feature description",
        "metadata": [
            {
                "id": first_metadata_id,  # user mistakenly sends existing metadata ID
                "model_field": optional_b_feature_metadata_field.id,
                "field_value": "200",
            },
        ],
    }

    # When - Create second feature
    second_response = admin_client_new.post(
        url, data=json.dumps(second_feature_data), content_type="application/json"
    )

    # Then - Second feature should be created successfully
    assert second_response.status_code == status.HTTP_201_CREATED
    second_feature_id = second_response.json()["id"]
    second_metadata = second_response.json()["metadata"]
    assert len(second_metadata) == 1
    assert second_metadata[0]["field_value"] == "200"
    # The metadata ID should be different (new metadata instance created)
    assert second_metadata[0]["id"] != first_metadata_id

    # When - Retrieve first feature to verify metadata is still there
    first_feature_url = reverse(
        "api-v1:projects:project-features-detail", args=[project.id, first_feature_id]
    )
    first_feature_check = admin_client_new.get(first_feature_url)

    # Then - First feature should still have its metadata
    assert first_feature_check.status_code == status.HTTP_200_OK
    first_feature_metadata_after = first_feature_check.json()["metadata"]
    assert len(first_feature_metadata_after) == 1
    assert first_feature_metadata_after[0]["field_value"] == "100"
    assert first_feature_metadata_after[0]["id"] == first_metadata_id

    # When - Retrieve second feature to verify metadata
    second_feature_url = reverse(
        "api-v1:projects:project-features-detail",
        args=[project.id, second_feature_id],
    )
    second_feature_check = admin_client_new.get(second_feature_url)

    # Then - Second feature should have its own metadata
    assert second_feature_check.status_code == status.HTTP_200_OK
    second_feature_metadata_after = second_feature_check.json()["metadata"]
    assert len(second_feature_metadata_after) == 1
    assert second_feature_metadata_after[0]["field_value"] == "200"


def test_create_feature__required_metadata_on_other_project__returns_201(
    admin_client: APIClient,
    project: Project,
    project_b: Project,
    organisation: Organisation,
    a_metadata_field: MetadataField,
    feature_content_type: ContentType,
    project_content_type: ContentType,
) -> None:
    # Given
    model_field = MetadataModelField.objects.create(
        field=a_metadata_field,
        content_type=feature_content_type,
    )
    MetadataModelFieldRequirement.objects.create(
        content_type=project_content_type,
        object_id=project_b.id,
        model_field=model_field,
    )
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {"name": "Test feature cross project", "description": "desc"}

    # When
    response = admin_client.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED


def test_list_features__edge_v2_project__makes_one_dynamo_query(
    admin_client_new: APIClient,
    dynamo_enabled_project_environment_one: Environment,
    environment: Environment,
    feature: Feature,
    mocker: MockerFixture,
) -> None:
    # Given
    environment = dynamo_enabled_project_environment_one
    project = environment.project

    # Create two additional features so we have 3 in total (including the fixture feature).
    Feature.objects.create(name="feature_2", project=project)
    Feature.objects.create(name="feature_3", project=project)

    # Inject a mock DynamoDB table directly on the wrapper so we can
    # verify the number of queries made.
    mock_table = mocker.MagicMock()
    mock_table.query.return_value = {"Items": [], "Count": 0}

    from edge_api.identities import edge_identity_service

    mocker.patch.object(
        edge_identity_service.ddb_environment_v2_wrapper,
        "_table",
        mock_table,
    )

    url = reverse("api-v1:projects:project-features-list", args=[project.id])

    # When
    response = admin_client_new.get(f"{url}?environment={environment.id}")

    # Then
    assert response.status_code == status.HTTP_200_OK

    # Validate that only a single query is made to dynamodb, not one
    # per feature.
    assert mock_table.query.call_count == 1


@pytest.mark.parametrize(
    "feature_type, expected_status",
    [
        (STANDARD, status.HTTP_201_CREATED),
        (MULTIVARIATE, status.HTTP_201_CREATED),
        ("boolean", status.HTTP_400_BAD_REQUEST),
        ("FLAG", status.HTTP_400_BAD_REQUEST),
    ],
)
def test_create_feature__type_provided__validates_and_sets_type(
    admin_client_new: APIClient,
    project: Project,
    feature_type: str,
    expected_status: int,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {"name": f"test_feature_{feature_type}", "type": feature_type}

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == expected_status
    if expected_status == status.HTTP_201_CREATED:
        assert response.json()["type"] == feature_type


def test_create_feature__multivariate_options_provided__sets_type_to_multivariate(
    admin_client_new: APIClient,
    project: Project,
) -> None:
    # Given
    url = reverse("api-v1:projects:project-features-list", args=[project.id])
    data = {
        "name": "test_feature_mv_type",
        "multivariate_options": [{"type": "unicode", "string_value": "option-a"}],
    }

    # When
    response = admin_client_new.post(
        url, data=json.dumps(data), content_type="application/json"
    )

    # Then
    assert response.status_code == status.HTTP_201_CREATED
    assert response.json()["type"] == MULTIVARIATE