@missioncontrolio/client 0.0.3

package/tests/autoCancelOrderHandler.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import type { RequestOption } from "@microsoft/kiota-abstractions";
+import type { Middleware } from "@microsoft/kiota-http-fetchlibrary";
+import { AutoCancelOrderHandler } from "../src/client/autoCancelOrderHandler";
+import { MissionControlHeaders } from "../src/client/missionControlHeaders";
+
+const TEST_REQUEST_ID = "aaaabbbb-cccc-dddd-eeee-ffffffffffff";
+const BASE = "https://api.test.com";
+
+// -- Recording middleware (equivalent to C# RecordingHandler) ----------------
+
+interface CapturedRequest {
+  url: string;
+  init: RequestInit;
+  body: string | null;
+}
+
+class RecordingMiddleware implements Middleware {
+  next: Middleware | undefined;
+  sentRequests: CapturedRequest[] = [];
+  private queue: Array<Response | Error> = [];
+
+  enqueueResponse(status: number, body?: string): void {
+    this.queue.push(new Response(body ?? null, { status }));
+  }
+
+  enqueueError(error: Error): void {
+    this.queue.push(error);
+  }
+
+  async execute(
+    url: string,
+    requestInit: RequestInit,
+    _requestOptions?: Record<string, RequestOption>,
+  ): Promise<Response> {
+    const body = requestInit.body != null ? String(requestInit.body) : null;
+    this.sentRequests.push({ url, init: { ...requestInit }, body });
+
+    const item = this.queue.shift();
+    if (!item) return new Response(null, { status: 200 });
+    if (item instanceof Error) throw item;
+    return item;
+  }
+}
+
+// -- Helpers -----------------------------------------------------------------
+
+function createPipeline(): {
+  handler: AutoCancelOrderHandler;
+  inner: RecordingMiddleware;
+} {
+  const inner = new RecordingMiddleware();
+  const handler = new AutoCancelOrderHandler();
+  handler.next = inner;
+  return { handler, inner };
+}
+
+function createOrderBody(requestId: string): string {
+  return JSON.stringify({ requestId });
+}
+
+function createOrderInit(path: string, requestId: string): [string, RequestInit] {
+  return [
+    `${BASE}${path}`,
+    {
+      method: "POST",
+      headers: new Headers({ "Content-Type": "application/json" }),
+      body: createOrderBody(requestId),
+    },
+  ];
+}
+
+function assertIsCancelRequest(
+  captured: CapturedRequest,
+  expectedRequestId: string,
+): void {
+  expect(new URL(captured.url).pathname).toContain("/Order/cancelOrder");
+  expect(captured.body).not.toBeNull();
+  const parsed = JSON.parse(captured.body!);
+  expect(parsed.originalRequestId).toBe(expectedRequestId);
+}
+
+// -- Tests -------------------------------------------------------------------
+
+describe("AutoCancelOrderHandler", () => {
+  let handler: AutoCancelOrderHandler;
+  let inner: RecordingMiddleware;
+
+  beforeEach(() => {
+    ({ handler, inner } = createPipeline());
+  });
+
+  it("successful request does not send cancel request", async () => {
+    inner.enqueueResponse(200);
+    const [url, init] = createOrderInit("/Order/createOrder", TEST_REQUEST_ID);
+
+    const response = await handler.execute(url, init);
+
+    expect(response.status).toBe(200);
+    expect(inner.sentRequests).toHaveLength(1);
+  });
+
+  it.each([500, 502, 503, 504])(
+    "server error %i sends cancel request",
+    async (status) => {
+      inner.enqueueResponse(status);
+      inner.enqueueResponse(200); // cancel response
+      const [url, init] = createOrderInit(
+        "/Order/createOrder",
+        TEST_REQUEST_ID,
+      );
+
+      const response = await handler.execute(url, init);
+
+      expect(response.status).toBe(status);
+      expect(inner.sentRequests).toHaveLength(2);
+      assertIsCancelRequest(inner.sentRequests[1], TEST_REQUEST_ID);
+    },
+  );
+
+  it("client error does not send cancel request", async () => {
+    inner.enqueueResponse(400);
+    const [url, init] = createOrderInit("/Order/createOrder", TEST_REQUEST_ID);
+
+    const response = await handler.execute(url, init);
+
+    expect(response.status).toBe(400);
+    expect(inner.sentRequests).toHaveLength(1);
+  });
+
+  it("connection error sends cancel request and rethrows", async () => {
+    inner.enqueueError(new TypeError("fetch failed"));
+    inner.enqueueResponse(200); // cancel response
+    const [url, init] = createOrderInit("/Order/createOrder", TEST_REQUEST_ID);
+
+    await expect(handler.execute(url, init)).rejects.toThrow("fetch failed");
+
+    expect(inner.sentRequests).toHaveLength(2);
+    assertIsCancelRequest(inner.sentRequests[1], TEST_REQUEST_ID);
+  });
+
+  it("non-order endpoint does not send cancel request on error", async () => {
+    inner.enqueueResponse(500);
+    const response = await handler.execute(`${BASE}/Product`, {
+      method: "POST",
+      headers: new Headers({ "Content-Type": "application/json" }),
+      body: "{}",
+    });
+
+    expect(response.status).toBe(500);
+    expect(inner.sentRequests).toHaveLength(1);
+  });
+
+  it("claimReservation sends cancel request on error", async () => {
+    inner.enqueueResponse(500);
+    inner.enqueueResponse(200);
+    const [url, init] = createOrderInit(
+      "/Order/claimReservation/some-id",
+      TEST_REQUEST_ID,
+    );
+
+    await handler.execute(url, init);
+
+    expect(inner.sentRequests).toHaveLength(2);
+    assertIsCancelRequest(inner.sentRequests[1], TEST_REQUEST_ID);
+  });
+
+  it("reportOrder sends cancel request on error", async () => {
+    inner.enqueueResponse(500);
+    inner.enqueueResponse(200);
+    const [url, init] = createOrderInit(
+      "/Order/reportOrder",
+      TEST_REQUEST_ID,
+    );
+
+    await handler.execute(url, init);
+
+    expect(inner.sentRequests).toHaveLength(2);
+    assertIsCancelRequest(inner.sentRequests[1], TEST_REQUEST_ID);
+  });
+
+  it("missing requestId does not send cancel request", async () => {
+    inner.enqueueResponse(500);
+
+    const response = await handler.execute(`${BASE}/Order/createOrder`, {
+      method: "POST",
+      headers: new Headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify({ productId: "aaaabbbb-cccc-dddd-eeee-ffffffffffff" }),
+    });
+
+    expect(response.status).toBe(500);
+    expect(inner.sentRequests).toHaveLength(1);
+  });
+
+  it("cancel request fails — original error still returned", async () => {
+    inner.enqueueResponse(500); // original 5xx
+    inner.enqueueError(new Error("Cancel failed")); // cancel blows up
+    const [url, init] = createOrderInit("/Order/createOrder", TEST_REQUEST_ID);
+
+    const response = await handler.execute(url, init);
+
+    expect(response.status).toBe(500);
+  });
+
+  it("copies auth and partner-id headers to cancel request", async () => {
+    inner.enqueueResponse(500);
+    inner.enqueueResponse(200);
+
+    const headers = new Headers({
+      "Content-Type": "application/json",
+      Authorization: "Bearer test-token",
+      [MissionControlHeaders.PartnerId]: "partner-123",
+    });
+
+    const response = await handler.execute(`${BASE}/Order/createOrder`, {
+      method: "POST",
+      headers,
+      body: createOrderBody(TEST_REQUEST_ID),
+    });
+
+    expect(response.status).toBe(500);
+    expect(inner.sentRequests).toHaveLength(2);
+
+    const cancelInit = inner.sentRequests[1].init;
+    const cancelHeaders = new Headers(cancelInit.headers);
+    expect(cancelHeaders.get("Authorization")).toBe("Bearer test-token");
+    expect(cancelHeaders.get(MissionControlHeaders.PartnerId)).toBe(
+      "partner-123",
+    );
+  });
+
+  it("cancel URI preserves path prefix", async () => {
+    inner.enqueueResponse(500);
+    inner.enqueueResponse(200);
+    const [url, init] = createOrderInit(
+      "/partnerApi/v2/Order/createOrder",
+      TEST_REQUEST_ID,
+    );
+
+    await handler.execute(url, init);
+
+    const cancelUrl = new URL(inner.sentRequests[1].url);
+    expect(cancelUrl.pathname).toBe("/partnerApi/v2/Order/cancelOrder");
+  });
+
+  it("cancel URI strips query string", async () => {
+    inner.enqueueResponse(500);
+    inner.enqueueResponse(200);
+
+    const headers = new Headers({ "Content-Type": "application/json" });
+    await handler.execute(
+      `${BASE}/Order/createOrder?foo=bar`,
+      {
+        method: "POST",
+        headers,
+        body: createOrderBody(TEST_REQUEST_ID),
+      },
+    );
+
+    const cancelUrl = new URL(inner.sentRequests[1].url);
+    expect(cancelUrl.search).toBe("");
+  });
+});

