feat: add wrapper-based API testing approach

.github/release-please/manifest.json

@@ -1 +1 @@
-{".":"0.4.0"}
+{".":"0.4.1"}

.serena/.gitignore

@@ -0,0 +1 @@
+/cache

.serena/project.yml

@@ -0,0 +1,67 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: typescript
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed) on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "itdoc"

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.4.1](https://github.com/do-pa/itdoc/compare/v0.4.0...v0.4.1) (2025-08-21)
+
+
+### 🩹 Fixes
+
+* og_image is not working ([#231](https://github.com/do-pa/itdoc/issues/231)) ([d1070ec](https://github.com/do-pa/itdoc/commit/d1070ec1064cf914b576e2eb9153378903ccaf89)), closes [#230](https://github.com/do-pa/itdoc/issues/230)
+* resolve issue causing LLM script to not run properly ([#235](https://github.com/do-pa/itdoc/issues/235)) ([1fa8d90](https://github.com/do-pa/itdoc/commit/1fa8d90fe14c37031baaa58f375550785f055275))
+
 ## [0.4.0](https://github.com/do-pa/itdoc/compare/v0.3.0...v0.4.0) (2025-08-08)
 
 

bin/index.ts

@@ -55,22 +55,19 @@ Example:
 program
     .command("generate")
     .description("Generate ITDOC test code based on LLM.")
-    .option("-p, --path <testspecPath>", "Path to the markdown test spec file.")
     .option("-a, --app <appPath>", "Path to the Express root app file.")
     .option("-e, --env <envPath>", "Path to the .env file.")
-    .action((options: { path?: string; env?: string; app?: string }) => {
+    .action(async (options: { env?: string; app?: string }) => {
         const envPath = options.env
             ? path.isAbsolute(options.env)
                 ? options.env
                 : path.resolve(process.cwd(), options.env)
             : path.resolve(process.cwd(), ".env")
 
-        if (!options.path && !options.app) {
+        if (!options.app) {
             logger.error(
-                "Either a test spec path (-p) or an Express app path (-a) must be provided. By default, the OpenAI key (OPENAI_API_KEY in .env) is loaded from the root directory, but you can customize the path if needed",
+                "An Express app path (-a) must be provided. By default, the OpenAI key (OPENAI_API_KEY in .env) is loaded from the root directory, but you can customize the path with -e/--env if needed.",
             )
-            logger.info("ex) itdoc generate -p ../md/testspec.md")
-            logger.info("ex) itdoc generate --path ../md/testspec.md")
             logger.info("ex) itdoc generate -a ../app.js")
             logger.info("ex) itdoc generate --app ../app.js")
             logger.info("ex) itdoc generate -a ../app.js -e <custom path : env>")
@@ -80,12 +77,14 @@ program
         logger.box("ITDOC LLM START")
         if (options.app) {
             const appPath = resolvePath(options.app)
+
             logger.info(`Running analysis based on Express app path: ${appPath}`)
-            generateByLLM("", appPath, envPath)
-        } else if (options.path) {
-            const specPath = resolvePath(options.path)
-            logger.info(`Running analysis based on test spec (MD) path: ${specPath}`)
-            generateByLLM(specPath, "", envPath)
+            try {
+                await generateByLLM(appPath, envPath)
+            } catch (err) {
+                logger.error(`LLM generation failed: ${(err as Error).message}`)
+                process.exit(1)
+            }
         }
     })
 

examples/express-ts/jest.config.ts

@@ -3,12 +3,15 @@ import type { Config } from "jest"
 const jestConfig: Config = {
     testEnvironment: "node",
     roots: ["<rootDir>/src"],
-    testMatch: ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
+    testMatch: ["**/__tests__/jest/**/*.spec.ts"],
     transform: {
         "^.+\\.ts$": [
             "ts-jest",
             {
                 tsconfig: "tsconfig.json",
+                diagnostics: {
+                    ignoreCodes: [18046],
+                },
             },
         ],
     },

examples/express-ts/package.json

@@ -8,7 +8,7 @@
         "start": "node dist/index.js",
         "test": "pnpm run test:jest && pnpm run test:mocha",
         "test:jest": "jest",
-        "test:mocha": "mocha --require tsx \"src/**/__tests__/**/*.test.ts\""
+        "test:mocha": "mocha --require tsx \"src/__tests__/mocha/**/*.test.ts\""
     },
     "dependencies": {
         "cors": "^2.8.5",
@@ -20,6 +20,7 @@
         "@types/express": "^4.17.21",
         "@types/jest": "^30.0.0",
         "@types/mocha": "^10.0.10",
+        "@types/multer": "^2.0.0",
         "@types/node": "^20.10.5",
         "@types/supertest": "^6.0.2",
         "itdoc": "workspace:*",

examples/express-ts/src/__tests__/jest/product.wrapper.spec.ts

@@ -0,0 +1,212 @@
+/**
+ * Product API Tests using wrapTest wrapper approach
+ *
+ * This demonstrates the new high-order function wrapping method
+ * that automatically captures HTTP requests/responses
+ */
+
+import { app } from "../../index"
+import { wrapTest, createClient } from "itdoc"
+import { ProductService } from "../../services/productService"
+
+const apiTest = wrapTest(it)
+
+const request = createClient.supertest(app)
+
+describe("Product API - Wrapper Approach", () => {
+    beforeEach(() => {
+        ProductService.resetProducts()
+    })
+    describe("GET /api/products/:id", () => {
+        apiTest.withMeta({
+            summary: "Get product by ID",
+            tags: ["Products"],
+            description: "Retrieves a specific product by its ID",
+        })("should return a specific product", async () => {
+            const response = await request.get("/api/products/1")
+
+            expect(response.status).toBe(200)
+            expect(response.body).toHaveProperty("id", 1)
+            expect(response.body).toHaveProperty("name", "Laptop")
+            expect(response.body).toHaveProperty("price", 999.99)
+            expect(response.body).toHaveProperty("category", "Electronics")
+        })
+
+        apiTest("should return product with different ID", async () => {
+            const response = await request.get("/api/products/2")
+
+            expect(response.status).toBe(200)
+            expect(response.body).toHaveProperty("id", 2)
+            expect(response.body).toHaveProperty("name", "Smartphone")
+        })
+    })
+
+    describe("POST /api/products", () => {
+        apiTest.withMeta({
+            summary: "Create new product",
+            tags: ["Products", "Create"],
+            description: "Creates a new product with the provided information",
+        })("should create a new product", async () => {
+            const response = await request.post("/api/products").send({
+                name: "Test Product",
+                price: 99.99,
+                category: "Test Category",
+            })
+
+            expect(response.status).toBe(201)
+            expect(response.body).toHaveProperty("id", 3)
+            expect(response.body).toHaveProperty("name", "Test Product")
+            expect(response.body).toHaveProperty("price", 99.99)
+            expect(response.body).toHaveProperty("category", "Test Category")
+        })
+
+        apiTest.withMeta({
+            summary: "Create product with different data",
+            tags: ["Products", "Create"],
+        })("should create another product", async () => {
+            const response = await request.post("/api/products").send({
+                name: "Another Product",
+                price: 199.99,
+                category: "Another Category",
+            })
+
+            expect(response.status).toBe(201)
+            expect(response.body.name).toBe("Another Product")
+        })
+    })
+
+    describe("PUT /api/products/:id", () => {
+        apiTest.withMeta({
+            summary: "Update product",
+            tags: ["Products", "Update"],
+            description: "Updates an existing product with the provided information",
+        })("should update a product", async () => {
+            const response = await request.put("/api/products/1").send({
+                name: "Updated Product",
+                price: 199.99,
+                category: "Updated Category",
+            })
+
+            expect(response.status).toBe(200)
+            expect(response.body).toHaveProperty("id", 1)
+            expect(response.body).toHaveProperty("name", "Updated Product")
+            expect(response.body).toHaveProperty("price", 199.99)
+            expect(response.body).toHaveProperty("category", "Updated Category")
+        })
+
+        apiTest("should update product with partial data", async () => {
+            const response = await request.put("/api/products/2").send({
+                name: "Partially Updated",
+                price: 299.99,
+                category: "Electronics",
+            })
+
+            expect(response.status).toBe(200)
+            expect(response.body.name).toBe("Partially Updated")
+        })
+    })
+
+    describe("Complete product CRUD workflow", () => {
+        apiTest.withMeta({
+            summary: "Product CRUD workflow",
+            tags: ["Products", "Workflow", "CRUD"],
+            description: "Complete create, read, update, delete workflow for products",
+        })("should perform complete CRUD operations", async () => {
+            const createResponse = await request.post("/api/products").send({
+                name: "Workflow Product",
+                price: 149.99,
+                category: "Test",
+            })
+
+            expect(createResponse.status).toBe(201)
+            const productId = createResponse.body.id
+
+            const getResponse = await request.get(`/api/products/${productId}`)
+
+            expect(getResponse.status).toBe(200)
+            expect(getResponse.body.name).toBe("Workflow Product")
+
+            const updateResponse = await request.put(`/api/products/${productId}`).send({
+                name: "Updated Workflow Product",
+                price: 179.99,
+                category: "Updated Test",
+            })
+
+            expect(updateResponse.status).toBe(200)
+            expect(updateResponse.body.name).toBe("Updated Workflow Product")
+
+            const deleteResponse = await request.delete(`/api/products/${productId}`)
+
+            expect(deleteResponse.status).toBe(204)
+        })
+    })
+
+    describe("Product filtering and search", () => {
+        apiTest.withMeta({
+            summary: "Filter products by category",
+            tags: ["Products", "Filter"],
+        })("should filter products with query params", async () => {
+            const response = await request
+                .get("/api/products/1")
+                .query({ category: "Electronics", minPrice: 500 })
+
+            expect(response.status).toBe(200)
+        })
+
+        apiTest("should search products with multiple params", async () => {
+            const response = await request.get("/api/products/1").query({
+                search: "laptop",
+                sortBy: "price",
+                order: "asc",
+            })
+
+            expect(response.status).toBe(200)
+        })
+    })
+
+    describe("Product API with authentication", () => {
+        apiTest.withMeta({
+            summary: "Create product with auth",
+            tags: ["Products", "Authentication"],
+        })("should create product with authorization header", async () => {
+            const response = await request
+                .post("/api/products")
+                .set("Authorization", "Bearer fake-token-123")
+                .send({
+                    name: "Authenticated Product",
+                    price: 299.99,
+                    category: "Secure",
+                })
+
+            expect(response.status).toBe(201)
+        })
+
+        apiTest("should include custom headers", async () => {
+            const response = await request
+                .get("/api/products/1")
+                .set("Authorization", "Bearer token")
+                .set("X-Client-ID", "test-client")
+                .set("Accept", "application/json")
+
+            expect(response.status).toBe(200)
+        })
+    })
+
+    describe("DELETE /api/products/:id", () => {
+        apiTest.withMeta({
+            summary: "Delete product",
+            tags: ["Products", "Delete"],
+            description: "Deletes a product by its ID",
+        })("should delete a product", async () => {
+            const response = await request.delete("/api/products/1")
+
+            expect(response.status).toBe(204)
+        })
+
+        apiTest("should delete another product", async () => {
+            const response = await request.delete("/api/products/2")
+
+            expect(response.status).toBe(204)
+        })
+    })
+})