@schmock/faker 2.3.0 → 2.4.0

package/src/plugin-integration.test.ts

@@ -1,575 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { version as packageVersion } from "../package.json";
-import { fakerPlugin } from "./index";
-import { schemas, validators } from "./test-utils";
-
-describe("Schema Plugin Integration", () => {
-  describe("Plugin Lifecycle", () => {
-    it("validates schema during plugin creation", () => {
-      // Valid schema should create plugin
-      const validPlugin = fakerPlugin({
-        schema: schemas.complex.user(),
-      });
-      expect(validPlugin).toBeDefined();
-      expect(validPlugin.name).toBe("faker");
-      expect(validPlugin.version).toBe(packageVersion);
-
-      // Invalid schema should throw immediately
-      expect(() => {
-        fakerPlugin({
-          schema: { type: "invalid" as any },
-        });
-      }).toThrow("Invalid schema type");
-    });
-
-    it("processes context through plugin pipeline", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          requestId: { type: "string" },
-          timestamp: { type: "string" },
-          data: { type: "object" },
-        }),
-      });
-
-      const context = {
-        method: "POST",
-        path: "/api/data",
-        params: {},
-        query: {},
-        state: { requestId: "req-123" },
-        headers: { "content-type": "application/json" },
-        body: { value: 42 },
-        route: { pattern: "/api/data" },
-      };
-
-      const result = await plugin.process(context);
-
-      expect(result).toHaveProperty("context");
-      expect(result).toHaveProperty("response");
-      expect(result.context).toBe(context); // Context passed through
-      expect(result.response).toHaveProperty("requestId");
-      expect(result.response).toHaveProperty("timestamp");
-      expect(result.response).toHaveProperty("data");
-    });
-
-    it("preserves existing responses when present", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({ id: schemas.simple.number() }),
-      });
-
-      const context = {
-        method: "GET",
-        path: "/test",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const existingResponse = {
-        cached: true,
-        data: [1, 2, 3],
-        metadata: { source: "cache" },
-      };
-
-      const result = await plugin.process(context, existingResponse);
-
-      expect(result.response).toBe(existingResponse);
-      expect(result.response).toEqual(existingResponse);
-    });
-  });
-
-  describe("Context Integration", () => {
-    it("uses params in template overrides", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          userId: { type: "string" },
-          postId: { type: "string" },
-          action: { type: "string" },
-        }),
-        overrides: {
-          userId: "{{params.userId}}",
-          postId: "{{params.postId}}",
-          action: "view",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/users/123/posts/456",
-        params: { userId: "123", postId: "456" },
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response.userId).toBe("123"); // Template values are strings
-      expect(result.response.postId).toBe("456");
-      expect(result.response.action).toBe("view");
-    });
-
-    it("uses query parameters in templates", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          page: { type: "number" },
-          limit: { type: "number" },
-          sort: { type: "string" },
-          filter: { type: "string" },
-        }),
-        overrides: {
-          page: "{{query.page}}",
-          limit: "{{query.limit}}",
-          sort: "{{query.sort}}",
-          filter: "{{query.filter}}",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/items",
-        params: {},
-        query: {
-          page: "2",
-          limit: "50",
-          sort: "name",
-          filter: "active",
-        },
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response.page).toBe("2"); // Query values are strings
-      expect(result.response.limit).toBe("50");
-      expect(result.response.sort).toBe("name");
-      expect(result.response.filter).toBe("active");
-    });
-
-    it("uses state in template processing", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          currentUser: { type: "string" },
-          sessionId: { type: "string" },
-          permissions: { type: "array", items: { type: "string" } },
-        }),
-        overrides: {
-          currentUser: "{{state.user.name}}",
-          sessionId: "{{state.session.id}}",
-          permissions: ["read", "write"],
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/profile",
-        params: {},
-        query: {},
-        state: new Map(),
-        routeState: {
-          user: { id: 1, name: "John Doe" },
-          session: { id: "sess-123", expires: "2024-12-31" },
-        },
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response.currentUser).toBe("John Doe");
-      expect(result.response.sessionId).toBe("sess-123");
-      expect(result.response.permissions).toEqual(["read", "write"]);
-    });
-
-    it("handles missing template values gracefully", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          value1: { type: "string" },
-          value2: { type: "string" },
-          value3: { type: "string" },
-        }),
-        overrides: {
-          value1: "{{params.missing}}",
-          value2: "{{state.nonexistent.nested}}",
-          value3: "default",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/test",
-        params: { other: "value" },
-        query: {},
-        state: new Map(),
-        routeState: { different: "data" },
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      // Missing values return original template
-      expect(result.response.value1).toBe("{{params.missing}}");
-      expect(result.response.value2).toBe("{{state.nonexistent.nested}}");
-      expect(result.response.value3).toBe("default");
-    });
-  });
-
-  describe("Array Generation with Plugin", () => {
-    it("generates arrays with count parameter", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.array(
-          schemas.simple.object({
-            id: { type: "number" },
-            name: { type: "string" },
-          }),
-        ),
-        count: 5,
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/items",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(Array.isArray(result.response)).toBe(true);
-      expect(result.response).toHaveLength(5);
-      result.response.forEach((item) => {
-        expect(item).toHaveProperty("id");
-        expect(item).toHaveProperty("name");
-      });
-    });
-
-    it("applies overrides to array items", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.array(
-          schemas.simple.object({
-            index: { type: "number" },
-            category: { type: "string" },
-          }),
-        ),
-        count: 3,
-        overrides: {
-          category: "{{state.defaultCategory}}",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/items",
-        params: {},
-        query: {},
-        state: new Map(),
-        routeState: { defaultCategory: "electronics" },
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response).toHaveLength(3);
-      result.response.forEach((item) => {
-        expect(item.category).toBe("electronics");
-      });
-    });
-  });
-
-  describe("Error Handling in Plugin", () => {
-    it("wraps generation errors with context", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          type: "string",
-          pattern: "[", // Invalid regex
-        },
-      });
-
-      const context = {
-        method: "GET",
-        path: "/api/test/123",
-        params: { id: "123" },
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      try {
-        await plugin.process(context);
-        expect.fail("Should have thrown");
-      } catch (error: any) {
-        // Should throw some kind of error for invalid pattern
-        expect(error).toBeDefined();
-        expect(error.name).toContain("Error");
-      }
-    });
-
-    it("handles null or undefined context properties", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          data: { type: "string" },
-        }),
-      });
-
-      // Should not crash with null/undefined properties
-      const result = await plugin.process({
-        method: "GET",
-        path: "/test",
-        params: null as any,
-        query: undefined as any,
-        state: null as any,
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response).toHaveProperty("data");
-      expect(typeof result.response.data).toBe("string");
-    });
-  });
-
-  describe("Complex Schema Scenarios", () => {
-    it("handles conditional schemas in plugin", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          type: "object",
-          properties: {
-            type: { type: "string", enum: ["user", "admin"] },
-            data: { type: "object" },
-          },
-          required: ["type", "data"],
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/profile",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(["user", "admin"]).toContain(result.response.type);
-      expect(result.response).toHaveProperty("data");
-    });
-
-    it("generates nested data with references", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          $defs: {
-            timestamp: { type: "string", format: "date-time" },
-            user: {
-              type: "object",
-              properties: {
-                id: { type: "string", format: "uuid" },
-                name: { type: "string" },
-              },
-            },
-          },
-          type: "object",
-          properties: {
-            created: { $ref: "#/$defs/timestamp" },
-            updated: { $ref: "#/$defs/timestamp" },
-            author: { $ref: "#/$defs/user" },
-            editor: { $ref: "#/$defs/user" },
-          },
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/document",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(
-        validators.appearsToBeFromCategory([result.response.created], "date"),
-      ).toBe(true);
-      expect(
-        validators.appearsToBeFromCategory([result.response.updated], "date"),
-      ).toBe(true);
-      // $ref-resolved schemas may not preserve format through JSF resolution
-      expect(result.response.author).toHaveProperty("id");
-      expect(typeof result.response.author.id).toBe("string");
-      expect(result.response.editor).toHaveProperty("id");
-      expect(typeof result.response.editor.id).toBe("string");
-    });
-  });
-
-  describe("Performance Characteristics", () => {
-    it("maintains consistent performance across multiple calls", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.complex.user(),
-      });
-
-      const context = {
-        method: "GET",
-        path: "/api/user",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      // Generate multiple times
-      const results: any[] = [];
-      for (let i = 0; i < 10; i++) {
-        const r = await plugin.process(context);
-        results.push(r.response);
-      }
-
-      // All should be valid but different
-      results.forEach((result) => {
-        expect(result).toHaveProperty("id");
-        expect(result).toHaveProperty("email");
-      });
-
-      // Should generate different data each time
-      const emails = results.map((r) => r.email);
-      const uniqueEmails = new Set(emails);
-      expect(uniqueEmails.size).toBeGreaterThan(5);
-    });
-
-    it("handles large schemas efficiently", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          type: "object",
-          properties: Object.fromEntries(
-            Array.from({ length: 50 }, (_, i) => [
-              `field${i}`,
-              { type: i % 2 === 0 ? "string" : "number" },
-            ]),
-          ),
-        },
-      });
-
-      const context = {
-        method: "GET",
-        path: "/api/data",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const result = await plugin.process(context);
-
-      // Should have all fields
-      expect(Object.keys(result.response).length).toBeGreaterThanOrEqual(50);
-    });
-  });
-
-  describe("Real-world Plugin Usage", () => {
-    it("generates mock API responses for testing", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          type: "object",
-          properties: {
-            success: { type: "boolean", const: true },
-            data: {
-              type: "object",
-              properties: {
-                id: { type: "string", format: "uuid" },
-                email: { type: "string", format: "email" },
-                profile: {
-                  type: "object",
-                  properties: {
-                    name: { type: "string" },
-                    avatar: { type: "string", format: "uri" },
-                  },
-                },
-              },
-            },
-            timestamp: { type: "string", format: "date-time" },
-          },
-        },
-        overrides: {
-          "data.id": "{{params.userId}}",
-          timestamp: "{{state.currentTime}}",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/users/user-123",
-        params: { userId: "user-123" },
-        query: {},
-        state: new Map(),
-        routeState: { currentTime: "2024-01-01T12:00:00Z" },
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response.success).toBe(true);
-      expect(result.response.data.id).toBe("user-123");
-      expect(result.response.timestamp).toBe("2024-01-01T12:00:00Z");
-      expect(
-        validators.appearsToBeFromCategory(
-          [result.response.data.email],
-          "email",
-        ),
-      ).toBe(true);
-    });
-
-    it("works with schmock plugin pipeline", async () => {
-      const schemaPlug = fakerPlugin({
-        schema: schemas.simple.object({
-          message: { type: "string" },
-          code: { type: "number" },
-        }),
-      });
-
-      // Mock another plugin in the pipeline
-      const loggingPlugin = {
-        name: "logger",
-        version: "1.0.0",
-        process: (ctx: any, response: any) => {
-          console.log(`Processing ${ctx.path}`);
-          return { context: ctx, response };
-        },
-      };
-
-      // Simulate pipeline execution
-      const context = {
-        method: "GET",
-        path: "/api/status",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      // First plugin generates response
-      const result1 = await schemaPlug.process(context);
-
-      // Second plugin receives generated response
-      const result2 = loggingPlugin.process(result1.context, result1.response);
-
-      expect(result2.response).toHaveProperty("message");
-      expect(result2.response).toHaveProperty("code");
-      expect(result2.response).toBe(result1.response); // Same reference
-    });
-  });
-});