package/tests/clientBuilder.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "vitest";
+import { ClientBuilder } from "../src/client/clientBuilder";
+import { MissionControlEnvironment } from "../src/client/missionControlEnvironment";
+
+describe("ClientBuilder", () => {
+  describe("withDefaultPartnerId", () => {
+    it("throws when partnerId is an empty string", () => {
+      expect(() => new ClientBuilder().withDefaultPartnerId("")).toThrow(
+        "partnerId must not be null or whitespace.",
+      );
+    });
+
+    it("throws when partnerId is whitespace only", () => {
+      expect(() => new ClientBuilder().withDefaultPartnerId("   ")).toThrow(
+        "partnerId must not be null or whitespace.",
+      );
+    });
+
+    it("returns the builder instance for fluent chaining", () => {
+      const builder = new ClientBuilder();
+      expect(builder.withDefaultPartnerId("partner-123")).toBe(builder);
+    });
+  });
+
+  describe("withBaseUrl", () => {
+    it("throws when baseUrl is an empty string", () => {
+      expect(() => new ClientBuilder().withBaseUrl("")).toThrow(
+        "baseUrl must not be null or whitespace.",
+      );
+    });
+
+    it("throws when baseUrl is whitespace only", () => {
+      expect(() => new ClientBuilder().withBaseUrl("  ")).toThrow(
+        "baseUrl must not be null or whitespace.",
+      );
+    });
+
+    it("returns the builder instance for fluent chaining", () => {
+      const builder = new ClientBuilder();
+      expect(builder.withBaseUrl("http://localhost:5000")).toBe(builder);
+    });
+  });
+
+  describe("withScope", () => {
+    it("throws when scope is an empty string", () => {
+      expect(() => new ClientBuilder().withScope("")).toThrow(
+        "scope must not be null or whitespace.",
+      );
+    });
+
+    it("throws when scope is whitespace only", () => {
+      expect(() => new ClientBuilder().withScope("  ")).toThrow(
+        "scope must not be null or whitespace.",
+      );
+    });
+
+    it("returns the builder instance for fluent chaining", () => {
+      const builder = new ClientBuilder();
+      expect(builder.withScope("api://app-id/.default")).toBe(builder);
+    });
+  });
+
+  describe("forEnvironment", () => {
+    it("returns the builder instance for the Sandbox environment", () => {
+      const builder = new ClientBuilder();
+      expect(builder.forEnvironment(MissionControlEnvironment.Sandbox)).toBe(
+        builder,
+      );
+    });
+
+    it("returns the builder instance for the Production environment", () => {
+      const builder = new ClientBuilder();
+      expect(builder.forEnvironment(MissionControlEnvironment.Production)).toBe(
+        builder,
+      );
+    });
+
+    it("can be chained after withAzureAdClientCredentials", () => {
+      const builder = new ClientBuilder();
+      const result = builder
+        .withAzureAdClientCredentials("id", "secret")
+        .forEnvironment(MissionControlEnvironment.Sandbox);
+      expect(result).toBe(builder);
+    });
+  });
+
+  describe("withAzureAdClientCredentials", () => {
+    it("returns the builder instance for fluent chaining", () => {
+      const builder = new ClientBuilder();
+      expect(
+        builder.withAzureAdClientCredentials("client-id", "client-secret"),
+      ).toBe(builder);
+    });
+
+    it("returns the builder instance when a custom tenantId is provided", () => {
+      const builder = new ClientBuilder();
+      expect(
+        builder.withAzureAdClientCredentials(
+          "client-id",
+          "client-secret",
+          "tenant-id",
+        ),
+      ).toBe(builder);
+    });
+  });
+
+  describe("build", () => {
+    it("throws when no credentials have been configured", () => {
+      expect(() => new ClientBuilder().build()).toThrow(
+        "No credentials configured. Call withAzureAdClientCredentials() before calling build().",
+      );
+    });
+
+    it("throws even after forEnvironment is called without credentials", () => {
+      expect(() =>
+        new ClientBuilder()
+          .forEnvironment(MissionControlEnvironment.Sandbox)
+          .build(),
+      ).toThrow("No credentials configured.");
+    });
+
+    it("returns a client when credentials are configured", () => {
+      const client = new ClientBuilder()
+        .withAzureAdClientCredentials("fake-client-id", "fake-client-secret")
+        .build();
+      expect(client).toBeDefined();
+    });
+
+    it("returns a client for the Sandbox environment", () => {
+      const client = new ClientBuilder()
+        .forEnvironment(MissionControlEnvironment.Sandbox)
+        .withAzureAdClientCredentials("fake-client-id", "fake-client-secret")
+        .build();
+      expect(client).toBeDefined();
+    });
+
+    it("returns a client when a default partner ID is set", () => {
+      const client = new ClientBuilder()
+        .withDefaultPartnerId("partner-123")
+        .withAzureAdClientCredentials("fake-client-id", "fake-client-secret")
+        .build();
+      expect(client).toBeDefined();
+    });
+
+    it("returns a client when a custom base URL and scope override are set", () => {
+      const client = new ClientBuilder()
+        .withBaseUrl("http://localhost:5000")
+        .withScope("api://local-app-id/.default")
+        .withAzureAdClientCredentials("fake-client-id", "fake-client-secret")
+        .build();
+      expect(client).toBeDefined();
+    });
+  });
+});

