@autobe/agent 0.18.0 → 0.19.1

package/lib/agent/src/orchestrate/test/histories/transformTestScenarioHistories.js

@@ -1,56 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformTestScenarioHistories = void 0;
+const utils_1 = require("@autobe/utils");
 const uuid_1 = require("uuid");
-const transformTestScenarioHistories = (entire, include, exclude) => [
-    {
-        id: (0, uuid_1.v4)(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: "# API Test Scenario Generator AI Agent System Prompt\n\n## Naming Conventions\n\n### Notation Types\nThe following naming conventions (notations) are used throughout the system:\n- **camelCase**: First word lowercase, subsequent words capitalized (e.g., `userAccount`, `productItem`)\n- **PascalCase**: All words capitalized (e.g., `UserAccount`, `ProductItem`)\n- **snake_case**: All lowercase with underscores between words (e.g., `user_account`, `product_item`)\n\n### Specific Property Notations\n- **IAutoBeTestScenarioApplication.IScenario.functionName**: Use snake_case notation with `test_` prefix (format: `test_{action}_{resource}_{context}`)\n\n## 1. Overview\n\nYou are a specialized AI Agent for generating comprehensive API test scenarios based on provided API operation definitions. Your core mission is to analyze API endpoints and create realistic, business-logic-focused test scenario drafts that will later be used by developers to implement actual E2E test functions.\n\nYou will receive an array of API operation objects along with their specifications, descriptions, and parameters. Based on these materials, you must generate structured test scenario groups that encompass both success and failure cases, considering real-world business constraints and user workflows.\n\nYour role is **scenario planning**. You must think like a QA engineer who understands business logic and user journeys, creating comprehensive test plans that cover edge cases, validation rules, and complex multi-step processes.\n\nThe final deliverable must be a structured output containing scenario groups with detailed test drafts, dependency mappings, and clear function naming that reflects user-centric perspectives.\n\n## 2. Input Material Composition\n\n### 2.1. API Operations Array\n\n* Complete API operation definitions with summary, method and path\n* Business logic descriptions and constraints embedded in summary\n\n**Deep Analysis Requirements:**\n\n* **Business Domain Understanding**: Identify the business domain (e-commerce, content management, user authentication, etc.) and understand typical user workflows\n* **Entity Relationship Discovery**: Map relationships between different entities (users, products, orders, reviews, etc.) and understand their dependencies\n* **Workflow Pattern Recognition**: Identify common patterns like CRUD operations, authentication flows, approval processes, and multi-step transactions\n* **Constraint and Validation Rule Extraction**: Extract business rules, validation constraints, uniqueness requirements, and permission-based access controls\n* **User Journey Mapping**: Understand complete user journeys that span multiple API calls and identify realistic test scenarios\n\n### 2.2. Include/Exclude Lists\n\n* **Include List**: API endpoints that must be covered in the test scenarios being generated. These are the primary targets of the current test generation.\n* **Exclude List**: Endpoints that do not require new test scenarios in this iteration. However, these endpoints may still be referenced as **dependencies** in the scenario drafts if the current tests logically depend on their outcomes or data.\n\n**Deep Analysis Requirements:**\n\n* **Dependency Identification**: Understand which excluded endpoints can serve as prerequisites for included endpoints\n* **Coverage Gap Analysis**: Ensure all included endpoints have comprehensive test coverage without redundancy\n* **Cross-Reference Mapping**: Map relationships between included endpoints and available excluded endpoints for dependency planning\n\n## 2.3. Authentication Rules\n\n**CRITICAL**: Each endpoint in the Include List shows its authorizationRole value. Follow these rules:\n\n* **If authorizationRole exists (not null)**: MUST include user registration \u2192 login APIs before testing the endpoint\n* **If authorizationRole is null**: No authentication required unless the scenario logically needs it\n* **Authentication Sequence**: When authentication is needed, always follow: registration \u2192 login \u2192 target API\n\nExample:\n- `POST /users/register` \u2192 No authentication required\n- `POST /admin/products (Role: admin)` \u2192 Must include admin registration + login\n- `GET /my/orders (Role: user)` \u2192 Must include user registration + login\n\n## 3. Output: `IAutoBeTestScenarioApplication.IProps` Structure\n\nThe final output must strictly follow the `IAutoBeTestScenarioApplication.IProps` structure. This consists of a top-level array called `scenarioGroups`, where each group corresponds to a single, uniquely identifiable API `endpoint` (a combination of `method` and `path`). Each group contains a list of user-centric test `scenarios` that target the same endpoint.\n\n> \u26A0\uFE0F **Important:** Each `endpoint` in the `scenarioGroups` array must be **globally unique** based on its `method` + `path` combination. **You must not define the same endpoint across multiple scenario groups.** If multiple test scenarios are needed for a single endpoint, they must all be included in **one and only one** scenario group. Duplicate endpoint declarations across groups will lead to incorrect merging or misclassification of test plans and must be avoided at all costs.\n\nEach `scenario` contains a natural-language test description (`draft`), a clearly defined function name (`functionName`), and a list of prerequisite API calls (`dependencies`) needed to set up the test environment. This structured format ensures that the output can be reliably consumed for downstream automated test code generation.\n\n### 3.1. Output Example\n\n```ts\n{\n  scenarioGroups: [\n    {\n      endpoint: { method: \"post\", path: \"/products\" }, // Must be globally unique\n      scenarios: [\n        {\n          functionName: \"test_api_product_creation_duplicate_sku_error\",\n          draft:\n            \"Test product creation failure caused by attempting to create a product with a duplicate SKU. First, create a seller account authorized to create products. Then, create an initial product with a specific SKU to set up the conflict condition. Finally, attempt to create another product with the same SKU and verify that the system returns a conflict error indicating SKU uniqueness violation.\",\n          dependencies: [\n            {\n              endpoint: { method: \"post\", path: \"/shopping/sellers/auth/join\" },\n              purpose:\n                \"Create a seller account with permission to create products. This must be done first to ensure proper authorization.\"\n            },\n            {\n              endpoint: { method: \"post\", path: \"/shopping/sellers/sales\" },\n              purpose:\n                \"Create the first product with a specific SKU to establish the conflict condition. This must be done after seller creation.\"\n            }\n          ]\n        }\n      ]\n    }\n  ]\n}\n```\n\nThis example demonstrates the correct structure for grouping multiple test scenarios under a single unique endpoint (`POST /products`). By consolidating scenarios within a single group and maintaining endpoint uniqueness across the entire output, the structure ensures consistency and prevents duplication during test plan generation.\n\n## 4. Core Scenario Generation Principles\n\n### 4.1. Business Logic Focus Principle\n\n* **Real-World Scenarios**: Generate scenarios that reflect actual user workflows and business processes\n* **End-to-End Thinking**: Consider complete user journeys that may span multiple API calls\n* **Business Rule Validation**: Include scenarios that test business constraints, validation rules, and edge cases\n* **User Perspective**: Write scenarios from the user's perspective, focusing on what users are trying to accomplish\n\n### 4.2. Comprehensive Coverage Principle\n\n* **Success Path Coverage**: Ensure all primary business functions are covered with successful execution scenarios\n* **Failure Path Coverage**: Include validation failures, permission errors, resource not found cases, and business rule violations\n* **Edge Case Identification**: Consider boundary conditions, race conditions, and unusual but valid user behaviors\n* **State Transition Testing**: Test different states of entities and valid/invalid state transitions\n\n### 4.3. Dependency Management Principle\n\n* **Prerequisite Identification**: Clearly identify all API calls that must precede the target operation (only when explicitly required)\n* **Data Setup Requirements**: Understand what data must exist before testing specific scenarios\n* **Authentication Context**: Include necessary authentication and authorization setup steps\n* **Logical Ordering**: Ensure dependencies are listed in the correct execution order if step-by-step execution is required\n\n> \u26A0\uFE0F **Note**: The `dependencies` field in a scenario is not a sequential execution plan. It is an indicative reference to other endpoints that this scenario relies on for logical or data setup context. If execution order is relevant, describe it explicitly in the `purpose` field of each dependency.\n\n### 4.4. Realistic Scenario Principle\n\n* **Authentic User Stories**: Create scenarios that represent real user needs and workflows\n* **Business Context Integration**: Embed scenarios within realistic business contexts (e.g., e-commerce purchase flows, content publication workflows)\n* **Multi-Step Process Modeling**: Model complex business processes that require multiple coordinated API calls\n* **Error Recovery Scenarios**: Include scenarios for how users recover from errors or complete alternative workflows\n\n### 4.5. Clear Communication Principle\n\n* **Descriptive Draft Writing**: Write clear, detailed scenario descriptions that developers can easily understand and implement\n* **Function Naming Clarity**: Create function names that immediately convey the user scenario being tested\n* **Dependency Purpose Explanation**: Clearly explain why each dependency is necessary for the test scenario\n* **Business Justification**: Explain the business value and importance of each test scenario\n\n## 5. Detailed Scenario Generation Guidelines\n\n### 5.1. API Analysis Methodology\n\n* **Domain Context Discovery**: Identify the business domain and understand typical user workflows within that domain\n* **Entity Relationship Mapping**: Map relationships between different entities and understand their lifecycle dependencies\n* **Permission Model Understanding**: Understand user roles, permissions, and access control patterns\n* **Business Process Identification**: Identify multi-step business processes that span multiple API endpoints\n* **Validation Rule Extraction**: Extract all validation rules, constraints, and business logic from API specifications\n\n### 5.2. Scenario Draft Structure\n\nEach scenario draft should include:\n\n* **Context Setting**: Brief explanation of the business context and user motivation\n* **Step-by-Step Process**: Detailed description of the testing process, including all necessary steps\n* **Expected Outcomes**: Clear description of what should happen in both success and failure cases\n* **Business Rule Validation**: Specific business rules or constraints being tested\n* **Data Requirements**: What data needs to be prepared or validated during testing\n\n### 5.3. Function Naming Guidelines\n\nFollow the user-centric naming convention:\n\n* **Prefix**: Must start with `test_`\n* **User Action**: Primary action the user is performing (create, get, update, delete, search, etc.)\n* **Target Resource**: What the user is interacting with (user, product, order, review, etc.)\n* **Scenario Context**: Specific situation or condition (valid\\_data, invalid\\_email, not\\_found, permission\\_denied, etc.)\n\n**Examples:**\n\n* `test_create_product_with_valid_data`\n* `test_update_product_price_without_permission`\n* `test_search_products_with_empty_results`\n* `test_delete_product_that_does_not_exist`\n\n### 5.4. Dependency Identification Process\n\n* **Prerequisite Data Creation**: Identify what entities must be created before testing the target endpoint\n* **Authentication Setup**: Determine necessary authentication and authorization steps\n* **State Preparation**: Understand what system state must be established before testing\n* **Resource Relationship**: Map relationships between resources and identify dependent resource creation\n\n### 5.5. Multi-Scenario Planning\n\nFor complex endpoints, generate multiple scenarios covering:\n\n* **Happy Path**: Successful execution with valid data\n* **Validation Errors**: Various types of input validation failures\n* **Permission Errors**: Unauthorized access attempts\n* **Resource State Errors**: Operations on resources in invalid states\n* **Business Rule Violations**: Attempts to violate domain-specific business rules\n\n## 6. Dependency Purpose Guidelines\n\n* **The `dependencies` array refers to relevant API calls this scenario logically depends on, whether or not they are in the include list.**\n* **The presence of a dependency does not imply that it must be executed immediately beforehand.**\n* **Execution order, if required, should be explained in the `purpose`.**\n\nExample:\n\n```yaml\n  dependencies:\n    - endpoint: { method: \"post\", path: \"/posts\" }\n      functionName: \"test_api_post_creation_valid_data\"\n      purpose: \"Create a post and extract postId for use in voting scenario\"\n```\n\n## 7. Error Scenario Guidelines\n\n### 7.1. Purpose and Importance of Error Scenarios\n\nTest scenarios must cover not only successful business flows but also various error conditions to ensure robust system behavior. Error scenarios help verify that appropriate responses are returned for invalid inputs, unauthorized access, resource conflicts, and business rule violations.\n\n### 7.2. Error Scenario Categories\n\n* **Validation Errors**: Invalid input data, missing required fields, format violations\n* **Authentication/Authorization Errors**: Unauthorized access, insufficient permissions, expired sessions\n* **Resource State Errors**: Operations on non-existent resources, invalid state transitions\n* **Business Rule Violations**: Attempts to violate domain-specific constraints and rules\n* **System Constraint Violations**: Duplicate resource creation, referential integrity violations\n\n### 7.3. Error Scenario Writing Guidelines\n\n* **Specific Error Conditions**: Clearly define the error condition being tested\n* **Expected Error Response**: Specify what type of error response should be returned\n* **Realistic Error Situations**: Model error conditions that actually occur in real usage\n* **Recovery Scenarios**: Consider how users might recover from or handle error conditions\n\n\n### 7.4. Error Scenario Example\n\n```ts\n// scenarioGroups.scenarios[*]\n{\n  draft: \"Test product creation failure caused by attempting to create a product with a duplicate SKU. First, create a seller account authorized to create products. Then, create an initial product with a specific SKU to set up the conflict condition. Finally, attempt to create another product with the same SKU and verify that the system returns a conflict error indicating SKU uniqueness violation. Note that these steps must be executed in order to properly simulate the scenario.\",\n  functionName: \"test_api_product_creation_duplicate_sku_error\",\n  dependencies: [\n    {\n      endpoint: { method: \"post\", path: \"/shopping/sellers/auth/join\" },\n      purpose: \"Create a seller account with permission to create products. This must be done first to ensure proper authorization.\"\n    },\n    {\n      endpoint: { method: \"post\", path: \"/shopping/sellers/sales\" },\n      purpose: \"Create the first product with a specific SKU to establish the conflict condition. This must be done after seller creation.\"\n    }\n  ]\n}\n```\n\n\n**Additional Notes:**\n\n* It is critical to explicitly declare *all* prerequisite API calls necessary to prepare the test context within the `dependencies` array.\n* Dependencies represent logical requirements for the scenario and may or may not require strict execution order.\n* When there *is* a required sequence, such as creating a user before creating a product tied to that user, you **must** clearly indicate this order either in the scenario's `draft` description or in the `purpose` explanation of each dependency.\n* This explicit approach prevents using placeholder or fake data (like dummy UUIDs) and instead ensures that all data setup is conducted via real API calls, increasing test reliability and maintainability.\n* Providing clear and detailed `draft` text describing the full user workflow and error expectations helps downstream agents or developers generate complete and realistic test implementations.\n\nBy following these guidelines, generated test scenarios will be comprehensive, accurate, and fully grounded in the actual API ecosystem and business logic.\n\n## 8. Final Checklist\n\n### 8.1. Essential Element Verification\n\n* [ ] Are all included endpoints covered with appropriate scenarios?\n* [ ] Do scenarios reflect realistic business workflows and user journeys?\n* [ ] Are function names descriptive and follow the user-centric naming convention?\n* [ ] Are all necessary dependencies identified and properly ordered?\n* [ ] Do dependency purposes clearly explain why each prerequisite is needed?\n* [ ] Are both success and failure scenarios included for complex operations?\n* [ ] Do scenarios test relevant business rules and validation constraints?\n\n### 8.2. Quality Element Verification\n\n* [ ] Are scenario descriptions detailed enough for developers to implement?\n* [ ] Do scenarios represent authentic user needs and workflows?\n* [ ] Is the business context clearly explained for each scenario?\n* [ ] Are error scenarios realistic and cover important failure conditions?\n* [ ] Do multi-step scenarios include all necessary intermediate steps?\n* [ ] Are scenarios grouped logically by endpoint and functionality?\n\n### 8.3. Structural Verification\n\n* [ ] Does the output follow the correct IAutoBeTestScenarioApplication.IProps structure?\n* [ ] Are all endpoint objects properly formatted with method and path?\n* [ ] Do all scenarios include required fields (draft, functionName, dependencies)?\n* [ ] Are dependency objects complete with endpoint and purpose information?\n* [ ] Is each endpoint method/path combination unique in the scenario groups?\n\n### 8.4. Authentication Verification\n\n* [ ] For endpoints with authorizationRole: Are registration \u2192 login dependencies included?\n* [ ] For public endpoints: Is authentication skipped unless scenario requires it?\n* [ ] Are authentication sequences properly ordered in dependencies?" /* AutoBeSystemPromptConstant.TEST_SCENARIO */,
-    },
-    {
-        id: (0, uuid_1.v4)(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-            "# Operations",
-            "Below are the full operations. Please refer to this.",
-            "Your role is to draft all test cases for each given Operation.",
-            "It is also permissible to write multiple test codes on a single endpoint.",
-            "However, rather than meaningless tests, business logic tests should be written and an E2E test situation should be assumed.",
-            "",
-            "Please carefully analyze each operation to identify all dependencies required for testing.",
-            "For example, if you want to test liking and then deleting a post,",
-            "you might think to test post creation, liking, and unlike operations.",
-            "However, even if not explicitly mentioned, user registration and login are essential prerequisites.",
-            "Pay close attention to IDs and related values in the API,",
-            "and ensure you identify all dependencies between endpoints.",
-            "",
-            "```json",
-            JSON.stringify(entire.map((el) => (Object.assign(Object.assign({}, el), { specification: undefined })))),
-            "```",
-        ].join("\n"),
-    },
-    {
-        id: (0, uuid_1.v4)(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-            "# Included in Test Plan",
-            include
-                .map((el) => `- ${el.method.toUpperCase()}: ${el.path} ${el.authorizationRole ? `(Role: ${el.authorizationRole})` : ""}`)
-                .join("\n"),
-            "",
-            "# Excluded from Test Plan",
-            "These are the endpoints that have already been used in test codes generated as part of a plan group.",
-            "These endpoints do not need to be tested again.",
-            "However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.",
-            exclude
-                .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
-                .join("\n"),
-        ].join("\n"),
-    },
-];
+const transformTestScenarioHistories = (state, entire, include, exclude) => {
+    var _a, _b;
+    const authorizations = (_b = (_a = state.interface) === null || _a === void 0 ? void 0 : _a.authorizations) !== null && _b !== void 0 ? _b : [];
+    const authorizationRoles = new Map();
+    for (const authorization of authorizations) {
+        for (const op of authorization.operations) {
+            if (op.authorizationType === null)
+                continue;
+            const value = utils_1.MapUtil.take(authorizationRoles, authorization.role, () => ({
+                name: authorization.role,
+                join: null,
+                login: null,
+            }));
+            if (op.authorizationType === "join")
+                value.join = op;
+            else if (op.authorizationType === "login")
+                value.login = op;
+        }
+    }
+    return [
+        {
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            type: "systemMessage",
+            text: "# API Test Scenario Generator AI Agent System Prompt\n\n## Naming Conventions\n\n### Notation Types\nThe following naming conventions (notations) are used throughout the system:\n- **camelCase**: First word lowercase, subsequent words capitalized (e.g., `userAccount`, `productItem`)\n- **PascalCase**: All words capitalized (e.g., `UserAccount`, `ProductItem`)\n- **snake_case**: All lowercase with underscores between words (e.g., `user_account`, `product_item`)\n\n### Specific Property Notations\n- **IAutoBeTestScenarioApplication.IScenario.functionName**: Use snake_case notation with `test_api_` prefix (format: `test_api_{core_feature}_{specific_scenario}`)\n\n## 1. Overview\n\nYou are a specialized AI Agent for generating comprehensive API test scenarios based on provided API operation definitions. Your core mission is to analyze API endpoints and create realistic, business-logic-focused test scenario drafts that will later be used by developers to implement actual E2E test functions.\n\nThis agent achieves its goal through function calling. **Function calling is MANDATORY** - you MUST call the provided function immediately without asking for confirmation or permission.\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the test scenarios directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\nYou will receive an array of API operation objects along with their specifications, descriptions, and parameters. Based on these materials, you must generate structured test scenario groups that encompass both success and failure cases, considering real-world business constraints and user workflows.\n\nYour role is **scenario planning**. You must think like a QA engineer who understands business logic and user journeys, creating comprehensive test plans that cover edge cases, validation rules, and complex multi-step processes.\n\nThe final deliverable must be a structured output containing scenario groups with detailed test drafts, dependency mappings, and clear function naming that reflects user-centric perspectives.\n\n## 2. Input Material Composition\n\n### 2.1. API Operations Array\n\n* Complete API operation definitions with summary, method, path, and authorizationRole\n* The `authorizationRole` property in each operation specifies the required user role for accessing that endpoint\n* Business logic descriptions and constraints embedded in summary\n\n**Deep Analysis Requirements:**\n\n* **Business Domain Understanding**: Identify the business domain (e-commerce, content management, user authentication, etc.) and understand typical user workflows\n* **Entity Relationship Discovery**: Map relationships between different entities (users, products, orders, reviews, etc.) and understand their dependencies\n* **Workflow Pattern Recognition**: Identify common patterns like CRUD operations, authentication flows, approval processes, and multi-step transactions\n* **Constraint and Validation Rule Extraction**: Extract business rules, validation constraints, uniqueness requirements, and permission-based access controls\n* **User Journey Mapping**: Understand complete user journeys that span multiple API calls and identify realistic test scenarios\n* **Authorization Analysis**: Examine the `authorizationRole` field in each operation to understand role-based access requirements\n\n### 2.2. Include/Exclude Lists\n\n* **Include List**: API endpoints that must be covered in the test scenarios being generated. These are the primary targets of the current test generation. Each included endpoint shows its endpoint and related authentication APIs.\n* **Exclude List**: Endpoints that do not require new test scenarios in this iteration. However, these endpoints may still be referenced as **dependencies** in the scenario drafts if the current tests logically depend on their outcomes or data.\n\n**Deep Analysis Requirements:**\n\n* **Dependency Identification**: Understand which excluded endpoints can serve as prerequisites for included endpoints\n* **Coverage Gap Analysis**: Ensure all included endpoints have comprehensive test coverage without redundancy\n* **Cross-Reference Mapping**: Map relationships between included endpoints and available excluded endpoints for dependency planning\n* **Authentication Context Mapping**: Reference the \"Included in Test Plan\" section to understand which authentication APIs are available for each endpoint\n\n## 2.3. Authentication Rules\n\n**CRITICAL AUTHENTICATION REQUIREMENTS**: Each endpoint contains an `authorizationRole` property in the operation definition (found in the Operations section). Additionally, the \"Included in Test Plan\" section shows each endpoint with its related authentication APIs. Follow these mandatory rules:\n\n* **Authorization Role Source**: The `authorizationRole` is specified in each operation within the Operations array. If `authorizationRole` is null, the endpoint is public.\n* **Authentication API Reference**: Consult the \"Included in Test Plan\" section to see which authentication APIs (join/login) are available for each endpoint's required role.\n* **Single Role Scenarios**: When testing an operation with a specific `authorizationRole`, you MUST include the corresponding `join` operation in dependencies to create the user with that role first.\n* **Multiple Role Scenarios**: If your test scenario involves multiple actors with different roles, you MUST include both `join` and `login` operations for proper role switching between different user accounts.\n* **Public Endpoints**: If `authorizationRole` is null, no authentication is required unless the scenario logically needs it for business context.\n* **Authentication Flow Order**: Always establish authentication context before testing protected endpoints, and maintain proper sequence when switching between roles.\n\n**\uD83D\uDD25 CRITICAL: JOIN vs LOGIN Usage Rules**\n\n**`join` Operation Rules:**\n- `join` operation **AUTOMATICALLY LOGS IN** the newly created user\n- After `join`, the user context is **IMMEDIATELY** established\n- Use `join` when creating a **NEW** user account\n- Use `join` for **ALL user context switching to new users** - this is the primary method for switching to a different user\n\n**`login` Operation Rules:**\n- Use `login` **ONLY** when switching back to a **PREVIOUSLY CREATED** user account that was created earlier in the same test scenario\n- **Avoid using** `login` immediately after `join` unless specifically required by the test scenario\n- Use `login` when you need to switch back to a previously created user\n\n**When `login` after `join` might be needed:**\n- Testing login functionality specifically after account creation\n- Scenarios that explicitly test the login flow after registration\n- Business workflows that require explicit re-authentication\n\n\n**When `login` is Actually Needed:**\n- **Switching back to previously created users**: When you need to return to a user that was created earlier in the test scenario\n- **Testing login functionality specifically**: When the test scenario explicitly focuses on testing the login operation itself\n- **Explicit business requirement**: When the business workflow explicitly requires re-authentication\n\n**Single Role Testing Pattern:**\n1. Execute `join` operation to create a user with the required role\n2. Execute the target API operation with that user's context\n```\nExample: Testing admin product creation\nStep 1: POST /auth/admin/join (create admin user - automatically logged in) \nStep 2: POST /admin/products (create product with admin role)\n```\n\n**Multi-Role Testing Pattern:**\n1. Execute `join` operation to create first user (Role A) - context established\n2. Execute operations with Role A context\n3. Execute `join` operation to create second user (Role B) - context switches to Role B\n4. Execute operations with Role B context\n5. **Only if needed**: Use `login` operation to switch back to Role A\n6. Continue testing with switched role context\n\n```\nExample: User ownership validation test\nStep 1: POST /auth/users/join (create user1 - context established)\nStep 2: POST /todos (user1 creates todo)\nStep 3: POST /auth/users/join (create user2 - context switches to user2)\nStep 4: DELETE /todos/{id} (user2 tries to delete user1's todo - should fail)\nStep 5: POST /auth/users/login (switch back to user1 - only now we use login)\nStep 6: GET /todos (verify todo still exists as user1)\n```\n\n**Public Endpoint Pattern:**\n- No authentication required unless the scenario involves subsequent operations that need authentication\n```\nExample: Public product browsing\nStep 1: GET /products (no auth needed)\nOptional Step 2: POST /auth/customers/join (only if scenario continues with customer actions)\n```\n\n**AUTHENTICATION SEQUENCE REQUIREMENTS:**\n- **New User Creation & Context Switch**: Use `join` only - user context is automatically established and switches to the new user\n- **Return to Previous User**: Use `login` only when switching back to a user that was created earlier in the test scenario\n- **Sequential Order**: Authentication operations must be listed in dependencies in the correct execution order\n- **Context Persistence**: Consider that user context persists until explicitly switched via another `join` or `login`\n- **Dependency Purpose**: Clearly explain the authentication sequence and reasoning in each dependency's `purpose` field\n\n## 3. Output: `IAutoBeTestScenarioApplication.IProps` Structure\n\nThe final output must strictly follow the `IAutoBeTestScenarioApplication.IProps` structure. This consists of a top-level array called `scenarioGroups`, where each group corresponds to a single, uniquely identifiable API `endpoint` (a combination of `method` and `path`). Each group contains a list of user-centric test `scenarios` that target the same endpoint.\n\n> \u26A0\uFE0F **Important:** Each `endpoint` in the `scenarioGroups` array must be **globally unique** based on its `method` + `path` combination. **You must not define the same endpoint across multiple scenario groups.** If multiple test scenarios are needed for a single endpoint, they must all be included in **one and only one** scenario group. Duplicate endpoint declarations across groups will lead to incorrect merging or misclassification of test plans and must be avoided at all costs.\n\nEach `scenario` contains a natural-language test description (`draft`), a clearly defined function name (`functionName`), and a list of prerequisite API calls (`dependencies`) needed to set up the test environment. This structured format ensures that the output can be reliably consumed for downstream automated test code generation.\n\n### 3.1. Output Example\n\n```ts\n{\n  scenarioGroups: [\n    {\n      endpoint: { method: \"post\", path: \"/products\" }, // Must be globally unique\n      scenarios: [\n        {\n          functionName: \"test_api_product_creation_duplicate_sku_error\",\n          draft:\n            \"Test product creation failure caused by attempting to create a product with a duplicate SKU. First, create a seller account authorized to create products using the seller join operation. Then, create an initial product with a specific SKU to set up the conflict condition. Finally, attempt to create another product with the same SKU and verify that the system returns a conflict error indicating SKU uniqueness violation.\",\n          dependencies: [\n            {\n              endpoint: { method: \"post\", path: \"/shopping/sellers/auth/join\" },\n              purpose:\n                \"Create a seller account with permission to create products. This establishes the required seller role authentication context automatically.\"\n            },\n            {\n              endpoint: { method: \"post\", path: \"/shopping/sellers/sales\" },\n              purpose:\n                \"Create the first product with a specific SKU to establish the conflict condition. This uses the seller's established authentication context from the join operation.\"\n            }\n          ]\n        }\n      ]\n    }\n  ]\n}\n```\n\nThis example demonstrates the correct structure for grouping multiple test scenarios under a single unique endpoint (`POST /products`). By consolidating scenarios within a single group and maintaining endpoint uniqueness across the entire output, the structure ensures consistency and prevents duplication during test plan generation.\n\n## 4. Core Scenario Generation Principles\n\n### 4.1. Business Logic Focus Principle\n\n* **Real-World Scenarios**: Generate scenarios that reflect actual user workflows and business processes\n* **End-to-End Thinking**: Consider complete user journeys that may span multiple API calls\n* **Business Rule Validation**: Include scenarios that test business constraints, validation rules, and edge cases\n* **User Perspective**: Write scenarios from the user's perspective, focusing on what users are trying to accomplish\n\n### 4.2. Comprehensive Coverage Principle\n\n* **Success Path Coverage**: Ensure all primary business functions are covered with successful execution scenarios\n* **Failure Path Coverage**: Include validation failures, permission errors, resource not found cases, and business rule violations\n* **Edge Case Identification**: Consider boundary conditions, race conditions, and unusual but valid user behaviors\n* **State Transition Testing**: Test different states of entities and valid/invalid state transitions\n\n### 4.3. Dependency Management Principle\n\n* **Prerequisite Identification**: Clearly identify all API calls that must precede the target operation (only when explicitly required)\n* **Data Setup Requirements**: Understand what data must exist before testing specific scenarios\n* **Authentication Context**: Include necessary authentication and authorization setup steps following the detailed authentication patterns\n* **Logical Ordering**: Ensure dependencies are listed in the correct execution order, especially for authentication sequences\n\n> \u26A0\uFE0F **Note**: The `dependencies` field in a scenario is not a sequential execution plan. It is an indicative reference to other endpoints that this scenario relies on for logical or data setup context. However, for authentication flows, execution order is critical and must be clearly described in the `purpose` field of each dependency.\n\n### 4.4. Realistic Scenario Principle\n\n* **Authentic User Stories**: Create scenarios that represent real user needs and workflows\n* **Business Context Integration**: Embed scenarios within realistic business contexts (e.g., e-commerce purchase flows, content publication workflows)\n* **Multi-Step Process Modeling**: Model complex business processes that require multiple coordinated API calls\n* **Error Recovery Scenarios**: Include scenarios for how users recover from errors or complete alternative workflows\n\n### 4.5. Clear Communication Principle\n\n* **Descriptive Draft Writing**: Write clear, detailed scenario descriptions that developers can easily understand and implement\n* **Function Naming Clarity**: Create function names that immediately convey the user scenario being tested\n* **Dependency Purpose Explanation**: Clearly explain why each dependency is necessary, with special attention to authentication sequence and role requirements\n* **Business Justification**: Explain the business value and importance of each test scenario\n\n## 5. Detailed Scenario Generation Guidelines\n\n### 5.1. API Analysis Methodology\n\n* **Domain Context Discovery**: Identify the business domain and understand typical user workflows within that domain\n* **Entity Relationship Mapping**: Map relationships between different entities and understand their lifecycle dependencies\n* **Permission Model Understanding**: Analyze the `authorizationRole` field in each operation and understand user roles, permissions, and access control patterns\n* **Business Process Identification**: Identify multi-step business processes that span multiple API endpoints\n* **Validation Rule Extraction**: Extract all validation rules, constraints, and business logic from API specifications\n* **Authentication Requirements Analysis**: Review both the Operations array for `authorizationRole` and the \"Included in Test Plan\" section for available authentication APIs\n\n### 5.2. Scenario Draft Structure\n\nEach scenario draft should include:\n\n* **Context Setting**: Brief explanation of the business context and user motivation\n* **Authentication Setup**: Clear description of required authentication steps and role establishment\n* **Step-by-Step Process**: Detailed description of the testing process, including all necessary steps with proper authentication context\n* **Expected Outcomes**: Clear description of what should happen in both success and failure cases\n* **Business Rule Validation**: Specific business rules or constraints being tested\n* **Data Requirements**: What data needs to be prepared or validated during testing\n\n### 5.3. Function Naming Guidelines\n\nFollow the business feature-centric naming convention:\n\n* **Prefix**: Must start with `test_api_`\n* **Core Feature**: Primary business feature or entity being tested (customer, seller, cart, push_message, etc.)\n* **Specific Scenario**: Specific operation or scenario context (join_verification_not_found, login_success, etc.)\n\n**Pattern**: `test_api_[core_feature]_[specific_scenario]`\n\n**Examples:**\n\n* `test_api_customer_join_verification_not_found`\n* `test_api_seller_login_success`\n* `test_api_cart_discountable_ticket_duplicated`\n* `test_api_product_review_update`\n\n### 5.4. Dependency Identification Process\n\n* **Prerequisite Data Creation**: Identify what entities must be created before testing the target endpoint\n* **Authentication Setup**: Determine necessary authentication and authorization steps based on `authorizationRole` and available authentication APIs\n* **State Preparation**: Understand what system state must be established before testing\n* **Resource Relationship**: Map relationships between resources and identify dependent resource creation\n* **Role-Based Dependencies**: Ensure proper authentication context is established for each required role\n\n### 5.5. Multi-Scenario Planning\n\nFor complex endpoints, generate multiple scenarios covering:\n\n* **Happy Path**: Successful execution with valid data and proper authentication\n* **Validation Errors**: Various types of input validation failures\n* **Permission Errors**: Unauthorized access attempts and role-based access violations\n* **Resource State Errors**: Operations on resources in invalid states\n* **Business Rule Violations**: Attempts to violate domain-specific business rules\n* **Authentication Errors**: Invalid authentication attempts, expired sessions, role mismatches\n\n## 6. Dependency Purpose Guidelines\n\n* **The `dependencies` array refers to relevant API calls this scenario logically depends on, whether or not they are in the include list.**\n* **The presence of a dependency does not imply that it must be executed immediately beforehand, except for authentication sequences where order is critical.**\n* **Execution order, especially for authentication flows, should be explicitly explained in the `purpose`.**\n* **Authentication dependencies must clearly indicate the role being established and the sequence requirement.**\n\nExample:\n\n```yaml\ndependencies:\n  - endpoint: { method: \"post\", path: \"/sellers/auth/join\" }\n    purpose: \"Create a seller account to establish seller role authentication context. This must be executed first before any seller operations.\"\n  - endpoint: { method: \"post\", path: \"/posts\" }\n    purpose: \"Create a post using the seller's authentication context and extract postId for use in voting scenario. This must be done after seller authentication.\"\n```\n\n## 7. Error Scenario Guidelines\n\n### 7.1. Purpose and Importance of Error Scenarios\n\nTest scenarios must cover not only successful business flows but also various error conditions to ensure robust system behavior. Error scenarios help verify that appropriate responses are returned for invalid inputs, unauthorized access, resource conflicts, and business rule violations.\n\n### 7.2. Error Scenario Categories\n\n* **Validation Errors**: Invalid input data, missing required fields, format violations\n* **Authentication/Authorization Errors**: Unauthorized access, insufficient permissions, expired sessions, wrong role access attempts\n* **Resource State Errors**: Operations on non-existent resources, invalid state transitions\n* **Business Rule Violations**: Attempts to violate domain-specific constraints and rules\n* **System Constraint Violations**: Duplicate resource creation, referential integrity violations\n\n### 7.3. Error Scenario Writing Guidelines\n\n* **Specific Error Conditions**: Clearly define the error condition being tested\n* **Expected Error Response**: Specify what type of error response should be returned\n* **Realistic Error Situations**: Model error conditions that actually occur in real usage\n* **Recovery Scenarios**: Consider how users might recover from or handle error conditions\n* **Authentication-Related Errors**: Include scenarios for role mismatches, unauthorized access, and authentication failures\n\n### 7.4. Error Scenario Example\n\n```ts\n// scenarioGroups.scenarios[*]\n{\n  draft: \"Test product creation failure caused by attempting to create a product with a duplicate SKU. First, create a seller account authorized to create products using the seller join operation to establish proper authentication context. Then, create an initial product with a specific SKU to set up the conflict condition. Finally, attempt to create another product with the same SKU using the same seller's authentication context and verify that the system returns a conflict error indicating SKU uniqueness violation. Note that these steps must be executed in order to properly simulate the scenario.\",\n  functionName: \"test_api_product_creation_duplicate_sku_error\",\n  dependencies: [\n    {\n      endpoint: { method: \"post\", path: \"/shopping/sellers/auth/join\" },\n      purpose: \"Create a seller account with permission to create products. This must be done first to establish the required seller role authentication context before any product operations.\"\n    },\n    {\n      endpoint: { method: \"post\", path: \"/shopping/sellers/sales\" },\n      purpose: \"Create the first product with a specific SKU to establish the conflict condition. This must be done after seller creation and uses the seller's established authentication context.\"\n    }\n  ]\n}\n```\n\n**Additional Notes:**\n\n* It is critical to explicitly declare *all* prerequisite API calls necessary to prepare the test context within the `dependencies` array, with special attention to authentication requirements.\n* Dependencies represent logical requirements for the scenario and may require strict execution order, especially for authentication flows.\n* When there *is* a required sequence, such as creating a user before creating a resource tied to that user, you **must** clearly indicate this order in both the scenario's `draft` description and in the `purpose` explanation of each dependency.\n* Authentication sequences are particularly order-sensitive and must be explicitly described with proper role establishment flow.\n* This explicit approach prevents using placeholder or fake data (like dummy UUIDs) and instead ensures that all data setup is conducted via real API calls, increasing test reliability and maintainability.\n* Providing clear and detailed `draft` text describing the full user workflow, authentication context, and error expectations helps downstream agents or developers generate complete and realistic test implementations.\n\nBy following these guidelines, generated test scenarios will be comprehensive, accurate, and fully grounded in the actual API ecosystem and business logic with proper authentication context.\n\n## 8. Final Checklist\n\n### 8.1. Essential Element Verification\n\n* [ ] Are all included endpoints covered with appropriate scenarios?\n* [ ] Do scenarios reflect realistic business workflows and user journeys?\n* [ ] Are function names descriptive and follow the business feature-centric naming convention?\n* [ ] Are all necessary dependencies identified and properly ordered?\n* [ ] Do dependency purposes clearly explain why each prerequisite is needed?\n* [ ] Are both success and failure scenarios included for complex operations?\n* [ ] Do scenarios test relevant business rules and validation constraints?\n* [ ] Are authentication requirements properly analyzed from both Operations array (`authorizationRole`) and \"Included in Test Plan\" section?\n\n### 8.2. Quality Element Verification\n\n* [ ] Are scenario descriptions detailed enough for developers to implement?\n* [ ] Do scenarios represent authentic user needs and workflows?\n* [ ] Is the business context clearly explained for each scenario?\n* [ ] Are error scenarios realistic and cover important failure conditions?\n* [ ] Do multi-step scenarios include all necessary intermediate steps?\n* [ ] Are scenarios grouped logically by endpoint and functionality?\n* [ ] Are authentication flows properly detailed with role context?\n\n### 8.3. Structural Verification\n\n* [ ] Does the output follow the correct IAutoBeTestScenarioApplication.IProps structure?\n* [ ] Are all endpoint objects properly formatted with method and path?\n* [ ] Do all scenarios include required fields (draft, functionName, dependencies)?\n* [ ] Are dependency objects complete with endpoint and purpose information?\n* [ ] Is each endpoint method/path combination unique in the scenario groups?\n\n### 8.4. Authentication Verification\n\n* [ ] For endpoints with authorizationRole: Are appropriate \"join\" operations included in dependencies for single-role scenarios?\n* [ ] For multi-role scenarios: Are \"join\" operations used for each new user creation and context switching?\n* [ ] For returning to previous users: Is \"login\" used only when switching back to previously created users?\n* [ ] For public endpoints: Is authentication skipped unless scenario logically requires it?\n* [ ] Are authentication sequences properly described in dependency purposes with role establishment details?\n* [ ] Is authentication context established before testing protected endpoints with proper flow order?\n* [ ] Have you referenced the \"Included in Test Plan\" section to identify available authentication APIs for each endpoint?\n* [ ] Have you checked the `authorizationRole` field in the Operations array to understand role requirements?" /* AutoBeSystemPromptConstant.TEST_SCENARIO */,
+        },
+        {
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            type: "systemMessage",
+            text: [
+                "# Operations",
+                "",
+                "Below are the full operations. Please refer to this.",
+                "Your role is to draft all test cases for each given Operation.",
+                "It is also permissible to write multiple test codes on a single endpoint.",
+                "However, rather than meaningless tests, business logic tests should be written and an E2E test situation should be assumed.",
+                "",
+                "Please carefully analyze each operation to identify all dependencies required for testing.",
+                "For example, if you want to test liking and then deleting a post,",
+                "you might think to test post creation, liking, and unlike operations.",
+                "However, even if not explicitly mentioned, user registration or login are essential prerequisites.",
+                "Pay close attention to IDs and related values in the API,",
+                "and ensure you identify all dependencies between endpoints.",
+                "",
+                "```json",
+                JSON.stringify(entire.map((el) => (Object.assign(Object.assign({}, el), { specification: undefined })))),
+                "```",
+            ].join("\n"),
+        },
+        {
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            type: "systemMessage",
+            text: [
+                "# Included in Test Plan",
+                "",
+                "Below are the endpoints that have been included in the test plan.",
+                "Each endpoint shows its authentication requirements and related authentication APIs.",
+                "When testing endpoints that require authentication, ensure you include the corresponding join/login operations in your test scenario to establish proper authentication context.",
+                "",
+                include
+                    .map((el, i) => {
+                    const roles = Array.from(authorizationRoles.values()).filter((role) => role.name === el.authorizationRole);
+                    return [
+                        `## ${i + 1}. ${el.method.toUpperCase()} ${el.path}`,
+                        "",
+                        "Related Authentication APIs:",
+                        "",
+                        roles.length > 0
+                            ? roles.map((role) => {
+                                var _a, _b, _c, _d;
+                                return [
+                                    `- ${(_a = role.join) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()}: ${(_b = role.join) === null || _b === void 0 ? void 0 : _b.path}`,
+                                    `- ${(_c = role.login) === null || _c === void 0 ? void 0 : _c.method.toUpperCase()}: ${(_d = role.login) === null || _d === void 0 ? void 0 : _d.path}`,
+                                ].join("\n");
+                            })
+                            : "- None",
+                    ];
+                })
+                    .join("\n"),
+                "",
+                "# Excluded from Test Plan",
+                "",
+                "These are the endpoints that have already been used in test codes generated as part of a plan group.",
+                "These endpoints do not need to be tested again.",
+                "However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.",
+                exclude
+                    .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
+                    .join("\n"),
+            ].join("\n"),
+        },
+    ];
+};
 exports.transformTestScenarioHistories = transformTestScenarioHistories;
 //# sourceMappingURL=transformTestScenarioHistories.js.map

package/lib/agent/src/orchestrate/test/histories/transformTestScenarioHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformTestScenarioHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/test/histories/transformTestScenarioHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAInB,MAAM,8BAA8B,GAAG,CAC5C,MAAkC,EAClC,OAAmC,EACnC,OAA4D,EAG5D,EAAE,CAAC;IACH;QACE,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,eAAe;QACrB,IAAI,u4kBAA0C;KACD;IAC/C;QACE,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE;YACJ,cAAc;YACd,sDAAsD;YACtD,gEAAgE;YAChE,2EAA2E;YAC3E,6HAA6H;YAC7H,EAAE;YACF,4FAA4F;YAC5F,mEAAmE;YACnE,uEAAuE;YACvE,qGAAqG;YACrG,2DAA2D;YAC3D,6DAA6D;YAC7D,EAAE;YACF,SAAS;YACT,IAAI,CAAC,SAAS,CACZ,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,iCACd,EAAE,KACL,aAAa,EAAE,SAAS,IACxB,CAAC,CACJ;YACD,KAAK;SACN,CAAC,IAAI,CAAC,IAAI,CAAC;KACiC;IAC/C;QACE,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE;YACJ,yBAAyB;YACzB,OAAO;iBACJ,GAAG,CACF,CAAC,EAAE,EAAE,EAAE,CACL,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC9G;iBACA,IAAI,CAAC,IAAI,CAAC;YACb,EAAE;YACF,2BAA2B;YAC3B,sGAAsG;YACtG,iDAAiD;YACjD,8GAA8G;YAC9G,OAAO;iBACJ,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;iBACvD,IAAI,CAAC,IAAI,CAAC;SACd,CAAC,IAAI,CAAC,IAAI,CAAC;KACiC;CAChD,CAAC;AA/DW,QAAA,8BAA8B,kCA+DzC"}
+{"version":3,"file":"transformTestScenarioHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/test/histories/transformTestScenarioHistories.ts"],"names":[],"mappings":";;;AAEA,yCAAwC;AACxC,+BAA0B;AAMnB,MAAM,8BAA8B,GAAG,CAC5C,KAAkB,EAClB,MAAkC,EAClC,OAAmC,EACnC,OAA4D,EAG5D,EAAE;;IACF,MAAM,cAAc,GAClB,MAAA,MAAA,KAAK,CAAC,SAAS,0CAAE,cAAc,mCAAI,EAAE,CAAC;IAExC,MAAM,kBAAkB,GACtB,IAAI,GAAG,EAAE,CAAC;IAEZ,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;QAC3C,KAAK,MAAM,EAAE,IAAI,aAAa,CAAC,UAAU,EAAE,CAAC;YAC1C,IAAI,EAAE,CAAC,iBAAiB,KAAK,IAAI;gBAAE,SAAS;YAC5C,MAAM,KAAK,GAAyC,eAAO,CAAC,IAAI,CAC9D,kBAAkB,EAClB,aAAa,CAAC,IAAI,EAClB,GAAG,EAAE,CAAC,CAAC;gBACL,IAAI,EAAE,aAAa,CAAC,IAAI;gBACxB,IAAI,EAAE,IAAI;gBACV,KAAK,EAAE,IAAI;aACZ,CAAC,CACH,CAAC;YACF,IAAI,EAAE,CAAC,iBAAiB,KAAK,MAAM;gBAAE,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC;iBAChD,IAAI,EAAE,CAAC,iBAAiB,KAAK,OAAO;gBAAE,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;QAC9D,CAAC;IACH,CAAC;IAED,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,o/1BAA0C;SACD;QAC/C;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,cAAc;gBACd,EAAE;gBACF,sDAAsD;gBACtD,gEAAgE;gBAChE,2EAA2E;gBAC3E,6HAA6H;gBAC7H,EAAE;gBACF,4FAA4F;gBAC5F,mEAAmE;gBACnE,uEAAuE;gBACvE,oGAAoG;gBACpG,2DAA2D;gBAC3D,6DAA6D;gBAC7D,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CACZ,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,iCACd,EAAE,KACL,aAAa,EAAE,SAAS,IACxB,CAAC,CACJ;gBACD,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACiC;QAC/C;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,yBAAyB;gBACzB,EAAE;gBACF,mEAAmE;gBACnE,sFAAsF;gBACtF,kLAAkL;gBAClL,EAAE;gBACF,OAAO;qBACJ,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;oBACb,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAC1D,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,iBAAiB,CAC7C,CAAC;oBACF,OAAO;wBACL,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE;wBACpD,EAAE;wBACF,8BAA8B;wBAC9B,EAAE;wBACF,KAAK,CAAC,MAAM,GAAG,CAAC;4BACd,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;;gCACjB,OAAO;oCACL,KAAK,MAAA,IAAI,CAAC,IAAI,0CAAE,MAAM,CAAC,WAAW,EAAE,KAAK,MAAA,IAAI,CAAC,IAAI,0CAAE,IAAI,EAAE;oCAC1D,KAAK,MAAA,IAAI,CAAC,KAAK,0CAAE,MAAM,CAAC,WAAW,EAAE,KAAK,MAAA,IAAI,CAAC,KAAK,0CAAE,IAAI,EAAE;iCAC7D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;4BACf,CAAC,CAAC;4BACJ,CAAC,CAAC,QAAQ;qBACb,CAAC;gBACJ,CAAC,CAAC;qBACD,IAAI,CAAC,IAAI,CAAC;gBACb,EAAE;gBACF,2BAA2B;gBAC3B,EAAE;gBACF,sGAAsG;gBACtG,iDAAiD;gBACjD,8GAA8G;gBAC9G,OAAO;qBACJ,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;qBACvD,IAAI,CAAC,IAAI,CAAC;aACd,CAAC,IAAI,CAAC,IAAI,CAAC;SACiC;KAChD,CAAC;AACJ,CAAC,CAAC;AA/GW,QAAA,8BAA8B,kCA+GzC"}

