{
  "EndpointCoverage": [
    {
      "Endpoint": "api/Auth/login",
      "Controller": "Auth",
      "Action": "Login",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/bot/messages/pending",
      "Controller": "BotMessages",
      "Action": "GetPendingMessages",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/bot/messages/{id}/mark-sent",
      "Controller": "BotMessages",
      "Action": "MarkMessageAsSent",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/bot/messages/{id}/mark-failed",
      "Controller": "BotMessages",
      "Action": "MarkMessageAsFailed",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/bot/messages/test-create",
      "Controller": "BotMessages",
      "Action": "CreateTestMessage",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/bot/messages/customer-create",
      "Controller": "BotMessages",
      "Action": "CreateCustomerMessage",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/bot/messages/customer/{customerId}",
      "Controller": "BotMessages",
      "Action": "GetCustomerMessages",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/register",
      "Controller": "Bots",
      "Action": "RegisterBot",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/authenticate",
      "Controller": "Bots",
      "Action": "AuthenticateBot",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/settings",
      "Controller": "Bots",
      "Action": "GetBotSettings",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Bots/settings",
      "Controller": "Bots",
      "Action": "UpdateBotSettings",
      "HttpMethods": [
        "PUT"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/heartbeat",
      "Controller": "Bots",
      "Action": "RecordHeartbeat",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/platform-info",
      "Controller": "Bots",
      "Action": "UpdatePlatformInfo",
      "HttpMethods": [
        "PUT"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/metrics",
      "Controller": "Bots",
      "Action": "RecordMetric",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/metrics/batch",
      "Controller": "Bots",
      "Action": "RecordMetricsBatch",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/sessions/start",
      "Controller": "Bots",
      "Action": "StartSession",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/sessions/{sessionId}",
      "Controller": "Bots",
      "Action": "UpdateSession",
      "HttpMethods": [
        "PUT"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/sessions/{sessionId}/end",
      "Controller": "Bots",
      "Action": "EndSession",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/GetAllBots",
      "Controller": "Bots",
      "Action": "GetAllBots",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Bots/{id}",
      "Controller": "Bots",
      "Action": "GetBot",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Bots/{id}/metrics",
      "Controller": "Bots",
      "Action": "GetBotMetrics",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "Controller": "Bots",
      "Action": "GetMetricsSummary",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Bots/{id}/sessions",
      "Controller": "Bots",
      "Action": "GetBotSessions",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Bots/{id}",
      "Controller": "Bots",
      "Action": "DeleteBot",
      "HttpMethods": [
        "DELETE"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Catalog/categories",
      "Controller": "Catalog",
      "Action": "GetCategories",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Catalog/categories/{id}",
      "Controller": "Catalog",
      "Action": "GetCategory",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Catalog/products",
      "Controller": "Catalog",
      "Action": "GetProducts",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Catalog/products/{id}",
      "Controller": "Catalog",
      "Action": "GetProduct",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Customers/GetCustomers",
      "Controller": "Customers",
      "Action": "GetCustomers",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Customers/{id}",
      "Controller": "Customers",
      "Action": "GetCustomer",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/by-telegram/{telegramUserId}",
      "Controller": "Customers",
      "Action": "GetCustomerByTelegramId",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/CreateCustomer",
      "Controller": "Customers",
      "Action": "CreateCustomer",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/get-or-create",
      "Controller": "Customers",
      "Action": "GetOrCreateCustomer",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test",
        "State-Dependent Content Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/{id}",
      "Controller": "Customers",
      "Action": "UpdateCustomer",
      "HttpMethods": [
        "PUT"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/{id}/block",
      "Controller": "Customers",
      "Action": "BlockCustomer",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/{id}/unblock",
      "Controller": "Customers",
      "Action": "UnblockCustomer",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Customers/{id}",
      "Controller": "Customers",
      "Action": "DeleteCustomer",
      "HttpMethods": [
        "DELETE"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Home/Index",
      "Controller": "Home",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Messages/SendMessage",
      "Controller": "Messages",
      "Action": "SendMessage",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Messages/{id}",
      "Controller": "Messages",
      "Action": "GetMessage",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Messages/customer/{customerId}",
      "Controller": "Messages",
      "Action": "GetCustomerMessages",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Messages/order/{orderId}",
      "Controller": "Messages",
      "Action": "GetOrderMessages",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Messages/pending",
      "Controller": "Messages",
      "Action": "GetPendingMessages",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Messages/{id}/mark-sent",
      "Controller": "Messages",
      "Action": "MarkMessageAsSent",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Messages/{id}/mark-delivered",
      "Controller": "Messages",
      "Action": "MarkMessageAsDelivered",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Messages/{id}/mark-failed",
      "Controller": "Messages",
      "Action": "MarkMessageAsFailed",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Orders/GetAllOrders",
      "Controller": "Orders",
      "Action": "GetAllOrders",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Orders/{id}",
      "Controller": "Orders",
      "Action": "GetOrder",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Orders/{id}/status",
      "Controller": "Orders",
      "Action": "UpdateOrderStatus",
      "HttpMethods": [
        "PUT"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [
        "Admin"
      ],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test",
        "Role-Based Authorization Test"
      ],
      "CoveragePercentage": 0
    },
    {
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "Controller": "Orders",
      "Action": "GetOrdersByIdentity",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test",
        "State-Dependent Content Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "Controller": "Orders",
      "Action": "GetOrdersByCustomerId",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test",
        "State-Dependent Content Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "Controller": "Orders",
      "Action": "GetOrderByIdentity",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test",
        "State-Dependent Content Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/CreateOrder",
      "Controller": "Orders",
      "Action": "CreateOrder",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test",
        "State-Dependent Content Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/{id}/payments",
      "Controller": "Orders",
      "Action": "CreatePayment",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test",
        "State-Dependent Content Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/{id}/payments",
      "Controller": "Orders",
      "Action": "GetOrderPayments",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/payments/{paymentId}/status",
      "Controller": "Orders",
      "Action": "GetPaymentStatus",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/{id}/cancel",
      "Controller": "Orders",
      "Action": "CancelOrder",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/payments/webhook",
      "Controller": "Orders",
      "Action": "PaymentWebhook",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Test/create-product",
      "Controller": "Test",
      "Action": "CreateTestProduct",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Test/setup-test-data",
      "Controller": "Test",
      "Action": "SetupTestData",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Account/Login",
      "Controller": "Account",
      "Action": "Login",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Account/Login",
      "Controller": "Account",
      "Action": "Login",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 20
    },
    {
      "Endpoint": "api/Account/Logout",
      "Controller": "Account",
      "Action": "Logout",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Account/AccessDenied",
      "Controller": "Account",
      "Action": "AccessDenied",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Anonymous"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [],
      "CoveragePercentage": 40
    },
    {
      "Endpoint": "api/Bots/Index",
      "Controller": "Bots",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Bots/Details",
      "Controller": "Bots",
      "Action": "Details",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Create",
      "Controller": "Bots",
      "Action": "Create",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Bots/Wizard",
      "Controller": "Bots",
      "Action": "Wizard",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Bots/Wizard",
      "Controller": "Bots",
      "Action": "Wizard",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/CompleteWizard",
      "Controller": "Bots",
      "Action": "CompleteWizard",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Create",
      "Controller": "Bots",
      "Action": "Create",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Edit",
      "Controller": "Bots",
      "Action": "Edit",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Edit",
      "Controller": "Bots",
      "Action": "Edit",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Metrics",
      "Controller": "Bots",
      "Action": "Metrics",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Delete",
      "Controller": "Bots",
      "Action": "Delete",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Suspend",
      "Controller": "Bots",
      "Action": "Suspend",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/Activate",
      "Controller": "Bots",
      "Action": "Activate",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Bots/RegenerateKey",
      "Controller": "Bots",
      "Action": "RegenerateKey",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Categories/Index",
      "Controller": "Categories",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Categories/Create",
      "Controller": "Categories",
      "Action": "Create",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Categories/Create",
      "Controller": "Categories",
      "Action": "Create",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Categories/Edit",
      "Controller": "Categories",
      "Action": "Edit",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Categories/Edit",
      "Controller": "Categories",
      "Action": "Edit",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Categories/Delete",
      "Controller": "Categories",
      "Action": "Delete",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Dashboard/Index",
      "Controller": "Dashboard",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Messages/Index",
      "Controller": "Messages",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Messages/Customer",
      "Controller": "Messages",
      "Action": "Customer",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Messages/Reply",
      "Controller": "Messages",
      "Action": "Reply",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/Index",
      "Controller": "Orders",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Orders/Details",
      "Controller": "Orders",
      "Action": "Details",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/Create",
      "Controller": "Orders",
      "Action": "Create",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Orders/Create",
      "Controller": "Orders",
      "Action": "Create",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/Edit",
      "Controller": "Orders",
      "Action": "Edit",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/Edit",
      "Controller": "Orders",
      "Action": "Edit",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Orders/UpdateStatus",
      "Controller": "Orders",
      "Action": "UpdateStatus",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Products/Index",
      "Controller": "Products",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Products/Create",
      "Controller": "Products",
      "Action": "Create",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Products/Create",
      "Controller": "Products",
      "Action": "Create",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Products/Edit",
      "Controller": "Products",
      "Action": "Edit",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Products/Edit",
      "Controller": "Products",
      "Action": "Edit",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Products/UploadPhoto",
      "Controller": "Products",
      "Action": "UploadPhoto",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Products/DeletePhoto",
      "Controller": "Products",
      "Action": "DeletePhoto",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Products/Delete",
      "Controller": "Products",
      "Action": "Delete",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/ShippingRates/Index",
      "Controller": "ShippingRates",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/ShippingRates/Create",
      "Controller": "ShippingRates",
      "Action": "Create",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/ShippingRates/Create",
      "Controller": "ShippingRates",
      "Action": "Create",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/ShippingRates/Edit",
      "Controller": "ShippingRates",
      "Action": "Edit",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/ShippingRates/Edit",
      "Controller": "ShippingRates",
      "Action": "Edit",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/ShippingRates/Delete",
      "Controller": "ShippingRates",
      "Action": "Delete",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Users/Index",
      "Controller": "Users",
      "Action": "Index",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Users/Create",
      "Controller": "Users",
      "Action": "Create",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test"
      ],
      "CoveragePercentage": 30.000000000000004
    },
    {
      "Endpoint": "api/Users/Create",
      "Controller": "Users",
      "Action": "Create",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Users/Edit",
      "Controller": "Users",
      "Action": "Edit",
      "HttpMethods": [
        "GET"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Users/Edit",
      "Controller": "Users",
      "Action": "Edit",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    },
    {
      "Endpoint": "api/Users/Delete",
      "Controller": "Users",
      "Action": "Delete",
      "HttpMethods": [
        "POST"
      ],
      "TestedStates": [],
      "UntestedStates": [
        "Authenticated"
      ],
      "HasUnauthorizedTest": false,
      "HasValidDataTest": false,
      "HasInvalidDataTest": false,
      "HasRoleBasedTests": false,
      "RequiredRoles": [],
      "MissingTestTypes": [
        "Unauthorized Access Test",
        "Valid Data Test",
        "Invalid Data Test"
      ],
      "CoveragePercentage": 10
    }
  ],
  "AuthenticationScenarios": [
    {
      "ScenarioName": "Login Flow",
      "FromState": "Anonymous",
      "ToState": "Authenticated",
      "RequiredEndpoints": [
        "AuthController/Login"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Anonymous to Authenticated via login endpoint"
    },
    {
      "ScenarioName": "Register Flow",
      "FromState": "Anonymous",
      "ToState": "Authenticated",
      "RequiredEndpoints": [
        "BotsController/RegisterBot"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Anonymous to Authenticated via registration endpoint"
    },
    {
      "ScenarioName": "Login Flow",
      "FromState": "Anonymous",
      "ToState": "Authenticated",
      "RequiredEndpoints": [
        "BotsController/AuthenticateBot"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Anonymous to Authenticated via login endpoint"
    },
    {
      "ScenarioName": "Login Flow",
      "FromState": "Anonymous",
      "ToState": "Authenticated",
      "RequiredEndpoints": [
        "AccountController/Login"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Anonymous to Authenticated via login endpoint"
    },
    {
      "ScenarioName": "Login Flow",
      "FromState": "Anonymous",
      "ToState": "Authenticated",
      "RequiredEndpoints": [
        "AccountController/Login"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Anonymous to Authenticated via login endpoint"
    },
    {
      "ScenarioName": "Logout Flow",
      "FromState": "Authenticated",
      "ToState": "Anonymous",
      "RequiredEndpoints": [
        "AccountController/Logout"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Authenticated to Anonymous via logout endpoint"
    },
    {
      "ScenarioName": "Logout Flow",
      "FromState": "Authenticated_Admin",
      "ToState": "Anonymous",
      "RequiredEndpoints": [
        "AccountController/Logout"
      ],
      "IsTested": false,
      "TestDescription": "User should be able to transition from Authenticated_Admin to Anonymous via logout endpoint"
    },
    {
      "ScenarioName": "Session Timeout",
      "FromState": "Authenticated",
      "ToState": "Anonymous",
      "RequiredEndpoints": [],
      "IsTested": false,
      "TestDescription": "Verify that expired sessions are handled correctly and user is redirected to login"
    },
    {
      "ScenarioName": "Concurrent Sessions",
      "FromState": "Authenticated",
      "ToState": "Authenticated",
      "RequiredEndpoints": [],
      "IsTested": false,
      "TestDescription": "Test behavior when same user logs in from multiple locations"
    },
    {
      "ScenarioName": "Role Switching",
      "FromState": "Authenticated_User",
      "ToState": "Authenticated_Admin",
      "RequiredEndpoints": [],
      "IsTested": false,
      "TestDescription": "Verify that role changes are reflected in endpoint accessibility"
    }
  ],
  "IdentifiedGaps": [
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Auth/login",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/bot/messages/pending",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/bot/messages/{id}/mark-sent",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/bot/messages/{id}/mark-failed",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/bot/messages/test-create",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/bot/messages/customer-create",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/bot/messages/customer/{customerId}",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/register",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/authenticate",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/settings",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/settings",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/heartbeat",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/platform-info",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/metrics",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/metrics/batch",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/sessions/start",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/sessions/{sessionId}",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/sessions/{sessionId}/end",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/GetAllBots",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Bots/GetAllBots",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/{id}",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Bots/{id}",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/{id}/metrics",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Bots/{id}/metrics",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/{id}/sessions",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Bots/{id}/sessions",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/{id}",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Bots/{id}",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Catalog/categories",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Catalog/categories/{id}",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Catalog/products",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Catalog/products/{id}",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/GetCustomers",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/{id}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/by-telegram/{telegramUserId}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/CreateCustomer",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/get-or-create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "State-Dependent Logic",
      "Endpoint": "api/Customers/get-or-create",
      "Description": "Endpoint may show different content based on authentication state",
      "Severity": "Warning",
      "Recommendation": "Test endpoint with different authentication states to verify content differences",
      "AffectedStates": [
        "Anonymous",
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/{id}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/{id}/block",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/{id}/unblock",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Customers/{id}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Home/Index",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/SendMessage",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/{id}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/customer/{customerId}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/order/{orderId}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/pending",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/{id}/mark-sent",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/{id}/mark-delivered",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/{id}/mark-failed",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/GetAllOrders",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Orders/GetAllOrders",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/{id}",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Orders/{id}",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/{id}/status",
      "Description": "Endpoint has only 0.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated",
        "Authenticated_Admin"
      ]
    },
    {
      "GapType": "Missing Authorization Test",
      "Endpoint": "api/Orders/{id}/status",
      "Description": "Protected endpoint lacks unauthorized access test",
      "Severity": "Critical",
      "Recommendation": "Add test to verify 401/403 response for unauthorized access",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "State-Dependent Logic",
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "Description": "Endpoint may show different content based on authentication state",
      "Severity": "Warning",
      "Recommendation": "Test endpoint with different authentication states to verify content differences",
      "AffectedStates": [
        "Anonymous",
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "State-Dependent Logic",
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "Description": "Endpoint may show different content based on authentication state",
      "Severity": "Warning",
      "Recommendation": "Test endpoint with different authentication states to verify content differences",
      "AffectedStates": [
        "Anonymous",
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "State-Dependent Logic",
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "Description": "Endpoint may show different content based on authentication state",
      "Severity": "Warning",
      "Recommendation": "Test endpoint with different authentication states to verify content differences",
      "AffectedStates": [
        "Anonymous",
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/CreateOrder",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "State-Dependent Logic",
      "Endpoint": "api/Orders/CreateOrder",
      "Description": "Endpoint may show different content based on authentication state",
      "Severity": "Warning",
      "Recommendation": "Test endpoint with different authentication states to verify content differences",
      "AffectedStates": [
        "Anonymous",
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/{id}/payments",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "State-Dependent Logic",
      "Endpoint": "api/Orders/{id}/payments",
      "Description": "Endpoint may show different content based on authentication state",
      "Severity": "Warning",
      "Recommendation": "Test endpoint with different authentication states to verify content differences",
      "AffectedStates": [
        "Anonymous",
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/{id}/payments",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/payments/{paymentId}/status",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/{id}/cancel",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/payments/webhook",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Test/create-product",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Test/setup-test-data",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Account/Login",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Account/Login",
      "Description": "Endpoint has only 20.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Account/Logout",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Account/AccessDenied",
      "Description": "Endpoint has only 40.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Anonymous"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Details",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Create",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Wizard",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Wizard",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/CompleteWizard",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Metrics",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Delete",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Suspend",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/Activate",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Bots/RegenerateKey",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Categories/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Categories/Create",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Categories/Create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Categories/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Categories/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Categories/Delete",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Dashboard/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/Customer",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Messages/Reply",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/Details",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/Create",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/Create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Orders/UpdateStatus",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/Create",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/Create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/UploadPhoto",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/DeletePhoto",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Products/Delete",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/ShippingRates/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/ShippingRates/Create",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/ShippingRates/Create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/ShippingRates/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/ShippingRates/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/ShippingRates/Delete",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Users/Index",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Users/Create",
      "Description": "Endpoint has only 30.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Users/Create",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Users/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Users/Edit",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Low Coverage",
      "Endpoint": "api/Users/Delete",
      "Description": "Endpoint has only 10.0% test coverage",
      "Severity": "Critical",
      "Recommendation": "Implement comprehensive test suite covering all authentication states and data scenarios",
      "AffectedStates": [
        "Authenticated"
      ]
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Auth/login",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/bot/messages/{id}/mark-sent",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/bot/messages/{id}/mark-failed",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/bot/messages/test-create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/bot/messages/customer-create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/bot/messages/customer/{customerId}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/register",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/authenticate",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/settings",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/heartbeat",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/platform-info",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/metrics",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/metrics/batch",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/sessions/start",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/sessions/{sessionId}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/sessions/{sessionId}/end",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/{id}/metrics",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/{id}/sessions",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Catalog/categories/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Catalog/products/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/by-telegram/{telegramUserId}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/CreateCustomer",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/get-or-create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/{id}/block",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/{id}/unblock",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/SendMessage",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/customer/{customerId}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/order/{orderId}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-sent",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-delivered",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-failed",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/{id}/status",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/CreateOrder",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/{id}/payments",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/{id}/payments",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/payments/{paymentId}/status",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/{id}/cancel",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/payments/webhook",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Account/Login",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Account/Login",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Details",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Wizard",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Wizard",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/CompleteWizard",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Metrics",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Delete",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Suspend",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/Activate",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Bots/RegenerateKey",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Categories/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Categories/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Categories/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Categories/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Categories/Delete",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/Customer",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Messages/Reply",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/Details",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Orders/UpdateStatus",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/UploadPhoto",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/DeletePhoto",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Products/Delete",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/ShippingRates/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/ShippingRates/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/ShippingRates/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/ShippingRates/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/ShippingRates/Delete",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Users/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Users/Create",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Users/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Users/Edit",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    },
    {
      "GapType": "Data Validation",
      "Endpoint": "api/Users/Delete",
      "Description": "Endpoint with complex parameters lacks comprehensive data validation tests",
      "Severity": "Warning",
      "Recommendation": "Add tests for both valid and invalid data scenarios, including edge cases",
      "AffectedStates": []
    }
  ],
  "SuggestedTests": [
    {
      "TestName": "Auth_Login_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Auth/login",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Auth_Login_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Auth/login\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Auth_Login_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Auth/login",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Auth_Login_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Auth/login\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_MarkMessageAsSent_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/{id}/mark-sent",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task BotMessages_MarkMessageAsSent_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/{id}/mark-sent\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_MarkMessageAsSent_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/{id}/mark-sent",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task BotMessages_MarkMessageAsSent_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/{id}/mark-sent\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_MarkMessageAsFailed_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/{id}/mark-failed",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task BotMessages_MarkMessageAsFailed_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/{id}/mark-failed\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_MarkMessageAsFailed_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/{id}/mark-failed",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task BotMessages_MarkMessageAsFailed_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/{id}/mark-failed\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_CreateTestMessage_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/test-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task BotMessages_CreateTestMessage_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/test-create\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_CreateTestMessage_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/test-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task BotMessages_CreateTestMessage_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/test-create\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_CreateCustomerMessage_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/customer-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task BotMessages_CreateCustomerMessage_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/customer-create\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_CreateCustomerMessage_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/customer-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task BotMessages_CreateCustomerMessage_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/customer-create\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_GetCustomerMessages_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task BotMessages_GetCustomerMessages_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/customer/{customerId}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "BotMessages_GetCustomerMessages_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/bot/messages/customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task BotMessages_GetCustomerMessages_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/bot/messages/customer/{customerId}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RegisterBot_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/register",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_RegisterBot_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/register\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RegisterBot_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/register",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_RegisterBot_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/register\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_AuthenticateBot_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/authenticate",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_AuthenticateBot_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/authenticate\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_AuthenticateBot_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/authenticate",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_AuthenticateBot_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/authenticate\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_UpdateBotSettings_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/settings",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_UpdateBotSettings_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/settings\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_UpdateBotSettings_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/settings",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_UpdateBotSettings_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/settings\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RecordHeartbeat_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/heartbeat",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_RecordHeartbeat_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/heartbeat\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RecordHeartbeat_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/heartbeat",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_RecordHeartbeat_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/heartbeat\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_UpdatePlatformInfo_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/platform-info",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_UpdatePlatformInfo_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/platform-info\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_UpdatePlatformInfo_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/platform-info",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_UpdatePlatformInfo_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/platform-info\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RecordMetric_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/metrics",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_RecordMetric_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/metrics\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RecordMetric_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/metrics",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_RecordMetric_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/metrics\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RecordMetricsBatch_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/metrics/batch",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_RecordMetricsBatch_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/metrics/batch\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RecordMetricsBatch_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/metrics/batch",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_RecordMetricsBatch_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/metrics/batch\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_StartSession_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/sessions/start",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_StartSession_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/sessions/start\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_StartSession_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/sessions/start",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_StartSession_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/sessions/start\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_UpdateSession_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/sessions/{sessionId}",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_UpdateSession_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/sessions/{sessionId}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_UpdateSession_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/sessions/{sessionId}",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_UpdateSession_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/sessions/{sessionId}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_EndSession_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/sessions/{sessionId}/end",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_EndSession_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/sessions/{sessionId}/end\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_EndSession_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/sessions/{sessionId}/end",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_EndSession_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/sessions/{sessionId}/end\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetAllBots_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/GetAllBots",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Bots_GetAllBots_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/GetAllBots\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetAllBots_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/GetAllBots",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetAllBots_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/GetAllBots\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBot_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Bots_GetBot_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBot_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetBot_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBot_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetBot_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetBot_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_GetBot_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetBotMetrics_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}/metrics",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotMetrics_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}/metrics\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBotMetrics_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}/metrics",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotMetrics_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}/metrics\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBotMetrics_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}/metrics",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotMetrics_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}/metrics\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetBotMetrics_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}/metrics",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotMetrics_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}/metrics\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetMetricsSummary_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Bots_GetMetricsSummary_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}/metrics/summary\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetMetricsSummary_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetMetricsSummary_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}/metrics/summary\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetMetricsSummary_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetMetricsSummary_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}/metrics/summary\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetMetricsSummary_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}/metrics/summary",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_GetMetricsSummary_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}/metrics/summary\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetBotSessions_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}/sessions",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotSessions_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}/sessions\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBotSessions_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}/sessions",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotSessions_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}/sessions\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_GetBotSessions_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}/sessions",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotSessions_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}/sessions\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_GetBotSessions_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}/sessions",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_GetBotSessions_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}/sessions\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_DeleteBot_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "DELETE",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Bots_DeleteBot_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_DeleteBot_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "DELETE",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_DeleteBot_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Bots/{id}\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Bots_DeleteBot_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "DELETE",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_DeleteBot_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_DeleteBot_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/{id}",
      "HttpMethod": "DELETE",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_DeleteBot_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Catalog_GetCategory_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Catalog/categories/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Catalog_GetCategory_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Catalog/categories/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Catalog_GetCategory_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Catalog/categories/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Catalog_GetCategory_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Catalog/categories/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Catalog_GetProduct_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Catalog/products/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Catalog_GetProduct_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Catalog/products/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Catalog_GetProduct_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Catalog/products/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Catalog_GetProduct_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Catalog/products/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_GetCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_GetCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetCustomerByTelegramId_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/by-telegram/{telegramUserId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_GetCustomerByTelegramId_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/by-telegram/{telegramUserId}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetCustomerByTelegramId_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/by-telegram/{telegramUserId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_GetCustomerByTelegramId_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/by-telegram/{telegramUserId}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_CreateCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/CreateCustomer",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_CreateCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/CreateCustomer\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_CreateCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/CreateCustomer",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_CreateCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/CreateCustomer\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetOrCreateCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/get-or-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_GetOrCreateCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/get-or-create\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetOrCreateCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/get-or-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_GetOrCreateCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/get-or-create\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_GetOrCreateCustomer_StateDependent",
      "TestType": "State Dependent",
      "Endpoint": "api/Customers/get-or-create",
      "HttpMethod": "POST",
      "AuthenticationState": "Multiple",
      "ExpectedOutcome": "Different Content Based on State",
      "TestCode": "[Theory]\n[InlineData(\u0022Anonymous\u0022)]\n[InlineData(\u0022Authenticated\u0022)]\npublic async Task Customers_GetOrCreateCustomer_ShouldShowDifferentContent_BasedOnAuthState(string authState)\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    if (authState == \u0022Authenticated\u0022)\n        await AuthenticateAsync(client);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Customers/get-or-create\u0022);\n    var content = await response.Content.ReadAsStringAsync();\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n    // Add specific content assertions based on authentication state\n    if (authState == \u0022Authenticated\u0022)\n    {\n        Assert.Contains(\u0022authenticated-content\u0022, content);\n    }\n    else\n    {\n        Assert.Contains(\u0022anonymous-content\u0022, content);\n    }\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_UpdateCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_UpdateCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_UpdateCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_UpdateCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_BlockCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}/block",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_BlockCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}/block\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_BlockCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}/block",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_BlockCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}/block\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_UnblockCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}/unblock",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_UnblockCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}/unblock\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_UnblockCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}/unblock",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_UnblockCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}/unblock\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_DeleteCustomer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "HttpMethod": "DELETE",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Customers_DeleteCustomer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Customers_DeleteCustomer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Customers/{id}",
      "HttpMethod": "DELETE",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Customers_DeleteCustomer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Customers/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_SendMessage_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/SendMessage",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_SendMessage_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/SendMessage\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_SendMessage_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/SendMessage",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_SendMessage_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/SendMessage\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_GetMessage_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_GetMessage_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_GetMessage_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_GetMessage_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_GetCustomerMessages_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_GetCustomerMessages_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/customer/{customerId}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_GetCustomerMessages_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_GetCustomerMessages_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/customer/{customerId}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_GetOrderMessages_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/order/{orderId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_GetOrderMessages_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/order/{orderId}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_GetOrderMessages_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/order/{orderId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_GetOrderMessages_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/order/{orderId}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_MarkMessageAsSent_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-sent",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_MarkMessageAsSent_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}/mark-sent\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_MarkMessageAsSent_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-sent",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_MarkMessageAsSent_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}/mark-sent\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_MarkMessageAsDelivered_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-delivered",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_MarkMessageAsDelivered_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}/mark-delivered\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_MarkMessageAsDelivered_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-delivered",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_MarkMessageAsDelivered_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}/mark-delivered\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_MarkMessageAsFailed_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-failed",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_MarkMessageAsFailed_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}/mark-failed\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_MarkMessageAsFailed_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/{id}/mark-failed",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_MarkMessageAsFailed_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/{id}/mark-failed\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetAllOrders_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Orders/GetAllOrders",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Orders_GetAllOrders_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/GetAllOrders\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Orders_GetAllOrders_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Orders/GetAllOrders",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetAllOrders_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/GetAllOrders\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Orders_GetOrder_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Orders/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrder_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/{id}\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Orders_GetOrder_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Orders/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrder_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/{id}\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Orders_GetOrder_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrder_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrder_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrder_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_UpdateOrderStatus_UnauthorizedAccess",
      "TestType": "Authorization",
      "Endpoint": "api/Orders/{id}/status",
      "HttpMethod": "PUT",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "401 Unauthorized",
      "TestCode": "[Fact]\npublic async Task Orders_UpdateOrderStatus_ShouldReturn401_WhenNotAuthenticated()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/{id}/status\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Orders_UpdateOrderStatus_RequiresRole_Admin",
      "TestType": "Authorization",
      "Endpoint": "api/Orders/{id}/status",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_UpdateOrderStatus_ShouldReturn200_WhenUserAdmin()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client, \u0022Admin\u0022);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/{id}/status\u0022);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "Orders_UpdateOrderStatus_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/status",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_UpdateOrderStatus_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/status\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_UpdateOrderStatus_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/status",
      "HttpMethod": "PUT",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_UpdateOrderStatus_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/status\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrdersByIdentity_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrdersByIdentity_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/by-identity/{identityReference}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrdersByIdentity_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrdersByIdentity_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/by-identity/{identityReference}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrdersByIdentity_StateDependent",
      "TestType": "State Dependent",
      "Endpoint": "api/Orders/by-identity/{identityReference}",
      "HttpMethod": "GET",
      "AuthenticationState": "Multiple",
      "ExpectedOutcome": "Different Content Based on State",
      "TestCode": "[Theory]\n[InlineData(\u0022Anonymous\u0022)]\n[InlineData(\u0022Authenticated\u0022)]\npublic async Task Orders_GetOrdersByIdentity_ShouldShowDifferentContent_BasedOnAuthState(string authState)\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    if (authState == \u0022Authenticated\u0022)\n        await AuthenticateAsync(client);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/by-identity/{identityReference}\u0022);\n    var content = await response.Content.ReadAsStringAsync();\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n    // Add specific content assertions based on authentication state\n    if (authState == \u0022Authenticated\u0022)\n    {\n        Assert.Contains(\u0022authenticated-content\u0022, content);\n    }\n    else\n    {\n        Assert.Contains(\u0022anonymous-content\u0022, content);\n    }\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrdersByCustomerId_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrdersByCustomerId_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/by-customer/{customerId}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrdersByCustomerId_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrdersByCustomerId_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/by-customer/{customerId}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrdersByCustomerId_StateDependent",
      "TestType": "State Dependent",
      "Endpoint": "api/Orders/by-customer/{customerId}",
      "HttpMethod": "GET",
      "AuthenticationState": "Multiple",
      "ExpectedOutcome": "Different Content Based on State",
      "TestCode": "[Theory]\n[InlineData(\u0022Anonymous\u0022)]\n[InlineData(\u0022Authenticated\u0022)]\npublic async Task Orders_GetOrdersByCustomerId_ShouldShowDifferentContent_BasedOnAuthState(string authState)\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    if (authState == \u0022Authenticated\u0022)\n        await AuthenticateAsync(client);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/by-customer/{customerId}\u0022);\n    var content = await response.Content.ReadAsStringAsync();\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n    // Add specific content assertions based on authentication state\n    if (authState == \u0022Authenticated\u0022)\n    {\n        Assert.Contains(\u0022authenticated-content\u0022, content);\n    }\n    else\n    {\n        Assert.Contains(\u0022anonymous-content\u0022, content);\n    }\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrderByIdentity_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrderByIdentity_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/by-identity/{identityReference}/{id}\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrderByIdentity_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrderByIdentity_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/by-identity/{identityReference}/{id}\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrderByIdentity_StateDependent",
      "TestType": "State Dependent",
      "Endpoint": "api/Orders/by-identity/{identityReference}/{id}",
      "HttpMethod": "GET",
      "AuthenticationState": "Multiple",
      "ExpectedOutcome": "Different Content Based on State",
      "TestCode": "[Theory]\n[InlineData(\u0022Anonymous\u0022)]\n[InlineData(\u0022Authenticated\u0022)]\npublic async Task Orders_GetOrderByIdentity_ShouldShowDifferentContent_BasedOnAuthState(string authState)\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    if (authState == \u0022Authenticated\u0022)\n        await AuthenticateAsync(client);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/by-identity/{identityReference}/{id}\u0022);\n    var content = await response.Content.ReadAsStringAsync();\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n    // Add specific content assertions based on authentication state\n    if (authState == \u0022Authenticated\u0022)\n    {\n        Assert.Contains(\u0022authenticated-content\u0022, content);\n    }\n    else\n    {\n        Assert.Contains(\u0022anonymous-content\u0022, content);\n    }\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CreateOrder_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/CreateOrder",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_CreateOrder_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/CreateOrder\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CreateOrder_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/CreateOrder",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_CreateOrder_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/CreateOrder\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CreateOrder_StateDependent",
      "TestType": "State Dependent",
      "Endpoint": "api/Orders/CreateOrder",
      "HttpMethod": "POST",
      "AuthenticationState": "Multiple",
      "ExpectedOutcome": "Different Content Based on State",
      "TestCode": "[Theory]\n[InlineData(\u0022Anonymous\u0022)]\n[InlineData(\u0022Authenticated\u0022)]\npublic async Task Orders_CreateOrder_ShouldShowDifferentContent_BasedOnAuthState(string authState)\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    if (authState == \u0022Authenticated\u0022)\n        await AuthenticateAsync(client);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/CreateOrder\u0022);\n    var content = await response.Content.ReadAsStringAsync();\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n    // Add specific content assertions based on authentication state\n    if (authState == \u0022Authenticated\u0022)\n    {\n        Assert.Contains(\u0022authenticated-content\u0022, content);\n    }\n    else\n    {\n        Assert.Contains(\u0022anonymous-content\u0022, content);\n    }\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CreatePayment_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/payments",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_CreatePayment_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/payments\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CreatePayment_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/payments",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_CreatePayment_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/payments\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CreatePayment_StateDependent",
      "TestType": "State Dependent",
      "Endpoint": "api/Orders/{id}/payments",
      "HttpMethod": "POST",
      "AuthenticationState": "Multiple",
      "ExpectedOutcome": "Different Content Based on State",
      "TestCode": "[Theory]\n[InlineData(\u0022Anonymous\u0022)]\n[InlineData(\u0022Authenticated\u0022)]\npublic async Task Orders_CreatePayment_ShouldShowDifferentContent_BasedOnAuthState(string authState)\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    if (authState == \u0022Authenticated\u0022)\n        await AuthenticateAsync(client);\n\n    // Act\n    var response = await client.GetAsync(\u0022api/Orders/{id}/payments\u0022);\n    var content = await response.Content.ReadAsStringAsync();\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n    // Add specific content assertions based on authentication state\n    if (authState == \u0022Authenticated\u0022)\n    {\n        Assert.Contains(\u0022authenticated-content\u0022, content);\n    }\n    else\n    {\n        Assert.Contains(\u0022anonymous-content\u0022, content);\n    }\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrderPayments_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/payments",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrderPayments_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/payments\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetOrderPayments_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/payments",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_GetOrderPayments_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/payments\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetPaymentStatus_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/payments/{paymentId}/status",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_GetPaymentStatus_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/payments/{paymentId}/status\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_GetPaymentStatus_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/payments/{paymentId}/status",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_GetPaymentStatus_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/payments/{paymentId}/status\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CancelOrder_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/cancel",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_CancelOrder_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/cancel\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_CancelOrder_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/{id}/cancel",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_CancelOrder_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/{id}/cancel\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_PaymentWebhook_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/payments/webhook",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_PaymentWebhook_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/payments/webhook\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_PaymentWebhook_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/payments/webhook",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_PaymentWebhook_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/payments/webhook\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Details_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Details",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Details_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Details\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Details_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Details",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Details_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Details\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_CompleteWizard_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/CompleteWizard",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_CompleteWizard_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/CompleteWizard\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_CompleteWizard_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/CompleteWizard",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_CompleteWizard_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/CompleteWizard\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Metrics_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Metrics",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Metrics_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Metrics\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Metrics_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Metrics",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Metrics_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Metrics\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Delete_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Delete_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Delete\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Delete_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Delete_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Delete\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Suspend_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Suspend",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Suspend_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Suspend\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Suspend_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Suspend",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Suspend_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Suspend\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Activate_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Activate",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_Activate_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Activate\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_Activate_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/Activate",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_Activate_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/Activate\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RegenerateKey_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/RegenerateKey",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Bots_RegenerateKey_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/RegenerateKey\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Bots_RegenerateKey_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Bots/RegenerateKey",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Bots_RegenerateKey_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Bots/RegenerateKey\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Categories_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Categories/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Categories_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Categories/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Categories_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Categories/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Categories_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Categories/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Categories_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Categories/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Categories_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Categories/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Categories_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Categories/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Categories_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Categories/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Categories_Delete_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Categories/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Categories_Delete_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Categories/Delete\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Categories_Delete_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Categories/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Categories_Delete_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Categories/Delete\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_Customer_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/Customer",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_Customer_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/Customer\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_Customer_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/Customer",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_Customer_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/Customer\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_Reply_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/Reply",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Messages_Reply_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/Reply\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Messages_Reply_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Messages/Reply",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Messages_Reply_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Messages/Reply\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_Details_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/Details",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_Details_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/Details\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_Details_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/Details",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_Details_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/Details\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_UpdateStatus_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/UpdateStatus",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Orders_UpdateStatus_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/UpdateStatus\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Orders_UpdateStatus_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Orders/UpdateStatus",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Orders_UpdateStatus_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Orders/UpdateStatus\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Products_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Products_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Products_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Products_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_UploadPhoto_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/UploadPhoto",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Products_UploadPhoto_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/UploadPhoto\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_UploadPhoto_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/UploadPhoto",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Products_UploadPhoto_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/UploadPhoto\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_DeletePhoto_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/DeletePhoto",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Products_DeletePhoto_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/DeletePhoto\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_DeletePhoto_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/DeletePhoto",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Products_DeletePhoto_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/DeletePhoto\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_Delete_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Products_Delete_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/Delete\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Products_Delete_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Products/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Products_Delete_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Products/Delete\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "ShippingRates_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/ShippingRates/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task ShippingRates_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/ShippingRates/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "ShippingRates_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/ShippingRates/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task ShippingRates_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/ShippingRates/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "ShippingRates_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/ShippingRates/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task ShippingRates_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/ShippingRates/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "ShippingRates_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/ShippingRates/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task ShippingRates_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/ShippingRates/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "ShippingRates_Delete_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/ShippingRates/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task ShippingRates_Delete_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/ShippingRates/Delete\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "ShippingRates_Delete_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/ShippingRates/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task ShippingRates_Delete_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/ShippingRates/Delete\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Users_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Users/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Users_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Users/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Users_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Users/Edit",
      "HttpMethod": "GET",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Users_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Users/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Users_Edit_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Users/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Users_Edit_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Users/Edit\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Users_Edit_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Users/Edit",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Users_Edit_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Users/Edit\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Users_Delete_ValidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Users/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "200 OK",
      "TestCode": "[Fact]\npublic async Task Users_Delete_ShouldReturn200_WithValidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var validData = CreateValidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Users/Delete\u0022, validData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.OK, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "Users_Delete_InvalidData",
      "TestType": "Data Validation",
      "Endpoint": "api/Users/Delete",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "400 Bad Request",
      "TestCode": "[Fact]\npublic async Task Users_Delete_ShouldReturn400_WithInvalidData()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n    await AuthenticateAsync(client);\n    var invalidData = CreateInvalidTestData();\n\n    // Act\n    var response = await client.PostAsJsonAsync(\u0022api/Users/Delete\u0022, invalidData);\n\n    // Assert\n    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);\n}",
      "TestData": [],
      "Priority": "Medium"
    },
    {
      "TestName": "AuthFlow_Login_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "Transition to Authenticated",
      "TestCode": "[Fact]\npublic async Task Login_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Anonymous to Authenticated via login endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Register_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "Transition to Authenticated",
      "TestCode": "[Fact]\npublic async Task Register_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Anonymous to Authenticated via registration endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Login_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "Transition to Authenticated",
      "TestCode": "[Fact]\npublic async Task Login_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Anonymous to Authenticated via login endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Login_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "Transition to Authenticated",
      "TestCode": "[Fact]\npublic async Task Login_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Anonymous to Authenticated via login endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Login_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Anonymous",
      "ExpectedOutcome": "Transition to Authenticated",
      "TestCode": "[Fact]\npublic async Task Login_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Anonymous to Authenticated via login endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Logout_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "Transition to Anonymous",
      "TestCode": "[Fact]\npublic async Task Logout_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Authenticated to Anonymous via logout endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Logout_Flow",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated_Admin",
      "ExpectedOutcome": "Transition to Anonymous",
      "TestCode": "[Fact]\npublic async Task Logout_Flow_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // User should be able to transition from Authenticated_Admin to Anonymous via logout endpoint\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Session_Timeout",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "Transition to Anonymous",
      "TestCode": "[Fact]\npublic async Task Session_Timeout_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // Verify that expired sessions are handled correctly and user is redirected to login\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Concurrent_Sessions",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated",
      "ExpectedOutcome": "Transition to Authenticated",
      "TestCode": "[Fact]\npublic async Task Concurrent_Sessions_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // Test behavior when same user logs in from multiple locations\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    },
    {
      "TestName": "AuthFlow_Role_Switching",
      "TestType": "Authentication Flow",
      "Endpoint": "Multiple",
      "HttpMethod": "POST",
      "AuthenticationState": "Authenticated_User",
      "ExpectedOutcome": "Transition to Authenticated_Admin",
      "TestCode": "[Fact]\npublic async Task Role_Switching_ShouldWork()\n{\n    // Arrange\n    var client = _factory.CreateClient();\n\n    // Act \u0026 Assert\n    // Verify that role changes are reflected in endpoint accessibility\n    // TODO: Implement specific flow testing based on scenario\n}",
      "TestData": [],
      "Priority": "High"
    }
  ],
  "Summary": {
    "TotalEndpoints": 115,
    "FullyCoveredEndpoints": 0,
    "PartiallyCoveredEndpoints": 27,
    "UncoveredEndpoints": 88,
    "OverallCoveragePercentage": 16.956521739130434,
    "CriticalGaps": 124,
    "WarningGaps": 100,
    "InfoGaps": 0,
    "SuggestedTests": 190,
    "TopPriorities": [
      "Bots_GetAllBots_UnauthorizedAccess",
      "Bots_GetAllBots_RequiresRole_Admin",
      "Bots_GetBot_UnauthorizedAccess",
      "Bots_GetBot_RequiresRole_Admin",
      "Bots_GetBotMetrics_UnauthorizedAccess"
    ]
  }
}