package/tests/integration/fixture.ts

@@ -0,0 +1,50 @@
+import { ClientBuilder } from "../../src/client/clientBuilder";
+import type { Client } from "../../src/client/generated/client";
+
+// Credentials are read from process.env, which Vitest populates from .env.local
+// (placed next to vitest.integration.config.ts, never committed).
+// Copy .env.local.example to .env.local and fill in your values to run locally.
+// In CI, set the environment variables directly.
+const REQUIRED_KEYS = [
+  "MC_TENANT_ID",
+  "MC_CLIENT_ID",
+  "MC_CLIENT_SECRET",
+  "MC_PARTNER_ID",
+  "MC_BASE_URL",
+  "MC_SCOPE",
+] as const;
+
+const missingKeys = REQUIRED_KEYS.filter((key) => !process.env[key]);
+/**
+ * When non-empty, one or more required credentials are absent.
+ * Tests use this to skip gracefully rather than failing.
+ *
+ * Copy .env.local.example to .env.local and fill in your values to run integration tests locally.
+ * In CI, set the environment variables directly.
+ */
+export const missingCredentials: string =
+  missingKeys.length > 0
+    ? `Missing required credentials: ${missingKeys.join(", ")}. ` +
+      "Copy .env.local.example to .env.local and fill in your values."
+    : "";
+
+export const productId: string = process.env["MC_PRODUCT_ID"] ?? "";
+export const regionId: string = process.env["MC_REGION_ID"] ?? "";
+export const publisherId: string = process.env["MC_PUBLISHER_ID"] ?? "";
+
+/**
+ * Creates a fully configured integration-test client from the loaded credentials.
+ * Only call this inside a test that is guarded by {@link missingCredentials}.
+ */
+export function createClient(): Client {
+  return new ClientBuilder()
+    .withAzureAdClientCredentials(
+      process.env["MC_CLIENT_ID"]!,
+      process.env["MC_CLIENT_SECRET"]!,
+      process.env["MC_TENANT_ID"],
+    )
+    .withDefaultPartnerId(process.env["MC_PARTNER_ID"]!)
+    .withBaseUrl(process.env["MC_BASE_URL"]!)
+    .withScope(process.env["MC_SCOPE"]!)
+    .build();
+}