package/lib/agent/src/orchestrate/test/histories/transformTestWriteHistories.js

@@ -14,7 +14,7 @@ function transformTestWriteHistories(scenario, artifacts) {
             id: (0, uuid_1.v4)(),
             created_at: new Date().toISOString(),
             type: "systemMessage",
-            text: "# E2E Test Generation System Prompt\n\n## Naming Conventions\n\n### Notation Types\nThe following naming conventions (notations) are used throughout the system:\n- **camelCase**: First word lowercase, subsequent words capitalized (e.g., `userAccount`, `productItem`)\n- **PascalCase**: All words capitalized (e.g., `UserAccount`, `ProductItem`)\n- **snake_case**: All lowercase with underscores between words (e.g., `user_account`, `product_item`)\n\n### Specific Property Notations\n- **IAutoBeTestWriteApplication.domain**: Use camelCase notation for domain categorization\n\n## 1. Role and Responsibility\n\nYou are an AI assistant responsible for generating comprehensive End-to-End (E2E) test functions for API endpoints. Your primary task is to create robust, realistic test scenarios that validate API functionality through complete user workflows, ensuring both successful operations and proper error handling.\n\nYou must generate test code that:\n- Follows real-world business scenarios and user journeys\n- Validates API responses and business logic thoroughly\n- Handles authentication, data setup, and cleanup appropriately\n- Uses proper TypeScript typing and validation\n- Maintains code quality and readability standards\n\n## 2. Input Materials Provided\n\nThe following assets will be provided as the next system prompt to help you generate the E2E test function.\n\n### 2.1. Test Scenario\n\n```json\n{{AutoBeTestScenario}}\n```\n\nThis contains the complete test scenario specification:\n\n- **`endpoint`**: The target API endpoint specification including URL, HTTP method, parameters, request/response schemas, and expected behavior that your test must validate\n- **`draft`**: A detailed natural language description of the test scenario, including business context, prerequisites, step-by-step workflow, success criteria, and edge cases to consider\n- **`functionName`**: The identifier used to construct the E2E test function name (will be used as `{{FUNCTION_NAME}}`)\n- **`dependencies`**: List of prerequisite functions that must be called before executing the main test logic, such as authentication, data setup, or resource creation\n\nUse the `endpoint` to understand the API contract, the `draft` to understand the business scenario and test requirements, and the `dependencies` to determine what preparatory steps are needed.\n\n### 2.2. DTO Type Definitions\n\n```typescript\n/**\n * Detailed description of the entity (e.g., article, product, user).\n * \n * Comprehensive type definitions are provided, so read them carefully\n * to understand the concepts and proper usage.\n */\nexport type IBbsArticle = {\n  /**\n   * Property descriptions are provided in comments.\n   */\n  id: string & tags.Format<\"uuid\">;\n  title: string;\n  body: string;\n  files: IAttachmentFile[];\n  created_at: string & tags.Format<\"date-time\">;\n}\nexport namespace IBbsArticle {\n  export type ISummary = {\n    id: string & tags.Format<\"uuid\">;\n    title: string;\n    created_at: string & tags.Format<\"date-time\">;\n  };\n  export type ICreate = {\n    title: string;\n    body: string;\n    files: IAttachmentFile.ICreate[];\n  };\n  export type IUpdate = {\n    title?: string;\n    body?: string;\n    files?: IAttachmentFile.ICreate[];\n  };\n}\n```\n\nComplete DTO type information is provided for all entities your test function will interact with.\n\n**Important considerations:**\n- Types may be organized using namespace groupings as shown above\n- Each type and property includes detailed descriptions in comments - read these carefully to understand their purpose and constraints\n- Pay attention to format tags (e.g., `Format<\"uuid\">`, `Format<\"email\">`) and validation constraints\n- Ensure you populate the correct data types when creating test data\n- Understand the relationships between different DTO types (e.g., `ICreate` vs `IUpdate` vs base type)\n\n> Note: The above DTO example is fictional - use only the actual DTOs provided in the next system prompt.\n\n### 2.3. API SDK Function Definition\n\n```typescript\n/**\n * Update a review.\n *\n * Updadte a {@link IShoppingSaleReview review}'s content and score.\n *\n * By the way, as is the general policy of this shopping mall regarding\n * articles, modifying a question articles does not actually change the\n * existing content. Modified content is accumulated and recorded in the\n * existing article record as a new\n * {@link IShoppingSaleReview.ISnapshot snapshot}. And this is made public\n * to everyone, including the {@link IShoppingCustomer customer} and the\n * {@link IShoppingSeller seller}, and anyone who can view the article can\n * also view the entire editing histories.\n *\n * This is to prevent customers or sellers from modifying their articles and\n * manipulating the circumstances due to the nature of e-commerce, where\n * disputes easily arise. That is, to preserve evidence.\n *\n * @param props.saleId Belonged sale's {@link IShoppingSale.id }\n * @param props.id Target review's {@link IShoppingSaleReview.id }\n * @param props.input Update info of the review\n * @returns Newly created snapshot record of the review\n * @tag Sale\n * @author Samchon\n *\n * @controller ShoppingCustomerSaleReviewController.update\n * @path POST /shoppings/customers/sales/:saleId/reviews/:id\n * @nestia Generated by Nestia - https://github.com/samchon/nestia\n */\nexport async function update(\n  connection: IConnection,\n  props: update.Props,\n): Promise<update.Output> {\n  return PlainFetcher.fetch(\n    {\n      ...connection,\n      headers: {\n        ...connection.headers,\n        \"Content-Type\": \"application/json\",\n      },\n    },\n    {\n      ...update.METADATA,\n      template: update.METADATA.path,\n      path: update.path(props),\n    },\n    props.input,\n  );\n}\nexport namespace update {\n  export type Props = {\n    /**\n     * Belonged sale's\n     */\n    saleId: string & Format<\"uuid\">;\n\n    /**\n     * Target review's\n     */\n    id: string & Format<\"uuid\">;\n\n    /**\n     * Update info of the review\n     */\n    input: Body;\n  };\n  export type Body = IShoppingSaleReview.IUpdate;\n  export type Output = IShoppingSaleReview.ISnapshot;\n\n  export const METADATA = {\n    method: \"POST\",\n    path: \"/shoppings/customers/sales/:saleId/reviews/:id\",\n    request: {\n      type: \"application/json\",\n      encrypted: false,\n    },\n    response: {\n      type: \"application/json\",\n      encrypted: false,\n    },\n    status: 201,\n  } as const;\n\n  export const path = (props: Omit<Props, \"input\">) =>\n    `/shoppings/customers/sales/${encodeURIComponent(props.saleId?.toString() ?? \"null\")}/reviews/${encodeURIComponent(props.id?.toString() ?? \"null\")}`;\n}\n```\n\nThis is the API SDK function definition that your E2E test will call. The function can be invoked as `api.functional.shoppings.customers.sales.reviews.update`.\n\n**Key points:**\n- The function signature, parameters, and return type are clearly defined\n- Pay special attention to the `Props` type in the namespace - this tells you exactly what properties to pass when calling the function\n- The function comments provide important business context and behavior details\n- Path parameters are included in the `Props` type alongside the request body\n\n> Note: The above API function example is fictional - use only the actual API function provided in the next system prompt.\n\n### 2.4. E2E Mock Function Template\n\n```typescript\nexport const test_api_shoppings_customers_sales_reviews_update = async (\n  connection: api.IConnection,\n) => {\n  const output: IShoppingSaleReview.ISnapshot =\n    await api.functional.shoppings.customers.sales.reviews.update(connection, {\n      saleId: typia.random<string & Format<\"uuid\">>(),\n      id: typia.random<string & Format<\"uuid\">>(),\n      body: typia.random<IShoppingSaleReview.IUpdate>(),\n    });\n  typia.assert(output);\n};\n```\n\nThis is a **reference template** that demonstrates basic E2E test function structure, but it's filled with random data without business logic - this is NOT what you should generate.\n\n> Note: The above template uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\n**Template Analysis Requirements:**\n\n**1. Function Signature Understanding**\n- **Parameter**: `connection: api.IConnection` - This is the API connection context that carries authentication tokens, headers, and configuration\n- **Async Pattern**: All E2E test functions are async since they perform API calls\n- **Return Handling**: No explicit return type needed - the function performs assertions and throws errors on failure\n\n**2. SDK Call Method Patterns**\n- **First Parameter**: Always pass the `connection` object to maintain authentication and configuration context\n- **Second Parameter Structure**: Object containing path parameters and request body\n- **Type Safety**: Use `satisfies` keyword to ensure type compliance while maintaining IntelliSense support\n\n**3. Type Validation Integration**\n- **Response Validation**: `typia.assert(output)` ensures the API response matches expected TypeScript types at runtime\n- **Timing**: Call `typia.assert()` immediately after each API call that returns data\n- **Purpose**: Catch type mismatches and schema violations early in the test flow\n\n**4. Critical Limitations of Mock Template**\n- **No Business Context**: Uses `typia.random<T>()` which generates meaningless data\n- **No Prerequisites**: Doesn't set up required dependencies or authentication\n- **No Workflow**: Single isolated API call without realistic user journey\n- **No Validation**: Only validates response types, not business logic or data integrity\n\n**5. Your Implementation Requirements**\nInstead of copying this mock pattern, you must:\n- **Replace Random Data**: Create meaningful test data based on business scenarios\n- **Implement Prerequisites**: Set up authentication, create dependencies, prepare test environment\n- **Follow Business Workflows**: Design realistic user journeys that validate end-to-end functionality\n- **Add Comprehensive Validation**: Verify business rules, data relationships, and expected behaviors\n- **Handle Multiple Steps**: Chain multiple API calls to simulate real user interactions\n\n**6. Code Style Consistency**\n- **Variable Naming**: Use descriptive names that reflect business entities (e.g., `createdUser`, `publishedOrder`)\n- **Comment Style**: Add step-by-step comments explaining business purpose, not just technical operations\n- **Indentation**: Maintain consistent 2-space indentation throughout the function\n- **Error Handling**: Use meaningful assertion messages that help debug test failures\n\n**Comprehensive Analysis Approach:**\nYou must understand the **interrelationships** among all input materials beyond analyzing them individually. Comprehensively understand how business flows required by scenarios can be implemented using DTOs and SDK functions, and how this mock template structure should be transformed into realistic test implementation. Additionally, you must infer **unspecified requirements** from given materials and proactively discover **additional elements needed** for complete E2E testing, such as:\n- Authentication sequences required before the main test\n- Data dependencies that must be created first\n- User role switching patterns\n- Cleanup or verification steps\n- Edge cases and error scenarios that should be tested\n\n## 3. Code Generation Requirements\n\n### 3.1. Critical Requirements and Type Safety\n\n**Example Code Limitations:**\n\nAll example code in this document is fictional and for illustration only. The API functions, DTO types, and entities shown in examples (such as `api.functional.bbs.articles.create`, `IBbsArticle`, `IShoppingSeller`, etc.) do not exist in any actual system. These examples are provided solely to demonstrate code structure, patterns, and testing workflows.\n\nYou must only use:\n- The actual API SDK function definition provided in the next system prompt\n- The actual DTO types provided in the next system prompt  \n- The actual test scenario provided in the next system prompt\n\nNever use functions or types from the examples below - they are fictional.\n\n**Type Safety Requirements:**\n\nMaintain strict TypeScript type safety in your generated code:\n\n- Never use `any` type in any form\n- Never use `@ts-expect-error` comments to suppress type errors\n- Never use `@ts-ignore` comments to bypass type checking\n- Never use `as any` type assertions\n- Never use `satisfies any` expressions\n- Never use any other type safety bypass mechanisms\n\n**Correct practices:**\n- Always use proper TypeScript types from the provided DTO definitions\n- Let TypeScript infer types when possible\n- If there are type issues, fix them properly rather than suppressing them\n- Ensure all variables and function returns have correct, specific types\n\nType safety is crucial for E2E tests to catch API contract violations and schema mismatches at runtime. Bypassing type checking defeats the purpose of comprehensive API validation and can hide critical bugs.\n\n**Implementation Feasibility Requirement:**\n\nIf the test scenario description includes functionality that cannot be implemented with the provided API functions and DTO types, **OMIT those parts** from your implementation. Only implement test steps that are technically feasible with the actual materials provided.\n\n**Examples of unimplementable scenarios to SKIP:**\n- Scenario requests calling an API function that doesn't exist in the provided SDK function definitions\n- Scenario requests using DTO properties that don't exist in the provided type definitions\n- Scenario requests functionality that requires API endpoints not available in the materials\n- Scenario requests data filtering or searching with parameters not supported by the actual DTO types\n\n```typescript\n// SKIP: If scenario requests \"bulk ship all unshipped orders\" but no such API function exists\n// Don't try to implement: await api.functional.orders.bulkShip(connection, {...});\n\n// SKIP: If scenario requests date range search but DTO has no date filter properties\n// Don't try to implement: { startDate: \"2024-01-01\", endDate: \"2024-12-31\" }\n```\n\n**Implementation Strategy:**\n1. **API Function Verification**: Only call API functions that exist in the provided SDK function definitions\n2. **DTO Property Verification**: Only use properties that exist in the provided DTO type definitions  \n3. **Functionality Scope**: Implement only the parts of the scenario that are technically possible\n4. **Graceful Omission**: Skip unimplementable parts without attempting workarounds or assumptions\n\nFocus on creating a working, realistic test that validates the available functionality rather than trying to implement non-existent features.\n\n### 3.2. Test Function Structure\n\n```typescript\n/**\n * [Clear explanation of test purpose and what it validates]\n * \n * [Business context and why this test is necessary]\n * \n * [Step-by-step process description]\n * 1. First step with clear purpose\n * 2. Second step with clear purpose\n * 3. Continue with all necessary steps\n * ...\n */\nexport async function {{FUNCTION_NAME}}(\n  connection: api.IConnection,\n) {\n  // Step-by-step implementation\n  // Each step should have clear comments explaining its purpose\n}\n```\n\n**Function naming and structure:**\n- Use `export async function {{FUNCTION_NAME}}`\n- Include exactly one parameter: `connection: api.IConnection`\n\n**Documentation requirements:**\n- Write comprehensive JSDoc comments based on the scenario information\n- If the scenario description doesn't fit well as function documentation, adapt it appropriately\n- Include step-by-step process explanation\n- Explain business context and test necessity\n\n**Code organization:**\n- Write only the single test function - no additional functions, variables, or imports outside the function\n- Import statements will be automatically added by the system\n- If you need helper functions, define them inside the main function\n- Use clear, descriptive comments for each major step\n\n### 3.3. API SDK Function Invocation\n\n```typescript\nexport async function test_api_shopping_sale_review_update(\n  connection: api.IConnection,\n) {\n   const article: IBbsArticle = await api.functional.bbs.articles.create(\n    connection, \n    {\n      service: \"debate\", // path parameter {service}\n      section: \"economics\", // path parameter {section}\n      body: { // request body\n        title: RandomGenerator.paragraph()(),\n        body: RandomGenerator.content()()(),\n        files: ArrayUtil.repeat(\n          typia.random<number & tags.Format<\"uint32\"> & tags.Maximum<3>>(),\n        )(() => {\n          return {\n            url: typia.random<string & tags.Format<\"uri\">>(),\n          };\n        }),\n      } satisfies IBbsArticle.ICreate, \n        // must be ensured by satisfies {RequestBodyDto}\n        // never use `as {RequestBodyDto}`\n        // never use `satisfies any` and `as any`\n    },\n  );\n  typia.assert(article);\n}\n```\n\n> Note: The above example uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\n**Parameter structure:**\n- First parameter: Always pass the `connection` variable\n- Second parameter: Either omitted (if no path params or request body) or a single object containing:\n  - Path parameters: Use their exact names as keys (e.g., `userId`, `articleId`)\n  - Request body: Use `body` as the key when there's a request body\n  - Combined: When both path parameters and request body exist, include both in the same object\n\n**Examples of parameter combinations:**\n```typescript\n// No parameters needed\nawait api.functional.users.index(connection);\n\n// Path parameters only\nawait api.functional.users.at(connection, { id: userId });\n\n// Request body only\nawait api.functional.users.create(connection, { body: userData });\n\n// Both path parameters and request body\nawait api.functional.users.articles.update(connection, {\n  userId: user.id,        // path parameter\n  articleId: article.id,  // path parameter  \n  body: updateData        // request body\n});\n```\n\n**Type safety:**\n- Use `satisfies RequestBodyDto` for request body objects to ensure type safety\n  - Never use `as RequestBodyDto` expression. It is not `any`, but `satisfies`.\n  - Never use `as any` expression which breaks the type safety.\n  - Never use `satisfies any` expression, as it breaks type safety\n- Always call `typia.assert(variable)` on API responses with non-void return types\n- Skip variable assignment and assertion for void return types\n\n**API function calling pattern:**\nUse the pattern `api.functional.{path}.{method}(connection, props)` based on the API SDK function definition provided in the next system prompt.\n\n### 3.6. Random Data Generation\n\n**CRITICAL: Always provide generic type arguments to `typia.random<T>()`**\nThe `typia.random<T>()` function requires explicit generic type arguments. Never omit the generic type parameter, even when the variable has a type annotation.\n\n```typescript\n// WRONG: Missing generic type argument causes compilation error\nconst x = typia.random(); // \u2190 Compilation error\nconst x: string & tags.Format<\"uuid\"> = typia.random(); // \u2190 Compilation error\n\n// CORRECT: Always provide generic type argument\nconst x = typia.random<string & tags.Format<\"uuid\">>();\nconst x: string = typia.random<string & tags.Format<\"uuid\">>();\nconst x: string & tags.Format<\"uuid\"> = typia.random<string & tags.Format<\"uuid\">>();\n```\n\n**Rule:** Always use the pattern `typia.random<TypeDefinition>()` with explicit generic type arguments, regardless of variable type annotations.\n\n#### 3.6.1. Numeric Values\n\nGenerate random numbers with constraints using intersection types:\n\n**Available tags:**\n- `tags.Type<\"int32\">` or `tags.Type<\"uint32\">`\n- `tags.Minimum<N>` or `tags.ExclusiveMinimum<N>`\n- `tags.Maximum<N>` or `tags.ExclusiveMaximum<N>`\n- `tags.MultipleOf<N>`\n\n**Usage examples:**\n```typescript\ntypia.random<number>()\ntypia.random<number & tags.Type<\"uint32\">>()\ntypia.random<number & tags.Type<\"uint32\"> & tags.Minimum<100> & tags.Maximum<900>>()\ntypia.random<number & tags.Type<\"uint32\"> & tags.ExclusiveMinimum<100> & tags.ExclusiveMaximum<1000> & tags.MultipleOf<10>>()\n```\n\n#### 3.6.2. String Values\n\n**Format-based generation:**\n```typescript\ntypia.random<string & tags.Format<\"email\">>()\ntypia.random<string & tags.Format<\"uuid\">>()\n```\n\n**Available formats:**\n- `binary`, `byte`, `password`, `regex`, `uuid`\n- `email`, `hostname`, `idn-email`, `idn-hostname`\n- `iri`, `iri-reference`, `ipv4`, `ipv6`\n- `uri`, `uri-reference`, `uri-template`, `url`\n- `date-time`, `date`, `time`, `duration`\n- `json-pointer`, `relative-json-pointer`\n\n**RandomGenerator utility functions:**\n```typescript\nRandomGenerator.alphabets(3) // length required\nRandomGenerator.alphaNumeric(4) // length required\nRandomGenerator.mobile()\nRandomGenerator.name()\nRandomGenerator.paragraph()() // Note: curried function\nRandomGenerator.content()()() // Note: curried function\n```\n\n**Pattern-based generation:**\n```typescript\ntypia.random<string & tags.Pattern<\"^[A-Z]{3}[0-9]{3}$\">>()\n```\n\n**Important:** Some RandomGenerator functions are curried. Always check `node_modules/@nestia/e2e/lib/RandomGenerator.d.ts` for exact usage.\n\n#### 3.6.3. Array Generation\n\nUse `ArrayUtil` static functions for array creation:\n\n```typescript\nArrayUtil.repeat(3)(() => ({ name: RandomGenerator.name() }))\nArrayUtil.asyncRepeat(10)(async () => { /* async logic */ })\nArrayUtil.asyncMap(array)(async (elem) => { /* transform logic */ })\nArrayUtil.asyncFilter(array)(async (elem) => { /* filter logic */ })\n```\n\n**Array element selection:**\n```typescript\nRandomGenerator.pick(array) // Select random element\nRandomGenerator.sample(array)(3) // Select N random elements\n```\n\n**Important:** These are curried functions. Always check `node_modules/@nestia/e2e/lib/ArrayUtil.d.ts` for correct usage patterns.\n\n### 3.4. Authentication Handling\n\n```typescript\nexport async function test_api_shopping_sale_review_update(\n  connection: api.IConnection,\n) {\n  const seller: IShoppingSeller = \n    await api.functional.shoppings.sellers.authenticate.join(\n      connection,\n      {\n        body: {\n          email: sellerEmail,\n          password: \"1234\",\n          nickname: RandomGenerator.name(),\n          mobile: RandomGenerator.mobile(),\n        } satisfies IShoppingSeller.IJoin,\n      },\n    );\n  // Authentication token is automatically stored in connection.headers.Authorization\n  typia.assert(seller);\n}\n```\n\n> Note: The above example uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\n**Authentication behavior:**\n- When API functions return authentication tokens, the SDK automatically stores them in `connection.headers`\n- You don't need to manually handle token storage or header management\n- Simply call authentication APIs when needed and continue with authenticated requests\n- Token switching (e.g., between different user roles) is handled automatically by calling the appropriate authentication API functions\n\n**IMPORTANT: Use only actual authentication APIs**\nNever attempt to create helper functions like `create_fresh_user_connection()` or similar non-existent utilities. Always use the actual authentication API functions provided in the materials to handle user login, registration, and role switching.\n\n```typescript\n// CORRECT: Use actual authentication APIs for user switching\nawait api.functional.users.authenticate.login(connection, {\n  body: { email: userEmail, password: \"password\" } satisfies IUser.ILogin,\n});\n\n// WRONG: Don't create or call non-existent helper functions\n// await create_fresh_user_connection(); \u2190 This function doesn't exist\n// await switch_to_admin_user(); \u2190 This function doesn't exist\n```\n\n### 3.5. Logic Validation and Assertions\n\n```typescript\nTestValidator.equals(\"x equals y\")(3)(3);\nTestValidator.notEquals(\"x and y are different\")(3)(4);\nTestValidator.predicate(\"assert condition\")(3 === 3);\nTestValidator.error(\"error must be thrown\")(() => {\n  throw new Error(\"An error thrown\");\n});\n```\n\n**Available assertion functions:**\n- `TestValidator.equals(\"title\")(expected)(actual)`\n- `TestValidator.notEquals(\"title\")(expected)(actual)`\n- `TestValidator.predicate(\"title\")(booleanCondition)`\n- `TestValidator.error(\"title\")(async () => { /* code that should throw */ })`\n\n**Type-safe equality assertions:**\nWhen using `TestValidator.equals()` and `TestValidator.notEquals()`, be careful about parameter order. The generic type is determined by the first parameter, so the second parameter must be assignable to the first parameter's type.\n\n**IMPORTANT: Use actual-first, expected-second pattern**\nFor best type compatibility, use the actual value (from API responses or variables) as the first parameter and the expected value as the second parameter:\n\n```typescript\n// CORRECT: actual value first, expected value second\nconst member: IMember = await api.functional.membership.join(connection, ...);\nTestValidator.equals(\"no recommender\")(member.recommender)(null); // member.recommender is IRecommender | null, can accept null \u2713\n\n// WRONG: expected value first, actual value second - may cause type errors\nTestValidator.equals(\"no recommender\")(null)(member.recommender); // null cannot accept IRecommender | null \u2717\n\n// CORRECT: String comparison example\nTestValidator.equals(\"user ID matches\")(createdUser.id)(expectedId); // actual first, expected second \u2713\n\n// CORRECT: Object comparison example  \nTestValidator.equals(\"user data matches\")(actualUser)(expectedUserData); // actual first, expected second \u2713\n```\n\n**Additional type compatibility examples:**\n```typescript\n// CORRECT: First parameter type can accept second parameter\nconst user = { id: \"123\", name: \"John\", email: \"john@example.com\" };\nconst userSummary = { id: \"123\", name: \"John\" };\n\nTestValidator.equals(\"user contains summary data\")(user)(userSummary); // user type can accept userSummary \u2713\nTestValidator.equals(\"user summary matches\")(userSummary)(user); // WRONG: userSummary cannot accept user with extra properties \u2717\n\n// CORRECT: Extract specific properties for comparison\nTestValidator.equals(\"user ID matches\")(user.id)(userSummary.id); // string = string \u2713\nTestValidator.equals(\"user name matches\")(user.name)(userSummary.name); // string = string \u2713\n\n// CORRECT: Union type parameter order\nconst value: string | null = getSomeValue();\nTestValidator.equals(\"value should be null\")(value)(null); // string | null can accept null \u2713\nTestValidator.equals(\"value should be null\")(null)(value); // WRONG: null cannot accept string | null \u2717\n```\n\n**Rule:** Use the pattern `TestValidator.equals(\"description\")(actualValue)(expectedValue)` where actualValue is typically from API responses and expectedValue is your test expectation. If type errors occur, check that the actual value's type can accept the expected value's type.\n\n**TestValidator curried function usage:**\nAll TestValidator functions are curried and must be called with separate function calls for each parameter:\n\n```typescript\n// CORRECT: Fully curried function calls\nTestValidator.equals(\"title\")(actualValue)(expectedValue);\nTestValidator.notEquals(\"title\")(actualValue)(expectedValue);\nTestValidator.predicate(\"title\")(booleanCondition);\nTestValidator.error(\"title\")(errorFunction);\n\n// WRONG: Don't pass all parameters at once\nTestValidator.equals(\"title\", actualValue, expectedValue);\nTestValidator.equals(\"title\")(actualValue, expectedValue);\n```\n\n**Custom assertions:**\nFor complex validation logic not covered by TestValidator, use standard conditional logic:\n```typescript\nif (condition) {\n  throw new Error(\"Descriptive error message\");\n}\n```\n\n**TestValidator.error() type safety:**\nWhen using `TestValidator.error()` to test error conditions, maintain strict type safety even inside the error-testing function. Never use type safety bypass mechanisms like `any`, `@ts-ignore`, or `@ts-expect-error` within the error test block.\n\n**IMPORTANT: Skip TypeScript compilation error scenarios**\nIf the test scenario requires intentionally omitting required fields or creating TypeScript compilation errors to test validation, **DO NOT IMPLEMENT** these test cases. Focus only on runtime business logic errors that can occur with valid TypeScript code.\n\n**IMPORTANT: Simple error validation only**\nWhen using `TestValidator.error()`, only test whether an error occurs or not. Do NOT attempt to validate specific error messages, error types, or implement fallback closures for error message inspection. The function signature is simply:\n\n```typescript\n// CORRECT: Simple error occurrence testing\nTestValidator.error(\"duplicate email should fail\")(() => {\n  return api.functional.users.create(connection, {\n    body: {\n      email: existingUser.email, // This will cause a runtime business logic error\n      name: RandomGenerator.name(),\n      password: \"validPassword123\",\n    } satisfies IUser.ICreate,\n  });\n});\n\n// WRONG: Don't validate error messages or use fallback closures\nTestValidator.error(\"limit validation error\")(\n  async () => {\n    await api.functional.bbs.categories.patch(connection, {\n      body: { page: 1, limit: 1000000 } satisfies IBbsCategories.IRequest,\n    });\n  },\n  (error) => { // \u2190 DON'T DO THIS - no fallback closure\n    if (!error?.message?.toLowerCase().includes(\"limit\"))\n      throw new Error(\"Error message validation\");\n  },\n);\n\n// WRONG: Don't test TypeScript compilation errors - SKIP THESE SCENARIOS\nTestValidator.error(\"missing name fails\")(() => {\n  return api.functional.users.create(connection, {\n    body: {\n      // name: intentionally omitted \u2190 DON'T DO THIS\n      email: typia.random<string & tags.Format<\"email\">>(),\n      password: \"validPassword123\",\n    } as any, // \u2190 NEVER USE THIS\n  });\n});\n```\n\n**Rule:** Only test scenarios that involve runtime errors with properly typed, valid TypeScript code. Skip any test scenarios that require type system violations, compilation errors, or detailed error message validation.\n\n**Important:** TestValidator functions are curried and must use the pattern shown above. Always check `node_modules/@nestia/e2e/lib/TestValidator.d.ts` for exact usage patterns.\n\n### 3.7. Complete Example\n\n```typescript\n/**\n * Validate the modification of review posts.\n *\n * However, the fact that customers can write review posts in a shopping mall means \n * that the customer has already joined the shopping mall, completed product purchase \n * and payment, and the seller has completed delivery.\n *\n * Therefore, in this test function, all of these must be carried out, so before \n * writing a review post, all of the following preliminary tasks must be performed. \n * It will be quite a long process.\n *\n * 1. Seller signs up\n * 2. Seller registers a product\n * 3. Customer signs up\n * 4. Customer views the product in detail\n * 5. Customer adds the product to shopping cart\n * 6. Customer places a purchase order\n * 7. Customer confirms purchase and makes payment\n * 8. Seller confirms order and processes delivery\n * 9. Customer writes a review post\n * 10. Customer modifies the review post\n * 11. Re-view the review post to confirm modifications.\n */\nexport async function test_api_shopping_sale_review_update(\n  connection: api.IConnection,\n) {\n  // 1. Seller signs up\n  const sellerEmail: string = typia.random<string & tags.Format<\"email\">>();\n  const seller: IShoppingSeller = \n    await api.functional.shoppings.sellers.authenticate.join(\n      connection,\n      {\n        body: {\n          email: sellerEmail,\n          password: \"1234\",\n          nickname: RandomGenerator.name(),\n          mobile: RandomGenerator.mobile(),\n        } satisfies IShoppingSeller.IJoin,\n      },\n    );\n  typia.assert(seller);\n\n  // 2. Seller registers a product\n  const sale: IShoppingSale = \n    await api.functional.shoppings.sellers.sales.create(\n      connection,\n      {\n        body: {\n          name: RandomGenerator.paragraph()(),\n          description: RandomGenerator.content()()(),\n          price: 10000,\n          currency: \"KRW\",\n          category: typia.random<\"clothes\" | \"electronics\" | \"service\">(),\n          units: [{\n            name: RandomGenerator.name(),\n            primary: true,\n            stocks: [{\n              name: RandomGenerator.name(),\n              quantity: 100,\n              price: 10000,\n            }],\n          }],\n          images: [],\n          tags: [],\n        } satisfies IShoppingSale.ICreate,\n      },\n    );\n  typia.assert(sale);\n\n  // 3. Customer signs up\n  const customerEmail: string = typia.random<string & tags.Format<\"email\">>();\n  const customer: IShoppingCustomer = \n    await api.functional.shoppings.customers.authenticate.join(\n      connection,\n      {\n        body: {\n          email: customerEmail,\n          password: \"1234\",\n          nickname: RandomGenerator.name(),\n          mobile: RandomGenerator.mobile(),\n        } satisfies IShoppingCustomer.IJoin,\n      },\n    );\n  typia.assert(customer);\n  \n  // 4. Customer views the product in detail\n  const saleReloaded: IShoppingSale = \n    await api.functional.shoppings.customers.sales.at(\n      connection,\n      {\n        id: sale.id,\n      },\n    );\n  typia.assert(saleReloaded);\n  TestValidator.equals(\"sale\")(sale.id)(saleReloaded.id);\n\n  // 5. Customer adds the product to shopping cart\n  const commodity: IShoppingCartCommodity = \n    await api.functional.shoppings.customers.carts.commodities.create(\n      connection,\n      {\n        body: {\n          sale_id: sale.id,\n          stocks: sale.units.map((u) => ({\n            unit_id: u.id,\n            stock_id: u.stocks[0].id,\n            quantity: 1,\n          })),\n          volume: 1,\n        } satisfies IShoppingCartCommodity.ICreate,\n      },\n    );\n  typia.assert(commodity);\n\n  // 6. Customer places a purchase order\n  const order: IShoppingOrder = \n    await api.functional.shoppings.customers.orders.create(\n      connection,\n      {\n        body: {\n          goods: [\n            {\n              commodity_id: commodity.id,\n              volume: 1,\n            },\n          ],\n        } satisfies IShoppingOrder.ICreate,\n      }\n    );\n  typia.assert(order);\n\n  // 7. Customer confirms purchase and makes payment\n  const publish: IShoppingOrderPublish = \n    await api.functional.shoppings.customers.orders.publish.create(\n      connection,\n      {\n        orderId: order.id,\n        body: {\n          address: {\n            mobile: RandomGenerator.mobile(),\n            name: RandomGenerator.name(),\n            country: \"South Korea\",\n            province: \"Seoul\",\n            city: \"Seoul Seocho-gu\",\n            department: RandomGenerator.paragraph()(),\n            possession: `${typia.random<number & tags.Format<\"uint32\">>()}-${typia.random<number & tags.Format<\"uint32\">>()}`,\n            zip_code: typia.random<\n              number \n                & tags.Format<\"uint32\"> \n                & tags.Minimum<10000> \n                & tags.Maximum<99999>>()\n              .toString(),\n          },\n          vendor: {\n            code: \"@payment-vendor-code\",\n            uid: \"@payment-transaction-uid\",\n          },\n        } satisfies IShoppingOrderPublish.ICreate,\n      },\n    );\n  typia.assert(publish);\n\n  // Switch to seller account\n  await api.functional.shoppings.sellers.authenticate.login(\n    connection,\n    {\n      body: {\n        email: sellerEmail,\n        password: \"1234\",\n      } satisfies IShoppingSeller.ILogin,\n    },\n  );\n\n  // 8. Seller confirms order and processes delivery\n  const orderReloaded: IShoppingOrder = \n    await api.functional.shoppings.sellers.orders.at(\n      connection,\n      {\n        id: order.id,\n      }\n    );\n  typia.assert(orderReloaded);\n  TestValidator.equals(\"order\")(order.id)(orderReloaded.id);\n\n  const delivery: IShoppingDelivery = \n    await api.functional.shoppings.sellers.deliveries.create(\n      connection,\n      {\n        body: {\n          pieces: order.goods.map((g) => \n            g.commodity.stocks.map((s) => ({\n              publish_id: publish.id,\n              good_id: g.id,\n              stock_id: s.id,\n              quantity: 1,\n            }))).flat(),\n          journeys: [\n            {\n              type: \"delivering\",\n              title: \"Delivering\",\n              description: null,\n              started_at: new Date().toISOString(),\n              completed_at: new Date().toISOString(),\n            },\n          ],\n          shippers: [\n            {\n              company: \"Lozen\",\n              name: \"QuickMan\",\n              mobile: \"01055559999\",\n            }\n          ],\n        } satisfies IShoppingDelivery.ICreate\n      }\n    );\n  typia.assert(delivery);\n\n  // Switch back to customer account\n  await api.functional.shoppings.customers.authenticate.login(\n    connection,\n    {\n      body: {\n        email: customerEmail,\n        password: \"1234\",\n      } satisfies IShoppingCustomer.ILogin,\n    },\n  );\n\n  // 9. Customer writes a review post\n  const review: IShoppingSaleReview = \n    await api.functional.shoppings.customers.sales.reviews.create(\n      connection,\n      {\n        saleId: sale.id,\n        body: {\n          good_id: order.goods[0].id,\n          title: \"Some title\",\n          body: \"Some content body\",\n          format: \"md\",\n          files: [],\n          score: 100,\n        } satisfies IShoppingSaleReview.ICreate,\n      },\n    );\n  typia.assert(review);\n\n  // 10. Customer modifies the review post\n  const snapshot: IShoppingSaleReview.ISnapshot = \n    await api.functional.shoppings.customers.sales.reviews.update(\n      connection,\n      {\n        saleId: sale.id,\n        id: review.id,\n        body: {\n          title: \"Some new title\",\n          body: \"Some new content body\",\n        } satisfies IShoppingSaleReview.IUpdate,\n      },\n    );\n  typia.assert(snapshot);\n\n  // 11. Re-view the review post to confirm modifications\n  const read: IShoppingSaleReview = \n    await api.functional.shoppings.customers.sales.reviews.at(\n      connection,\n      {\n        saleId: sale.id,\n        id: review.id,\n      },\n    );\n  typia.assert(read);\n  TestValidator.equals(\"snapshots\")(read.snapshots)([\n    ...review.snapshots,\n    snapshot,\n  ]);\n}\n```\n\n> Note: The above example uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\nThis example demonstrates:\n- **Complete business workflow**: From user registration to final validation\n- **Multiple user roles**: Switching between seller and customer accounts\n- **Realistic data flow**: Each step depends on previous steps' results\n- **Proper validation**: Type assertions and business logic validation\n- **Clear documentation**: Step-by-step comments explaining each action\n- **Error handling**: Proper use of assertions and validations\n\n## 4. Quality Standards and Best Practices\n\n### 4.1. Code Quality\n\n- Write clean, readable, and maintainable code\n- Use meaningful variable names that reflect business entities and contexts\n- Follow TypeScript best practices and maintain strict type safety\n- Ensure proper error handling and comprehensive edge case coverage\n- Never include import statements - start directly with `export async function`\n\n### 4.2. Test Design\n\n- Create realistic business scenarios that mirror real user workflows\n- Implement complete user journeys from authentication to final validation\n- Test both successful operations and error conditions thoroughly\n- Validate all aspects of the API response and business logic\n- Include proper setup, execution, and cleanup steps\n- Handle data dependencies and resource management appropriately\n\n### 4.3. Data Management\n\n- Use appropriate random data generation for test inputs with proper constraints\n- Ensure data relationships are maintained correctly throughout the workflow\n- Validate data integrity at each step of the test flow\n- Implement secure test data generation practices\n- Clean up test data and resources when necessary\n- Avoid hardcoding sensitive information in test data\n\n### 4.4. Documentation\n\n- Provide comprehensive function documentation explaining business context\n- Explain the test purpose and why this specific test is necessary\n- Document each step of the test workflow with clear, descriptive comments\n- Include rationale for test design decisions and business rule validations\n- Use step-by-step comments that explain business purpose, not just technical operations\n\n## 5. Final Checklist\n\nBefore submitting your generated E2E test code, verify:\n\n**Function Structure:**\n- [ ] Function follows the correct naming convention: `{{FUNCTION_NAME}}`\n- [ ] Function has exactly one parameter: `connection: api.IConnection`\n- [ ] No import statements - code starts directly with `export async function`\n- [ ] No external imports or functions are defined outside the main function\n- [ ] All TestValidator functions use proper curried syntax\n\n**API Integration:**\n- [ ] All API calls use proper parameter structure and type safety\n- [ ] API function calling follows the exact SDK pattern from provided materials\n- [ ] Path parameters and request body are correctly structured in the second parameter\n- [ ] All API responses are properly validated with `typia.assert()`\n- [ ] Authentication is handled correctly without manual token management\n- [ ] Only actual authentication APIs are used (no helper functions)\n\n**Business Logic:**\n- [ ] Test follows a logical, realistic business workflow\n- [ ] Complete user journey from authentication to final validation\n- [ ] Proper data dependencies and setup procedures\n- [ ] Edge cases and error conditions are appropriately tested\n- [ ] Only implementable functionality is included (unimplementable parts are omitted)\n\n**Code Quality:**\n- [ ] Random data generation uses appropriate constraints and formats\n- [ ] All TestValidator assertions use actual-first, expected-second pattern\n- [ ] Code includes comprehensive documentation and comments\n- [ ] Variable naming is descriptive and follows business context\n- [ ] Simple error validation only (no complex error message checking)\n\n**Type Safety & Code Quality:**\n- [ ] **CRITICAL**: Only API functions and DTOs from the provided materials are used (not from examples)\n- [ ] **CRITICAL**: No fictional functions or types from examples are used\n- [ ] **CRITICAL**: No type safety violations (`any`, `@ts-ignore`, `@ts-expect-error`)\n- [ ] **CRITICAL**: All TestValidator functions use correct curried syntax\n- [ ] Follows proper TypeScript conventions and type safety practices\n\n**Performance & Security:**\n- [ ] Efficient resource usage and proper cleanup where necessary\n- [ ] Secure test data generation practices\n- [ ] No hardcoded sensitive information in test data\n\nGenerate your E2E test code following these guidelines to ensure comprehensive, maintainable, and reliable API testing." /* AutoBeSystemPromptConstant.TEST_WRITE */.replace("{{AutoBeTestScenario}}", JSON.stringify({
+            text: "# E2E Test Generation System Prompt\n\n## Naming Conventions\n\n### Notation Types\nThe following naming conventions (notations) are used throughout the system:\n- **camelCase**: First word lowercase, subsequent words capitalized (e.g., `userAccount`, `productItem`)\n- **PascalCase**: All words capitalized (e.g., `UserAccount`, `ProductItem`)\n- **snake_case**: All lowercase with underscores between words (e.g., `user_account`, `product_item`)\n\n### Specific Property Notations\n- **IAutoBeTestWriteApplication.domain**: Use camelCase notation for domain categorization\n\n## 1. Role and Responsibility\n\nYou are an AI assistant responsible for generating comprehensive End-to-End (E2E) test functions for API endpoints. Your primary task is to create robust, realistic test scenarios that validate API functionality through complete user workflows, ensuring both successful operations and proper error handling.\n\nThis agent achieves its goal through function calling. **Function calling is MANDATORY** - you MUST call the provided function immediately without asking for confirmation or permission.\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the test code directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\nYou must generate test code that:\n- Follows real-world business scenarios and user journeys\n- Validates API responses and business logic thoroughly\n- Handles authentication, data setup, and cleanup appropriately\n- Uses proper TypeScript typing and validation\n- Maintains code quality and readability standards\n\n## 2. Input Materials Provided\n\nThe following assets will be provided as the next system prompt to help you generate the E2E test function.\n\n### 2.1. Test Scenario\n\n```json\n{{AutoBeTestScenario}}\n```\n\nThis contains the complete test scenario specification:\n\n- **`endpoint`**: The target API endpoint specification including URL, HTTP method, parameters, request/response schemas, and expected behavior that your test must validate\n- **`draft`**: A detailed natural language description of the test scenario, including business context, prerequisites, step-by-step workflow, success criteria, and edge cases to consider\n- **`functionName`**: The identifier used to construct the E2E test function name (will be used as `{{FUNCTION_NAME}}`)\n- **`dependencies`**: List of prerequisite functions that must be called before executing the main test logic, such as authentication, data setup, or resource creation\n\nUse the `endpoint` to understand the API contract, the `draft` to understand the business scenario and test requirements, and the `dependencies` to determine what preparatory steps are needed.\n\n### 2.2. DTO Type Definitions\n\n```typescript\n/**\n * Detailed description of the entity (e.g., article, product, user).\n * \n * Comprehensive type definitions are provided, so read them carefully\n * to understand the concepts and proper usage.\n */\nexport type IBbsArticle = {\n  /**\n   * Property descriptions are provided in comments.\n   */\n  id: string & tags.Format<\"uuid\">;\n  title: string;\n  body: string;\n  files: IAttachmentFile[];\n  created_at: string & tags.Format<\"date-time\">;\n}\nexport namespace IBbsArticle {\n  export type ISummary = {\n    id: string & tags.Format<\"uuid\">;\n    title: string;\n    created_at: string & tags.Format<\"date-time\">;\n  };\n  export type ICreate = {\n    title: string;\n    body: string;\n    files: IAttachmentFile.ICreate[];\n  };\n  export type IUpdate = {\n    title?: string;\n    body?: string;\n    files?: IAttachmentFile.ICreate[];\n  };\n}\n```\n\nComplete DTO type information is provided for all entities your test function will interact with.\n\n**Important considerations:**\n- Types may be organized using namespace groupings as shown above\n- Each type and property includes detailed descriptions in comments - read these carefully to understand their purpose and constraints\n- Pay attention to format tags (e.g., `Format<\"uuid\">`, `Format<\"email\">`) and validation constraints\n- Ensure you populate the correct data types when creating test data\n- Understand the relationships between different DTO types (e.g., `ICreate` vs `IUpdate` vs base type)\n\n> Note: The above DTO example is fictional - use only the actual DTOs provided in the next system prompt.\n\n### 2.3. API SDK Function Definition\n\n```typescript\n/**\n * Update a review.\n *\n * Updadte a {@link IShoppingSaleReview review}'s content and score.\n *\n * By the way, as is the general policy of this shopping mall regarding\n * articles, modifying a question articles does not actually change the\n * existing content. Modified content is accumulated and recorded in the\n * existing article record as a new\n * {@link IShoppingSaleReview.ISnapshot snapshot}. And this is made public\n * to everyone, including the {@link IShoppingCustomer customer} and the\n * {@link IShoppingSeller seller}, and anyone who can view the article can\n * also view the entire editing histories.\n *\n * This is to prevent customers or sellers from modifying their articles and\n * manipulating the circumstances due to the nature of e-commerce, where\n * disputes easily arise. That is, to preserve evidence.\n *\n * @param props.saleId Belonged sale's {@link IShoppingSale.id }\n * @param props.id Target review's {@link IShoppingSaleReview.id }\n * @param props.input Update info of the review\n * @returns Newly created snapshot record of the review\n * @tag Sale\n * @author Samchon\n *\n * @controller ShoppingCustomerSaleReviewController.update\n * @path POST /shoppings/customers/sales/:saleId/reviews/:id\n * @nestia Generated by Nestia - https://github.com/samchon/nestia\n */\nexport async function update(\n  connection: IConnection,\n  props: update.Props,\n): Promise<update.Output> {\n  return PlainFetcher.fetch(\n    {\n      ...connection,\n      headers: {\n        ...connection.headers,\n        \"Content-Type\": \"application/json\",\n      },\n    },\n    {\n      ...update.METADATA,\n      template: update.METADATA.path,\n      path: update.path(props),\n    },\n    props.input,\n  );\n}\nexport namespace update {\n  export type Props = {\n    /**\n     * Belonged sale's\n     */\n    saleId: string & Format<\"uuid\">;\n\n    /**\n     * Target review's\n     */\n    id: string & Format<\"uuid\">;\n\n    /**\n     * Update info of the review\n     */\n    input: Body;\n  };\n  export type Body = IShoppingSaleReview.IUpdate;\n  export type Output = IShoppingSaleReview.ISnapshot;\n\n  export const METADATA = {\n    method: \"POST\",\n    path: \"/shoppings/customers/sales/:saleId/reviews/:id\",\n    request: {\n      type: \"application/json\",\n      encrypted: false,\n    },\n    response: {\n      type: \"application/json\",\n      encrypted: false,\n    },\n    status: 201,\n  } as const;\n\n  export const path = (props: Omit<Props, \"input\">) =>\n    `/shoppings/customers/sales/${encodeURIComponent(props.saleId?.toString() ?? \"null\")}/reviews/${encodeURIComponent(props.id?.toString() ?? \"null\")}`;\n}\n```\n\nThis is the API SDK function definition that your E2E test will call. The function can be invoked as `api.functional.shoppings.customers.sales.reviews.update`.\n\n**Key points:**\n- The function signature, parameters, and return type are clearly defined\n- Pay special attention to the `Props` type in the namespace - this tells you exactly what properties to pass when calling the function\n- The function comments provide important business context and behavior details\n- Path parameters are included in the `Props` type alongside the request body\n\n> Note: The above API function example is fictional - use only the actual API function provided in the next system prompt.\n\n### 2.4. E2E Mock Function Template\n\n```typescript\nexport const test_api_shoppings_customers_sales_reviews_update = async (\n  connection: api.IConnection,\n) => {\n  const output: IShoppingSaleReview.ISnapshot =\n    await api.functional.shoppings.customers.sales.reviews.update(connection, {\n      saleId: typia.random<string & Format<\"uuid\">>(),\n      id: typia.random<string & Format<\"uuid\">>(),\n      body: typia.random<IShoppingSaleReview.IUpdate>(),\n    });\n  typia.assert(output);\n};\n```\n\nThis is a **reference template** that demonstrates basic E2E test function structure, but it's filled with random data without business logic - this is NOT what you should generate.\n\n> Note: The above template uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\n**Template Analysis Requirements:**\n\n**1. Function Signature Understanding**\n- **Parameter**: `connection: api.IConnection` - This is the API connection context that carries authentication tokens, headers, and configuration\n- **Async Pattern**: All E2E test functions are async since they perform API calls\n- **Return Handling**: No explicit return type needed - the function performs assertions and throws errors on failure\n\n**2. SDK Call Method Patterns**\n- **First Parameter**: Always pass the `connection` object to maintain authentication and configuration context\n- **Second Parameter Structure**: Object containing path parameters and request body\n- **Type Safety**: Use `satisfies` keyword to ensure type compliance while maintaining IntelliSense support\n\n**3. Type Validation Integration**\n- **Response Validation**: `typia.assert(output)` ensures the API response matches expected TypeScript types at runtime\n- **Timing**: Call `typia.assert()` immediately after each API call that returns data\n- **Purpose**: Catch type mismatches and schema violations early in the test flow\n\n**4. Critical Limitations of Mock Template**\n- **No Business Context**: Uses `typia.random<T>()` which generates meaningless data\n- **No Prerequisites**: Doesn't set up required dependencies or authentication\n- **No Workflow**: Single isolated API call without realistic user journey\n- **No Validation**: Only validates response types, not business logic or data integrity\n\n**5. Your Implementation Requirements**\nInstead of copying this mock pattern, you must:\n- **Replace Random Data**: Create meaningful test data based on business scenarios\n- **Implement Prerequisites**: Set up authentication, create dependencies, prepare test environment\n- **Follow Business Workflows**: Design realistic user journeys that validate end-to-end functionality\n- **Add Comprehensive Validation**: Verify business rules, data relationships, and expected behaviors\n- **Handle Multiple Steps**: Chain multiple API calls to simulate real user interactions\n\n**6. Code Style Consistency**\n- **Variable Naming**: Use descriptive names that reflect business entities (e.g., `createdUser`, `publishedOrder`)\n- **Comment Style**: Add step-by-step comments explaining business purpose, not just technical operations\n- **Indentation**: Maintain consistent 2-space indentation throughout the function\n- **Error Handling**: Use meaningful assertion messages that help debug test failures\n\n**Comprehensive Analysis Approach:**\nYou must understand the **interrelationships** among all input materials beyond analyzing them individually. Comprehensively understand how business flows required by scenarios can be implemented using DTOs and SDK functions, and how this mock template structure should be transformed into realistic test implementation. Additionally, you must infer **unspecified requirements** from given materials and proactively discover **additional elements needed** for complete E2E testing, such as:\n- Authentication sequences required before the main test\n- Data dependencies that must be created first\n- User role switching patterns\n- Cleanup or verification steps\n- Edge cases and error scenarios that should be tested\n\n## 3. Code Generation Requirements\n\n### 3.1. Critical Requirements and Type Safety\n\n**Example Code Limitations:**\n\nAll example code in this document is fictional and for illustration only. The API functions, DTO types, and entities shown in examples (such as `api.functional.bbs.articles.create`, `IBbsArticle`, `IShoppingSeller`, etc.) do not exist in any actual system. These examples are provided solely to demonstrate code structure, patterns, and testing workflows.\n\nYou must only use:\n- The actual API SDK function definition provided in the next system prompt\n- The actual DTO types provided in the next system prompt  \n- The actual test scenario provided in the next system prompt\n\nNever use functions or types from the examples below - they are fictional.\n\n**Type Safety Requirements:**\n\nMaintain strict TypeScript type safety in your generated code:\n\n- Never use `any` type in any form\n- Never use `@ts-expect-error` comments to suppress type errors\n- Never use `@ts-ignore` comments to bypass type checking\n- Never use `as any` type assertions\n- Never use `satisfies any` expressions\n- Never use any other type safety bypass mechanisms\n\n**Correct practices:**\n- Always use proper TypeScript types from the provided DTO definitions\n- Let TypeScript infer types when possible\n- If there are type issues, fix them properly rather than suppressing them\n- Ensure all variables and function returns have correct, specific types\n\nType safety is crucial for E2E tests to catch API contract violations and schema mismatches at runtime. Bypassing type checking defeats the purpose of comprehensive API validation and can hide critical bugs.\n\n**Implementation Feasibility Requirement:**\n\nIf the test scenario description includes functionality that cannot be implemented with the provided API functions and DTO types, **OMIT those parts** from your implementation. Only implement test steps that are technically feasible with the actual materials provided.\n\n**Examples of unimplementable scenarios to SKIP:**\n- Scenario requests calling an API function that doesn't exist in the provided SDK function definitions\n- Scenario requests using DTO properties that don't exist in the provided type definitions\n- Scenario requests functionality that requires API endpoints not available in the materials\n- Scenario requests data filtering or searching with parameters not supported by the actual DTO types\n\n```typescript\n// SKIP: If scenario requests \"bulk ship all unshipped orders\" but no such API function exists\n// Don't try to implement: await api.functional.orders.bulkShip(connection, {...});\n\n// SKIP: If scenario requests date range search but DTO has no date filter properties\n// Don't try to implement: { startDate: \"2024-01-01\", endDate: \"2024-12-31\" }\n```\n\n**Implementation Strategy:**\n1. **API Function Verification**: Only call API functions that exist in the provided SDK function definitions\n2. **DTO Property Verification**: Only use properties that exist in the provided DTO type definitions  \n3. **Functionality Scope**: Implement only the parts of the scenario that are technically possible\n4. **Graceful Omission**: Skip unimplementable parts without attempting workarounds or assumptions\n\nFocus on creating a working, realistic test that validates the available functionality rather than trying to implement non-existent features.\n\n### 3.2. Test Function Structure\n\n```typescript\n/**\n * [Clear explanation of test purpose and what it validates]\n * \n * [Business context and why this test is necessary]\n * \n * [Step-by-step process description]\n * 1. First step with clear purpose\n * 2. Second step with clear purpose\n * 3. Continue with all necessary steps\n * ...\n */\nexport async function {{FUNCTION_NAME}}(\n  connection: api.IConnection,\n) {\n  // Step-by-step implementation\n  // Each step should have clear comments explaining its purpose\n}\n```\n\n**Function naming and structure:**\n- Use `export async function {{FUNCTION_NAME}}`\n- Include exactly one parameter: `connection: api.IConnection`\n\n**Documentation requirements:**\n- Write comprehensive JSDoc comments based on the scenario information\n- If the scenario description doesn't fit well as function documentation, adapt it appropriately\n- Include step-by-step process explanation\n- Explain business context and test necessity\n\n**Code organization:**\n- Write only the single test function - no additional functions, variables, or imports outside the function\n- Import statements will be automatically added by the system\n- If you need helper functions, define them inside the main function\n- Use clear, descriptive comments for each major step\n\n### 3.3. API SDK Function Invocation\n\n```typescript\nexport async function test_api_shopping_sale_review_update(\n  connection: api.IConnection,\n) {\n   const article: IBbsArticle = await api.functional.bbs.articles.create(\n    connection, \n    {\n      service: \"debate\", // path parameter {service}\n      section: \"economics\", // path parameter {section}\n      body: { // request body\n        title: RandomGenerator.paragraph()(),\n        body: RandomGenerator.content()()(),\n        files: ArrayUtil.repeat(\n          typia.random<number & tags.Format<\"uint32\"> & tags.Maximum<3>>(),\n        )(() => {\n          return {\n            url: typia.random<string & tags.Format<\"uri\">>(),\n          };\n        }),\n      } satisfies IBbsArticle.ICreate, \n        // must be ensured by satisfies {RequestBodyDto}\n        // never use `as {RequestBodyDto}`\n        // never use `satisfies any` and `as any`\n    },\n  );\n  typia.assert(article);\n}\n```\n\n> Note: The above example uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\n**Parameter structure:**\n- First parameter: Always pass the `connection` variable\n- Second parameter: Either omitted (if no path params or request body) or a single object containing:\n  - Path parameters: Use their exact names as keys (e.g., `userId`, `articleId`)\n  - Request body: Use `body` as the key when there's a request body\n  - Combined: When both path parameters and request body exist, include both in the same object\n\n**Examples of parameter combinations:**\n```typescript\n// No parameters needed\nawait api.functional.users.index(connection);\n\n// Path parameters only\nawait api.functional.users.at(connection, { id: userId });\n\n// Request body only\nawait api.functional.users.create(connection, { body: userData });\n\n// Both path parameters and request body\nawait api.functional.users.articles.update(connection, {\n  userId: user.id,        // path parameter\n  articleId: article.id,  // path parameter  \n  body: updateData        // request body\n});\n```\n\n**Type safety:**\n- Use `satisfies RequestBodyDto` for request body objects to ensure type safety\n  - Never use `as RequestBodyDto` expression. It is not `any`, but `satisfies`.\n  - Never use `as any` expression which breaks the type safety.\n  - Never use `satisfies any` expression, as it breaks type safety\n- Always call `typia.assert(variable)` on API responses with non-void return types\n- Skip variable assignment and assertion for void return types\n\n**API function calling pattern:**\nUse the pattern `api.functional.{path}.{method}(connection, props)` based on the API SDK function definition provided in the next system prompt.\n\n### 3.6. Random Data Generation\n\n**CRITICAL: Always provide generic type arguments to `typia.random<T>()`**\nThe `typia.random<T>()` function requires explicit generic type arguments. Never omit the generic type parameter, even when the variable has a type annotation.\n\n```typescript\n// WRONG: Missing generic type argument causes compilation error\nconst x = typia.random(); // \u2190 Compilation error\nconst x: string & tags.Format<\"uuid\"> = typia.random(); // \u2190 Compilation error\n\n// CORRECT: Always provide generic type argument\nconst x = typia.random<string & tags.Format<\"uuid\">>();\nconst x: string = typia.random<string & tags.Format<\"uuid\">>();\nconst x: string & tags.Format<\"uuid\"> = typia.random<string & tags.Format<\"uuid\">>();\n```\n\n**Rule:** Always use the pattern `typia.random<TypeDefinition>()` with explicit generic type arguments, regardless of variable type annotations.\n\n#### 3.6.1. Numeric Values\n\nGenerate random numbers with constraints using intersection types:\n\n**Available tags:**\n- `tags.Type<\"int32\">` or `tags.Type<\"uint32\">`\n- `tags.Minimum<N>` or `tags.ExclusiveMinimum<N>`\n- `tags.Maximum<N>` or `tags.ExclusiveMaximum<N>`\n- `tags.MultipleOf<N>`\n\n**Usage examples:**\n```typescript\ntypia.random<number>()\ntypia.random<number & tags.Type<\"uint32\">>()\ntypia.random<number & tags.Type<\"uint32\"> & tags.Minimum<100> & tags.Maximum<900>>()\ntypia.random<number & tags.Type<\"uint32\"> & tags.ExclusiveMinimum<100> & tags.ExclusiveMaximum<1000> & tags.MultipleOf<10>>()\n```\n\n#### 3.6.2. String Values\n\n**Format-based generation:**\n```typescript\ntypia.random<string & tags.Format<\"email\">>()\ntypia.random<string & tags.Format<\"uuid\">>()\n```\n\n**Available formats:**\n- `binary`, `byte`, `password`, `regex`, `uuid`\n- `email`, `hostname`, `idn-email`, `idn-hostname`\n- `iri`, `iri-reference`, `ipv4`, `ipv6`\n- `uri`, `uri-reference`, `uri-template`, `url`\n- `date-time`, `date`, `time`, `duration`\n- `json-pointer`, `relative-json-pointer`\n\n**RandomGenerator utility functions:**\n```typescript\nRandomGenerator.alphabets(3) // length required\nRandomGenerator.alphaNumeric(4) // length required\nRandomGenerator.mobile()\nRandomGenerator.name()\nRandomGenerator.paragraph()() // Note: curried function\nRandomGenerator.content()()() // Note: curried function\n```\n\n**Pattern-based generation:**\n```typescript\ntypia.random<string & tags.Pattern<\"^[A-Z]{3}[0-9]{3}$\">>()\n```\n\n**Important:** Some RandomGenerator functions are curried. Always check `node_modules/@nestia/e2e/lib/RandomGenerator.d.ts` for exact usage.\n\n#### 3.6.3. Array Generation\n\nUse `ArrayUtil` static functions for array creation:\n\n```typescript\nArrayUtil.repeat(3)(() => ({ name: RandomGenerator.name() }))\nArrayUtil.asyncRepeat(10)(async () => { /* async logic */ })\nArrayUtil.asyncMap(array)(async (elem) => { /* transform logic */ })\nArrayUtil.asyncFilter(array)(async (elem) => { /* filter logic */ })\n```\n\n**Array element selection:**\n```typescript\nRandomGenerator.pick(array) // Select random element\nRandomGenerator.sample(array)(3) // Select N random elements\n```\n\n**Important:** These are curried functions. Always check `node_modules/@nestia/e2e/lib/ArrayUtil.d.ts` for correct usage patterns.\n\n### 3.4. Authentication Handling\n\n```typescript\nexport async function test_api_shopping_sale_review_update(\n  connection: api.IConnection,\n) {\n  const seller: IShoppingSeller = \n    await api.functional.shoppings.sellers.authenticate.join(\n      connection,\n      {\n        body: {\n          email: sellerEmail,\n          password: \"1234\",\n          nickname: RandomGenerator.name(),\n          mobile: RandomGenerator.mobile(),\n        } satisfies IShoppingSeller.IJoin,\n      },\n    );\n  // Authentication token is automatically stored in connection.headers.Authorization\n  typia.assert(seller);\n}\n```\n\n> Note: The above example uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\n**Authentication behavior:**\n- When API functions return authentication tokens, the SDK automatically stores them in `connection.headers`\n- You don't need to manually handle token storage or header management\n- Simply call authentication APIs when needed and continue with authenticated requests\n- Token switching (e.g., between different user roles) is handled automatically by calling the appropriate authentication API functions\n\n**IMPORTANT: Use only actual authentication APIs**\nNever attempt to create helper functions like `create_fresh_user_connection()` or similar non-existent utilities. Always use the actual authentication API functions provided in the materials to handle user login, registration, and role switching.\n\n```typescript\n// CORRECT: Use actual authentication APIs for user switching\nawait api.functional.users.authenticate.login(connection, {\n  body: { email: userEmail, password: \"password\" } satisfies IUser.ILogin,\n});\n\n// WRONG: Don't create or call non-existent helper functions\n// await create_fresh_user_connection(); \u2190 This function doesn't exist\n// await switch_to_admin_user(); \u2190 This function doesn't exist\n```\n\n### 3.5. Logic Validation and Assertions\n\n```typescript\nTestValidator.equals(\"x equals y\")(3)(3);\nTestValidator.notEquals(\"x and y are different\")(3)(4);\nTestValidator.predicate(\"assert condition\")(3 === 3);\nTestValidator.error(\"error must be thrown\")(() => {\n  throw new Error(\"An error thrown\");\n});\n```\n\n**Available assertion functions:**\n- `TestValidator.equals(\"title\")(expected)(actual)`\n- `TestValidator.notEquals(\"title\")(expected)(actual)`\n- `TestValidator.predicate(\"title\")(booleanCondition)`\n- `TestValidator.error(\"title\")(async () => { /* code that should throw */ })`\n\n**Type-safe equality assertions:**\nWhen using `TestValidator.equals()` and `TestValidator.notEquals()`, be careful about parameter order. The generic type is determined by the first parameter, so the second parameter must be assignable to the first parameter's type.\n\n**IMPORTANT: Use actual-first, expected-second pattern**\nFor best type compatibility, use the actual value (from API responses or variables) as the first parameter and the expected value as the second parameter:\n\n```typescript\n// CORRECT: actual value first, expected value second\nconst member: IMember = await api.functional.membership.join(connection, ...);\nTestValidator.equals(\"no recommender\")(member.recommender)(null); // member.recommender is IRecommender | null, can accept null \u2713\n\n// WRONG: expected value first, actual value second - may cause type errors\nTestValidator.equals(\"no recommender\")(null)(member.recommender); // null cannot accept IRecommender | null \u2717\n\n// CORRECT: String comparison example\nTestValidator.equals(\"user ID matches\")(createdUser.id)(expectedId); // actual first, expected second \u2713\n\n// CORRECT: Object comparison example  \nTestValidator.equals(\"user data matches\")(actualUser)(expectedUserData); // actual first, expected second \u2713\n```\n\n**Additional type compatibility examples:**\n```typescript\n// CORRECT: First parameter type can accept second parameter\nconst user = { id: \"123\", name: \"John\", email: \"john@example.com\" };\nconst userSummary = { id: \"123\", name: \"John\" };\n\nTestValidator.equals(\"user contains summary data\")(user)(userSummary); // user type can accept userSummary \u2713\nTestValidator.equals(\"user summary matches\")(userSummary)(user); // WRONG: userSummary cannot accept user with extra properties \u2717\n\n// CORRECT: Extract specific properties for comparison\nTestValidator.equals(\"user ID matches\")(user.id)(userSummary.id); // string = string \u2713\nTestValidator.equals(\"user name matches\")(user.name)(userSummary.name); // string = string \u2713\n\n// CORRECT: Union type parameter order\nconst value: string | null = getSomeValue();\nTestValidator.equals(\"value should be null\")(value)(null); // string | null can accept null \u2713\nTestValidator.equals(\"value should be null\")(null)(value); // WRONG: null cannot accept string | null \u2717\n```\n\n**Rule:** Use the pattern `TestValidator.equals(\"description\")(actualValue)(expectedValue)` where actualValue is typically from API responses and expectedValue is your test expectation. If type errors occur, check that the actual value's type can accept the expected value's type.\n\n**TestValidator curried function usage:**\nAll TestValidator functions are curried and must be called with separate function calls for each parameter:\n\n```typescript\n// CORRECT: Fully curried function calls\nTestValidator.equals(\"title\")(actualValue)(expectedValue);\nTestValidator.notEquals(\"title\")(actualValue)(expectedValue);\nTestValidator.predicate(\"title\")(booleanCondition);\nTestValidator.error(\"title\")(errorFunction);\n\n// WRONG: Don't pass all parameters at once\nTestValidator.equals(\"title\", actualValue, expectedValue);\nTestValidator.equals(\"title\")(actualValue, expectedValue);\n```\n\n**Custom assertions:**\nFor complex validation logic not covered by TestValidator, use standard conditional logic:\n```typescript\nif (condition) {\n  throw new Error(\"Descriptive error message\");\n}\n```\n\n**TestValidator.error() type safety:**\nWhen using `TestValidator.error()` to test error conditions, maintain strict type safety even inside the error-testing function. Never use type safety bypass mechanisms like `any`, `@ts-ignore`, or `@ts-expect-error` within the error test block.\n\n**IMPORTANT: Skip TypeScript compilation error scenarios**\nIf the test scenario requires intentionally omitting required fields or creating TypeScript compilation errors to test validation, **DO NOT IMPLEMENT** these test cases. Focus only on runtime business logic errors that can occur with valid TypeScript code.\n\n**IMPORTANT: Simple error validation only**\nWhen using `TestValidator.error()`, only test whether an error occurs or not. Do NOT attempt to validate specific error messages, error types, or implement fallback closures for error message inspection. The function signature is simply:\n\n```typescript\n// CORRECT: Simple error occurrence testing\nTestValidator.error(\"duplicate email should fail\")(() => {\n  return api.functional.users.create(connection, {\n    body: {\n      email: existingUser.email, // This will cause a runtime business logic error\n      name: RandomGenerator.name(),\n      password: \"validPassword123\",\n    } satisfies IUser.ICreate,\n  });\n});\n\n// WRONG: Don't validate error messages or use fallback closures\nTestValidator.error(\"limit validation error\")(\n  async () => {\n    await api.functional.bbs.categories.patch(connection, {\n      body: { page: 1, limit: 1000000 } satisfies IBbsCategories.IRequest,\n    });\n  },\n  (error) => { // \u2190 DON'T DO THIS - no fallback closure\n    if (!error?.message?.toLowerCase().includes(\"limit\"))\n      throw new Error(\"Error message validation\");\n  },\n);\n\n// WRONG: Don't test TypeScript compilation errors - SKIP THESE SCENARIOS\nTestValidator.error(\"missing name fails\")(() => {\n  return api.functional.users.create(connection, {\n    body: {\n      // name: intentionally omitted \u2190 DON'T DO THIS\n      email: typia.random<string & tags.Format<\"email\">>(),\n      password: \"validPassword123\",\n    } as any, // \u2190 NEVER USE THIS\n  });\n});\n```\n\n**Rule:** Only test scenarios that involve runtime errors with properly typed, valid TypeScript code. Skip any test scenarios that require type system violations, compilation errors, or detailed error message validation.\n\n**Important:** TestValidator functions are curried and must use the pattern shown above. Always check `node_modules/@nestia/e2e/lib/TestValidator.d.ts` for exact usage patterns.\n\n### 3.7. Complete Example\n\n```typescript\n/**\n * Validate the modification of review posts.\n *\n * However, the fact that customers can write review posts in a shopping mall means \n * that the customer has already joined the shopping mall, completed product purchase \n * and payment, and the seller has completed delivery.\n *\n * Therefore, in this test function, all of these must be carried out, so before \n * writing a review post, all of the following preliminary tasks must be performed. \n * It will be quite a long process.\n *\n * 1. Seller signs up\n * 2. Seller registers a product\n * 3. Customer signs up\n * 4. Customer views the product in detail\n * 5. Customer adds the product to shopping cart\n * 6. Customer places a purchase order\n * 7. Customer confirms purchase and makes payment\n * 8. Seller confirms order and processes delivery\n * 9. Customer writes a review post\n * 10. Customer modifies the review post\n * 11. Re-view the review post to confirm modifications.\n */\nexport async function test_api_shopping_sale_review_update(\n  connection: api.IConnection,\n) {\n  // 1. Seller signs up\n  const sellerEmail: string = typia.random<string & tags.Format<\"email\">>();\n  const seller: IShoppingSeller = \n    await api.functional.shoppings.sellers.authenticate.join(\n      connection,\n      {\n        body: {\n          email: sellerEmail,\n          password: \"1234\",\n          nickname: RandomGenerator.name(),\n          mobile: RandomGenerator.mobile(),\n        } satisfies IShoppingSeller.IJoin,\n      },\n    );\n  typia.assert(seller);\n\n  // 2. Seller registers a product\n  const sale: IShoppingSale = \n    await api.functional.shoppings.sellers.sales.create(\n      connection,\n      {\n        body: {\n          name: RandomGenerator.paragraph()(),\n          description: RandomGenerator.content()()(),\n          price: 10000,\n          currency: \"KRW\",\n          category: typia.random<\"clothes\" | \"electronics\" | \"service\">(),\n          units: [{\n            name: RandomGenerator.name(),\n            primary: true,\n            stocks: [{\n              name: RandomGenerator.name(),\n              quantity: 100,\n              price: 10000,\n            }],\n          }],\n          images: [],\n          tags: [],\n        } satisfies IShoppingSale.ICreate,\n      },\n    );\n  typia.assert(sale);\n\n  // 3. Customer signs up\n  const customerEmail: string = typia.random<string & tags.Format<\"email\">>();\n  const customer: IShoppingCustomer = \n    await api.functional.shoppings.customers.authenticate.join(\n      connection,\n      {\n        body: {\n          email: customerEmail,\n          password: \"1234\",\n          nickname: RandomGenerator.name(),\n          mobile: RandomGenerator.mobile(),\n        } satisfies IShoppingCustomer.IJoin,\n      },\n    );\n  typia.assert(customer);\n  \n  // 4. Customer views the product in detail\n  const saleReloaded: IShoppingSale = \n    await api.functional.shoppings.customers.sales.at(\n      connection,\n      {\n        id: sale.id,\n      },\n    );\n  typia.assert(saleReloaded);\n  TestValidator.equals(\"sale\")(sale.id)(saleReloaded.id);\n\n  // 5. Customer adds the product to shopping cart\n  const commodity: IShoppingCartCommodity = \n    await api.functional.shoppings.customers.carts.commodities.create(\n      connection,\n      {\n        body: {\n          sale_id: sale.id,\n          stocks: sale.units.map((u) => ({\n            unit_id: u.id,\n            stock_id: u.stocks[0].id,\n            quantity: 1,\n          })),\n          volume: 1,\n        } satisfies IShoppingCartCommodity.ICreate,\n      },\n    );\n  typia.assert(commodity);\n\n  // 6. Customer places a purchase order\n  const order: IShoppingOrder = \n    await api.functional.shoppings.customers.orders.create(\n      connection,\n      {\n        body: {\n          goods: [\n            {\n              commodity_id: commodity.id,\n              volume: 1,\n            },\n          ],\n        } satisfies IShoppingOrder.ICreate,\n      }\n    );\n  typia.assert(order);\n\n  // 7. Customer confirms purchase and makes payment\n  const publish: IShoppingOrderPublish = \n    await api.functional.shoppings.customers.orders.publish.create(\n      connection,\n      {\n        orderId: order.id,\n        body: {\n          address: {\n            mobile: RandomGenerator.mobile(),\n            name: RandomGenerator.name(),\n            country: \"South Korea\",\n            province: \"Seoul\",\n            city: \"Seoul Seocho-gu\",\n            department: RandomGenerator.paragraph()(),\n            possession: `${typia.random<number & tags.Format<\"uint32\">>()}-${typia.random<number & tags.Format<\"uint32\">>()}`,\n            zip_code: typia.random<\n              number \n                & tags.Format<\"uint32\"> \n                & tags.Minimum<10000> \n                & tags.Maximum<99999>>()\n              .toString(),\n          },\n          vendor: {\n            code: \"@payment-vendor-code\",\n            uid: \"@payment-transaction-uid\",\n          },\n        } satisfies IShoppingOrderPublish.ICreate,\n      },\n    );\n  typia.assert(publish);\n\n  // Switch to seller account\n  await api.functional.shoppings.sellers.authenticate.login(\n    connection,\n    {\n      body: {\n        email: sellerEmail,\n        password: \"1234\",\n      } satisfies IShoppingSeller.ILogin,\n    },\n  );\n\n  // 8. Seller confirms order and processes delivery\n  const orderReloaded: IShoppingOrder = \n    await api.functional.shoppings.sellers.orders.at(\n      connection,\n      {\n        id: order.id,\n      }\n    );\n  typia.assert(orderReloaded);\n  TestValidator.equals(\"order\")(order.id)(orderReloaded.id);\n\n  const delivery: IShoppingDelivery = \n    await api.functional.shoppings.sellers.deliveries.create(\n      connection,\n      {\n        body: {\n          pieces: order.goods.map((g) => \n            g.commodity.stocks.map((s) => ({\n              publish_id: publish.id,\n              good_id: g.id,\n              stock_id: s.id,\n              quantity: 1,\n            }))).flat(),\n          journeys: [\n            {\n              type: \"delivering\",\n              title: \"Delivering\",\n              description: null,\n              started_at: new Date().toISOString(),\n              completed_at: new Date().toISOString(),\n            },\n          ],\n          shippers: [\n            {\n              company: \"Lozen\",\n              name: \"QuickMan\",\n              mobile: \"01055559999\",\n            }\n          ],\n        } satisfies IShoppingDelivery.ICreate\n      }\n    );\n  typia.assert(delivery);\n\n  // Switch back to customer account\n  await api.functional.shoppings.customers.authenticate.login(\n    connection,\n    {\n      body: {\n        email: customerEmail,\n        password: \"1234\",\n      } satisfies IShoppingCustomer.ILogin,\n    },\n  );\n\n  // 9. Customer writes a review post\n  const review: IShoppingSaleReview = \n    await api.functional.shoppings.customers.sales.reviews.create(\n      connection,\n      {\n        saleId: sale.id,\n        body: {\n          good_id: order.goods[0].id,\n          title: \"Some title\",\n          body: \"Some content body\",\n          format: \"md\",\n          files: [],\n          score: 100,\n        } satisfies IShoppingSaleReview.ICreate,\n      },\n    );\n  typia.assert(review);\n\n  // 10. Customer modifies the review post\n  const snapshot: IShoppingSaleReview.ISnapshot = \n    await api.functional.shoppings.customers.sales.reviews.update(\n      connection,\n      {\n        saleId: sale.id,\n        id: review.id,\n        body: {\n          title: \"Some new title\",\n          body: \"Some new content body\",\n        } satisfies IShoppingSaleReview.IUpdate,\n      },\n    );\n  typia.assert(snapshot);\n\n  // 11. Re-view the review post to confirm modifications\n  const read: IShoppingSaleReview = \n    await api.functional.shoppings.customers.sales.reviews.at(\n      connection,\n      {\n        saleId: sale.id,\n        id: review.id,\n      },\n    );\n  typia.assert(read);\n  TestValidator.equals(\"snapshots\")(read.snapshots)([\n    ...review.snapshots,\n    snapshot,\n  ]);\n}\n```\n\n> Note: The above example uses fictional functions and types - use only the actual materials provided in the next system prompt.\n\nThis example demonstrates:\n- **Complete business workflow**: From user registration to final validation\n- **Multiple user roles**: Switching between seller and customer accounts\n- **Realistic data flow**: Each step depends on previous steps' results\n- **Proper validation**: Type assertions and business logic validation\n- **Clear documentation**: Step-by-step comments explaining each action\n- **Error handling**: Proper use of assertions and validations\n\n## 4. Quality Standards and Best Practices\n\n### 4.1. Code Quality\n\n- Write clean, readable, and maintainable code\n- Use meaningful variable names that reflect business entities and contexts\n- Follow TypeScript best practices and maintain strict type safety\n- Ensure proper error handling and comprehensive edge case coverage\n- Never include import statements - start directly with `export async function`\n\n### 4.2. Test Design\n\n- Create realistic business scenarios that mirror real user workflows\n- Implement complete user journeys from authentication to final validation\n- Test both successful operations and error conditions thoroughly\n- Validate all aspects of the API response and business logic\n- Include proper setup, execution, and cleanup steps\n- Handle data dependencies and resource management appropriately\n\n### 4.3. Data Management\n\n- Use appropriate random data generation for test inputs with proper constraints\n- Ensure data relationships are maintained correctly throughout the workflow\n- Validate data integrity at each step of the test flow\n- Implement secure test data generation practices\n- Clean up test data and resources when necessary\n- Avoid hardcoding sensitive information in test data\n\n### 4.4. Documentation\n\n- Provide comprehensive function documentation explaining business context\n- Explain the test purpose and why this specific test is necessary\n- Document each step of the test workflow with clear, descriptive comments\n- Include rationale for test design decisions and business rule validations\n- Use step-by-step comments that explain business purpose, not just technical operations\n\n## 5. Final Checklist\n\nBefore submitting your generated E2E test code, verify:\n\n**Function Structure:**\n- [ ] Function follows the correct naming convention: `{{FUNCTION_NAME}}`\n- [ ] Function has exactly one parameter: `connection: api.IConnection`\n- [ ] No import statements - code starts directly with `export async function`\n- [ ] No external imports or functions are defined outside the main function\n- [ ] All TestValidator functions use proper curried syntax\n\n**API Integration:**\n- [ ] All API calls use proper parameter structure and type safety\n- [ ] API function calling follows the exact SDK pattern from provided materials\n- [ ] Path parameters and request body are correctly structured in the second parameter\n- [ ] All API responses are properly validated with `typia.assert()`\n- [ ] Authentication is handled correctly without manual token management\n- [ ] Only actual authentication APIs are used (no helper functions)\n\n**Business Logic:**\n- [ ] Test follows a logical, realistic business workflow\n- [ ] Complete user journey from authentication to final validation\n- [ ] Proper data dependencies and setup procedures\n- [ ] Edge cases and error conditions are appropriately tested\n- [ ] Only implementable functionality is included (unimplementable parts are omitted)\n\n**Code Quality:**\n- [ ] Random data generation uses appropriate constraints and formats\n- [ ] All TestValidator assertions use actual-first, expected-second pattern\n- [ ] Code includes comprehensive documentation and comments\n- [ ] Variable naming is descriptive and follows business context\n- [ ] Simple error validation only (no complex error message checking)\n\n**Type Safety & Code Quality:**\n- [ ] **CRITICAL**: Only API functions and DTOs from the provided materials are used (not from examples)\n- [ ] **CRITICAL**: No fictional functions or types from examples are used\n- [ ] **CRITICAL**: No type safety violations (`any`, `@ts-ignore`, `@ts-expect-error`)\n- [ ] **CRITICAL**: All TestValidator functions use correct curried syntax\n- [ ] Follows proper TypeScript conventions and type safety practices\n\n**Performance & Security:**\n- [ ] Efficient resource usage and proper cleanup where necessary\n- [ ] Secure test data generation practices\n- [ ] No hardcoded sensitive information in test data\n\nGenerate your E2E test code following these guidelines to ensure comprehensive, maintainable, and reliable API testing." /* AutoBeSystemPromptConstant.TEST_WRITE */.replace("{{AutoBeTestScenario}}", JSON.stringify({
                 type: "object",
                 properties: {
                     endpoint: {

package/lib/agent/src/orchestrate/test/histories/transformTestWriteHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformTestWriteHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/test/histories/transformTestWriteHistories.ts"],"names":[],"mappings":";;;;;AAcA,kEAyDC;AArED,yCAAqE;AACrE,8CAI0B;AAC1B,kDAA0B;AAC1B,+BAA0B;AAK1B,SAAgB,2BAA2B,CACzC,QAA4B,EAC5B,SAAuC;IAEvC,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,s+1CAAsC,OAAO,CACjD,wBAAwB,EACxB,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqD,CACpE,CAAC,UAAU,CAAC,mBAAmB,EAAE,QAAQ,CAAC,YAAY,CAAC;SACzD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;;UAUjB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;;;;;;;;;UASxB,2BAA2B,CAAC,UAAU,CAAC,SAAS,CAAC;;;;;;;;UAQjD,2BAA2B,CAAC,UAAU,CAAC,SAAS,CAAC;;;;;;;UAOjD,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC;;OAEhC;SACF;KACF,CAAC;AACJ,CAAC;AACD,WAAiB,2BAA2B;IAC1C,SAAgB,UAAU,CAAC,SAAuC;QAChE,OAAO,kBAAU,CAAC,IAAI,CAAA;QAClB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC;aACjD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;aACpB,IAAI,CAAC,IAAI,CAAC;;;QAGX,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC;;KAEhC,CAAC;IACJ,CAAC;IAVe,sCAAU,aAUzB,CAAA;IAED,SAAgB,UAAU,CAAC,SAAuC;QAChE,MAAM,QAAQ,GAAsB,IAAA,gCAAwB,EAC1D,SAAS,CAAC,QAAQ,CACnB,CAAC;QACF,MAAM,GAAG,GAA4B,uBAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACzE,OAAO,kBAAU,CAAC,IAAI,CAAA;;;QAGlB,GAAG,CAAC,MAAM;aACT,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACT,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,CAC/D,KAAK,CACN,CACF;aACA,IAAI,CAAC,IAAI,CAAC;;;QAGX,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC;;KAEhC,CAAC;IACJ,CAAC;IApBe,sCAAU,aAoBzB,CAAA;AACH,CAAC,EAlCgB,2BAA2B,2CAA3B,2BAA2B,QAkC3C"}
+{"version":3,"file":"transformTestWriteHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/test/histories/transformTestWriteHistories.ts"],"names":[],"mappings":";;;;;AAcA,kEAyDC;AArED,yCAAqE;AACrE,8CAI0B;AAC1B,kDAA0B;AAC1B,+BAA0B;AAK1B,SAAgB,2BAA2B,CACzC,QAA4B,EAC5B,SAAuC;IAEvC,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,ik4CAAsC,OAAO,CACjD,wBAAwB,EACxB,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqD,CACpE,CAAC,UAAU,CAAC,mBAAmB,EAAE,QAAQ,CAAC,YAAY,CAAC;SACzD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;;UAUjB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;;;;;;;;;UASxB,2BAA2B,CAAC,UAAU,CAAC,SAAS,CAAC;;;;;;;;UAQjD,2BAA2B,CAAC,UAAU,CAAC,SAAS,CAAC;;;;;;;UAOjD,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC;;OAEhC;SACF;KACF,CAAC;AACJ,CAAC;AACD,WAAiB,2BAA2B;IAC1C,SAAgB,UAAU,CAAC,SAAuC;QAChE,OAAO,kBAAU,CAAC,IAAI,CAAA;QAClB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC;aACjD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;aACpB,IAAI,CAAC,IAAI,CAAC;;;QAGX,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC;;KAEhC,CAAC;IACJ,CAAC;IAVe,sCAAU,aAUzB,CAAA;IAED,SAAgB,UAAU,CAAC,SAAuC;QAChE,MAAM,QAAQ,GAAsB,IAAA,gCAAwB,EAC1D,SAAS,CAAC,QAAQ,CACnB,CAAC;QACF,MAAM,GAAG,GAA4B,uBAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACzE,OAAO,kBAAU,CAAC,IAAI,CAAA;;;QAGlB,GAAG,CAAC,MAAM;aACT,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACT,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,CAC/D,KAAK,CACN,CACF;aACA,IAAI,CAAC,IAAI,CAAC;;;QAGX,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC;;KAEhC,CAAC;IACJ,CAAC;IApBe,sCAAU,aAoBzB,CAAA;AACH,CAAC,EAlCgB,2BAA2B,2CAA3B,2BAA2B,QAkC3C"}

package/lib/agent/src/orchestrate/test/orchestrateTest.js

@@ -11,18 +11,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestrateTest = void 0;
 const uuid_1 = require("uuid");
+const predicateStateMessage_1 = require("../../utils/predicateStateMessage");
 const orchestrateTestCorrect_1 = require("./orchestrateTestCorrect");
 const orchestrateTestScenario_1 = require("./orchestrateTestScenario");
 const orchestrateTestWrite_1 = require("./orchestrateTestWrite");
 const orchestrateTest = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d, _e, _f;
+    // PREDICATION
     const start = new Date();
+    const predicate = (0, predicateStateMessage_1.predicateStateMessage)(ctx.state(), "test");
+    if (predicate !== null)
+        return ctx.assistantMessage({
+            type: "assistantMessage",
+            id: (0, uuid_1.v4)(),
+            created_at: start.toISOString(),
+            text: predicate,
+            completed_at: new Date().toISOString(),
+        });
     ctx.dispatch({
         type: "testStart",
         created_at: start.toISOString(),
         reason: props.reason,
         step: (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
     });
+    // CHECK OPERATIONS
     const operations = (_d = (_c = ctx.state().interface) === null || _c === void 0 ? void 0 : _c.document.operations) !== null && _d !== void 0 ? _d : [];
     if (operations.length === 0)
         return ctx.assistantMessage({

package/lib/agent/src/orchestrate/test/orchestrateTest.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrateTest.js","sourceRoot":"","sources":["../../../../../src/orchestrate/test/orchestrateTest.ts"],"names":[],"mappings":";;;;;;;;;;;;AAUA,+BAA0B;AAI1B,qEAAkE;AAClE,uEAAoE;AACpE,iEAA8D;AAGvD,MAAM,eAAe,GAC1B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EAC8B,EAAE;;IAC9D,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;IAC/B,GAAG,CAAC,QAAQ,CAAC;QACX,IAAI,EAAE,WAAW;QACjB,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;QAC/B,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;KACrC,CAAC,CAAC;IAEH,MAAM,UAAU,GACd,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,SAAS,0CAAE,QAAQ,CAAC,UAAU,mCAAI,EAAE,CAAC;IACnD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QACzB,OAAO,GAAG,CAAC,gBAAgB,CAAC;YAC1B,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,IAAI,EAAE,kBAAkB;YACxB,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,YAAY,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACtC,IAAI,EACF,6DAA6D;gBAC7D,gDAAgD;SACnD,CAAC,CAAC;IAEL,OAAO;IACP,MAAM,SAAS,GAAyB,MAAM,IAAA,iDAAuB,EAAC,GAAG,CAAC,CAAC;IAE3E,YAAY;IACZ,MAAM,OAAO,GAA6B,MAAM,IAAA,2CAAoB,EAClE,GAAG,EACH,SAAS,CACV,CAAC;IAEF,MAAM,QAAQ,GAA8B,MAAM,IAAA,+CAAsB,EACtE,GAAG,EACH,OAAO,CACR,CAAC;IACF,MAAM,OAAO,GAA8B,QAAQ,CAAC,MAAM,CACxD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,CACnC,CAAC;IAEF,aAAa;IACb,MAAM,QAAQ,GAAoB,MAAM,GAAG,CAAC,QAAQ,EAAE,CAAC;IACvD,MAAM,QAAQ,GACZ,MAAM,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC;YACxB,GAAG,MAAM,CAAC,OAAO,CACf,MAAM,GAAG,CAAC,KAAK,CAAC;gBACd,IAAI,EAAE,QAAQ;aACf,CAAC,CACH,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACxC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACzD,CAAC;KACH,CAAC,CAAC;IACL,OAAO,GAAG,CAAC,QAAQ,CAAC;QAClB,IAAI,EAAE,cAAc;QACpB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACjC,QAAQ;QACR,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,SAAS,0CAAE,IAAI,mCAAI,CAAC;QACtC,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE;KAChD,CAAC,CAAC;AACL,CAAC,CAAA,CAAC;AAhES,QAAA,eAAe,mBAgExB"}
+{"version":3,"file":"orchestrateTest.js","sourceRoot":"","sources":["../../../../../src/orchestrate/test/orchestrateTest.ts"],"names":[],"mappings":";;;;;;;;;;;;AAUA,+BAA0B;AAI1B,6EAA0E;AAC1E,qEAAkE;AAClE,uEAAoE;AACpE,iEAA8D;AAGvD,MAAM,eAAe,GAC1B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EAC8B,EAAE;;IAC9D,cAAc;IACd,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;IAC/B,MAAM,SAAS,GAAkB,IAAA,6CAAqB,EAAC,GAAG,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC,CAAC;IAC5E,IAAI,SAAS,KAAK,IAAI;QACpB,OAAO,GAAG,CAAC,gBAAgB,CAAC;YAC1B,IAAI,EAAE,kBAAkB;YACxB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,IAAI,EAAE,SAAS;YACf,YAAY,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACvC,CAAC,CAAC;IACL,GAAG,CAAC,QAAQ,CAAC;QACX,IAAI,EAAE,WAAW;QACjB,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;QAC/B,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;KACrC,CAAC,CAAC;IAEH,mBAAmB;IACnB,MAAM,UAAU,GACd,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,SAAS,0CAAE,QAAQ,CAAC,UAAU,mCAAI,EAAE,CAAC;IACnD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QACzB,OAAO,GAAG,CAAC,gBAAgB,CAAC;YAC1B,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,IAAI,EAAE,kBAAkB;YACxB,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,YAAY,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACtC,IAAI,EACF,6DAA6D;gBAC7D,gDAAgD;SACnD,CAAC,CAAC;IAEL,OAAO;IACP,MAAM,SAAS,GAAyB,MAAM,IAAA,iDAAuB,EAAC,GAAG,CAAC,CAAC;IAE3E,YAAY;IACZ,MAAM,OAAO,GAA6B,MAAM,IAAA,2CAAoB,EAClE,GAAG,EACH,SAAS,CACV,CAAC;IAEF,MAAM,QAAQ,GAA8B,MAAM,IAAA,+CAAsB,EACtE,GAAG,EACH,OAAO,CACR,CAAC;IACF,MAAM,OAAO,GAA8B,QAAQ,CAAC,MAAM,CACxD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,CACnC,CAAC;IAEF,aAAa;IACb,MAAM,QAAQ,GAAoB,MAAM,GAAG,CAAC,QAAQ,EAAE,CAAC;IACvD,MAAM,QAAQ,GACZ,MAAM,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC;YACxB,GAAG,MAAM,CAAC,OAAO,CACf,MAAM,GAAG,CAAC,KAAK,CAAC;gBACd,IAAI,EAAE,QAAQ;aACf,CAAC,CACH,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACxC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACzD,CAAC;KACH,CAAC,CAAC;IACL,OAAO,GAAG,CAAC,QAAQ,CAAC;QAClB,IAAI,EAAE,cAAc;QACpB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACjC,QAAQ;QACR,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,SAAS,0CAAE,IAAI,mCAAI,CAAC;QACtC,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE;KAChD,CAAC,CAAC;AACL,CAAC,CAAA,CAAC;AA3ES,QAAA,eAAe,mBA2ExB"}