@leonxin/meetgames 0.1.8 → 0.1.11

package/tests/mcp.e2e.ts

@@ -0,0 +1,217 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(here, "..");
+const androidFixtureRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
+const remoteConfigFixture = path.join(pkgRoot, "fixtures", "meetsdk-remote-config.mock.json");
+const mcpEntry = path.join(pkgRoot, "dist", "mcp-entry.js");
+
+function copyAndroidProjectToTemp(): string {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meet-mcp-e2e-"));
+  const projectRoot = path.join(tmpRoot, "android-project");
+  fs.cpSync(androidFixtureRoot, projectRoot, { recursive: true });
+  return projectRoot;
+}
+
+function createMockFetchPreload(): { path: string; cleanup: () => void } {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meet-mcp-fetch-"));
+  const preloadPath = path.join(tmpRoot, "mock-fetch.mjs");
+  const remoteConfigText = fs.readFileSync(remoteConfigFixture, "utf8");
+  const preload = `
+const remoteConfigText = ${JSON.stringify(remoteConfigText)};
+const sdkHomeVersionResponse = {
+  code: 200,
+  data: {
+    result: {
+      android: { ver: "1.6.1.3", date: "2026-05-25" },
+      ios: { ver: "1.6.0.5", date: "2026-06-09" }
+    }
+  }
+};
+
+function jsonResponse(body) {
+  return new Response(JSON.stringify(body, null, 2), {
+    status: 200,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+
+globalThis.fetch = async (input) => {
+  const url = new URL(typeof input === "string" ? input : input.url);
+  if (url.pathname === "/sdk/home/version") {
+    return jsonResponse(sdkHomeVersionResponse);
+  }
+  if (url.pathname === "/console/openSDK/downloadSDKConfig") {
+    return new Response(remoteConfigText, {
+      status: 200,
+      headers: { "content-type": "application/json; charset=utf-8" }
+    });
+  }
+  if (url.pathname === "/firebase/google-services.json" || url.pathname.endsWith(".json")) {
+    return jsonResponse({ project_info: { project_id: "mock-project" }, client: [] });
+  }
+  return new Response("Unhandled mock route: " + url.pathname, { status: 404 });
+};
+`;
+  fs.writeFileSync(preloadPath, preload);
+  return {
+    path: preloadPath,
+    cleanup: () => fs.rmSync(tmpRoot, { recursive: true, force: true }),
+  };
+}
+
+function childEnv(baseUrl: string, preloadPath: string): Record<string, string> {
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter((entry): entry is [string, string] => typeof entry[1] === "string")
+  );
+  const preloadOption = `--import=${pathToFileURL(preloadPath).href}`;
+  return {
+    ...env,
+    NODE_OPTIONS: [env.NODE_OPTIONS, preloadOption].filter(Boolean).join(" "),
+    TOPSDK_API_BASE_URL: baseUrl,
+    MEETGAMES_SDK_HOME_API_BASE_URL: baseUrl,
+  };
+}
+
+async function connectMcpClient(baseUrl: string, preloadPath: string): Promise<Client> {
+  const client = new Client({ name: "meet-sdk-tool-mcp-e2e", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [mcpEntry],
+    cwd: pkgRoot,
+    env: childEnv(baseUrl, preloadPath),
+    stderr: "pipe",
+  });
+  await client.connect(transport);
+  return client;
+}
+
+function structured(result: Awaited<ReturnType<Client["callTool"]>>): Record<string, unknown> {
+  expect("structuredContent" in result).toBe(true);
+  const data = "structuredContent" in result ? result.structuredContent : undefined;
+  expect(data).toBeTruthy();
+  return data as Record<string, unknown>;
+}
+
+describe("meetgames MCP stdio server", () => {
+  const mockBaseUrl = "https://meet-sdk-tool-mcp-e2e.invalid";
+  let mockFetchPreload: ReturnType<typeof createMockFetchPreload>;
+  let client: Client;
+  const tmpRoots: string[] = [];
+
+  beforeEach(async () => {
+    expect(fs.existsSync(mcpEntry)).toBe(true);
+    mockFetchPreload = createMockFetchPreload();
+    client = await connectMcpClient(mockBaseUrl, mockFetchPreload.path);
+  });
+
+  afterEach(async () => {
+    await client?.close().catch(() => undefined);
+    mockFetchPreload?.cleanup();
+    for (const root of tmpRoots.splice(0)) {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("lists all public meetgames tools", async () => {
+    const { tools } = await client.listTools();
+    expect(tools.map((tool) => tool.name).sort()).toEqual([
+      "meetgames_doctor",
+      "meetgames_fetch_config",
+      "meetgames_integrate_apply",
+      "meetgames_integrate_dry_run",
+      "meetgames_setup",
+    ]);
+  });
+
+  it("runs doctor and integrate dry-run through stdio", async () => {
+    const projectRoot = copyAndroidProjectToTemp();
+    tmpRoots.push(path.dirname(projectRoot));
+
+    const doctor = structured(
+      await client.callTool({
+        name: "meetgames_doctor",
+        arguments: { projectRoot, appTarget: "app" },
+      })
+    );
+    expect(doctor.projectRoot).toBe(projectRoot);
+    expect(doctor.platform).toBe("android");
+    expect((doctor.android as { moduleName?: string }).moduleName).toBe(":app");
+
+    const dryRun = structured(
+      await client.callTool({
+        name: "meetgames_integrate_dry_run",
+        arguments: { projectRoot, appTarget: "app" },
+      })
+    );
+    expect(dryRun.dryRun).toBe(true);
+    expect(dryRun.hasErrors).toBe(false);
+    expect(String(dryRun.patch)).toContain("TOPSDK AUTO");
+    expect(fs.existsSync(path.join(projectRoot, "vendor", "meet-integrate", "sample.txt"))).toBe(false);
+  });
+
+  it("runs fetch-config and setup dry-run through stdio", async () => {
+    const projectRoot = copyAndroidProjectToTemp();
+    tmpRoots.push(path.dirname(projectRoot));
+    fs.rmSync(path.join(projectRoot, "meetsdk-remote-config.json"), { force: true });
+
+    const fetched = structured(
+      await client.callTool({
+        name: "meetgames_fetch_config",
+        arguments: {
+          projectRoot,
+          env: "test",
+          appId: "mock-topsdk-app-id",
+          appSecret: "mock-secret",
+          channelType: "GOOGLE",
+        },
+      })
+    );
+    expect(fetched.env).toBe("test");
+    expect(String(fetched.requestUrl)).toContain("/console/openSDK/downloadSDKConfig");
+    expect(fs.readFileSync(path.join(projectRoot, "meetsdk-remote-config.json"), "utf8")).toBe(
+      fs.readFileSync(remoteConfigFixture, "utf8")
+    );
+
+    const setup = structured(
+      await client.callTool({
+        name: "meetgames_setup",
+        arguments: {
+          projectRoot,
+          env: "test",
+          appId: "mock-topsdk-app-id",
+          appSecret: "mock-secret",
+          channelType: "GOOGLE",
+          appTarget: "app",
+          dryRun: true,
+        },
+      })
+    );
+    expect((setup.fetch as { env?: string }).env).toBe("test");
+    expect((setup.integrate as { dryRun?: boolean; hasErrors?: boolean }).dryRun).toBe(true);
+    expect((setup.integrate as { dryRun?: boolean; hasErrors?: boolean }).hasErrors).toBe(false);
+  });
+
+  it("runs integrate apply through stdio against a temporary fixture", async () => {
+    const projectRoot = copyAndroidProjectToTemp();
+    tmpRoots.push(path.dirname(projectRoot));
+
+    const applied = structured(
+      await client.callTool({
+        name: "meetgames_integrate_apply",
+        arguments: { projectRoot, appTarget: "app" },
+      })
+    );
+    expect(applied.dryRun).toBe(false);
+    expect((applied.report as { errors?: string[] }).errors).toEqual([]);
+    expect(applied.hasErrors).toBe(false);
+    expect(fs.existsSync(path.join(projectRoot, "vendor", "meet-integrate", "sample.txt"))).toBe(true);
+    expect(fs.readFileSync(path.join(projectRoot, "app", "build.gradle"), "utf8")).toContain("TOPSDK AUTO");
+  });
+});

package/tests/mcp.service.test.ts

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { meetgamesDoctor, meetgamesIntegrate } from "../src/mcp/service.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(here, "..");
+const androidLatestRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
+
+function stubSdkHomeVersion(): void {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () =>
+        JSON.stringify({
+          code: 200,
+          data: {
+            result: {
+              android: { ver: "1.6.1.3", date: "2026-05-25" },
+              ios: { ver: "1.6.0.5", date: "2026-06-09" },
+            },
+          },
+        }),
+    })) as unknown as typeof fetch
+  );
+}
+
+describe("mcp service", () => {
+  beforeEach(() => {
+    stubSdkHomeVersion();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("doctor returns android detection summary", () => {
+    const summary = meetgamesDoctor({ projectRoot: androidLatestRoot, appTarget: "app" });
+    expect(summary.projectRoot).toBe(androidLatestRoot);
+    expect((summary.android as { ok: boolean }).ok).toBe(true);
+    expect((summary.android as { moduleName: string }).moduleName).toBe(":app");
+  });
+
+  it("integrate dry-run returns patch and no errors", async () => {
+    const result = await meetgamesIntegrate({ projectRoot: androidLatestRoot, dryRun: true });
+    expect(result.dryRun).toBe(true);
+    expect(result.patch.length).toBeGreaterThan(0);
+    const report = result.report as { errors: string[] };
+    expect(report.errors).toEqual([]);
+  });
+});