package/tests/integration/partner.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { createClient, missingCredentials } from "./fixture";
+
+describe.skipIf(!!missingCredentials)("Partner API (integration)", () => {
+  it("get returns a result", async () => {
+    const client = createClient();
+
+    const result = await client.partner.get();
+
+    expect(result).toBeDefined();
+    expect(result?.result).toBeDefined();
+  });
+
+  it("get returns an array of partners", async () => {
+    const client = createClient();
+
+    const result = await client.partner.get();
+
+    expect(Array.isArray(result?.result)).toBe(true);
+  });
+
+  it("get includes pagination metadata", async () => {
+    const client = createClient();
+
+    const result = await client.partner.get();
+
+    expect(result?.totalCount).toBeDefined();
+    expect(typeof result?.totalCount).toBe("number");
+    expect(result?.pageCount).toBeDefined();
+    expect(typeof result?.pageCount).toBe("number");
+  });
+});

package/tests/integration/priceList.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { createClient, missingCredentials } from "./fixture";
+
+describe.skipIf(!!missingCredentials)("PriceList API (integration)", () => {
+  it("get returns a price list for the first available product", async () => {
+    const client = createClient();
+
+    // Discover the first available product so no extra env var is needed.
+    const products = await client.product.get();
+    const product = products?.result?.[0];
+
+    if (!product) {
+      console.log(
+        "No products found in the configured environment — skipping.",
+      );
+      return;
+    }
+
+    const result = await client.priceList.get({
+      queryParameters: {
+        productId: product.id!,
+        publisherId: product.publisherId!,
+      },
+    });
+
+    expect(result).toBeDefined();
+  });
+});

package/tests/integration/product.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { createClient, missingCredentials } from "./fixture";
+
+describe.skipIf(!!missingCredentials)("Product API (integration)", () => {
+  it("get returns a result", async () => {
+    const client = createClient();
+
+    const result = await client.product.get();
+
+    expect(result).toBeDefined();
+    expect(result?.result).toBeDefined();
+  });
+
+  it("get returns an array of products", async () => {
+    const client = createClient();
+
+    const result = await client.product.get();
+
+    expect(Array.isArray(result?.result)).toBe(true);
+  });
+
+  it("get includes pagination metadata", async () => {
+    const client = createClient();
+
+    const result = await client.product.get();
+
+    expect(typeof result?.totalCount).toBe("number");
+    expect(typeof result?.pageCount).toBe("number");
+  });
+});

package/tests/integration/publisher.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { createClient, missingCredentials } from "./fixture";
+
+describe.skipIf(!!missingCredentials)("Publisher API (integration)", () => {
+  it("get returns a result", async () => {
+    const client = createClient();
+
+    const result = await client.publisher.get();
+
+    expect(result).toBeDefined();
+    expect(result?.result).toBeDefined();
+  });
+
+  it("get returns an array of publishers", async () => {
+    const client = createClient();
+
+    const result = await client.publisher.get();
+
+    expect(Array.isArray(result?.result)).toBe(true);
+  });
+
+  it("get includes pagination metadata", async () => {
+    const client = createClient();
+
+    const result = await client.publisher.get();
+
+    expect(typeof result?.totalCount).toBe("number");
+    expect(typeof result?.pageCount).toBe("number");
+  });
+});

package/tests/integration/region.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { createClient, missingCredentials, publisherId } from "./fixture";
+
+describe.skipIf(!!missingCredentials)("Region API (integration)", () => {
+  it("get returns a result", async () => {
+    const client = createClient();
+
+    const result = await client.region.get({
+      queryParameters: { publisherId },
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.result).toBeDefined();
+  });
+
+  it("get returns an array of regions", async () => {
+    const client = createClient();
+
+    const result = await client.region.get({
+      queryParameters: { publisherId },
+    });
+
+    expect(Array.isArray(result?.result)).toBe(true);
+  });
+
+  it("get includes pagination metadata", async () => {
+    const client = createClient();
+
+    const result = await client.region.get({
+      queryParameters: { publisherId },
+    });
+
+    expect(typeof result?.totalCount).toBe("number");
+    expect(typeof result?.pageCount).toBe("number");
+  });
+});

package/tests/integration/setup.ts

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+// Load .env.local from the project root (next to vitest.integration.config.ts).
+// This ensures credentials are available via process.env when running integration tests.
+// In CI, set the environment variables directly instead of using this file.
+const envFile = resolve(import.meta.dirname, "../../.env.local");
+if (existsSync(envFile)) {
+  process.loadEnvFile(envFile);
+}
+
+// Allow self-signed certificates when running against a local development server.
+// This is scoped to the integration test process and must never be used in production code.
+const baseUrl = process.env["MC_BASE_URL"] ?? "";
+if (
+  baseUrl.startsWith("http://localhost") ||
+  baseUrl.startsWith("https://localhost") ||
+  baseUrl.startsWith("http://127.0.0.1") ||
+  baseUrl.startsWith("https://127.0.0.1")
+) {
+  process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+}