kubernetes-fluent-client 3.0.3 → 4.0.0-rc-http2-watch

package/src/generate.test.ts

@@ -1,389 +1,399 @@
 import { beforeEach, describe, expect, jest, test } from "@jest/globals";
-import { generate } from "./generate";
+import { convertCRDtoTS, GenerateOptions, readOrFetchCrd } from "./generate";
 import fs from "fs";
+import path from "path";
+import { quicktype } from "quicktype-core";
+import { fetch } from "./fetch";
+import { loadAllYaml } from "@kubernetes/client-node";
+import { K8s } from "./fluent";
+import { CustomResourceDefinition } from "./upstream";
 
-const sampleYaml = `
-# non-crd should be ignored
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: test
-  namespace: default
-data:
-  any: bleh
----
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  name: movies.example.com
-spec:
-  group: example.com
-  names:
-    kind: Movie
-    plural: movies
-  scope: Namespaced
-  versions:
-    - name: v1
-      schema:
-        openAPIV3Schema:
-          type: object
-          description: Movie nerd
-          properties:
-            spec:
-              properties:
-                title:
-                  type: string
-                author:
-                  type: string
-              type: object
----
-# duplicate entries should not break things
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  name: movies.example.com
-spec:
-  group: example.com
-  names:
-    kind: Movie
-    plural: movies
-  scope: Namespaced
-  versions:
-    - name: v1
-      schema:
-        openAPIV3Schema:
-          type: object
-          description: Movie nerd
-          properties:
-            spec:
-              properties:
-                title:
-                  type: string
-                author:
-                  type: string
-              type: object
----            
-# should support multiple versions
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  name: books.example.com
-spec:
-  group: example.com
-  names:
-    kind: Book
-    plural: books
-  scope: Namespaced
-  versions:
-    - name: v1
-      schema:
-        openAPIV3Schema:
-          type: object
-          description: Book nerd
-          properties:
-            spec:
-              properties:
-                title:
-                  type: string
-                author:
-                  type: string
-              type: object
-    - name: v2
-      schema:
-        openAPIV3Schema:
-          type: object
-          description: Book nerd
-          properties:
-            spec:
-              properties:
-                author:
-                  type: string
-              type: object
-      served: true
-      storage: true
-`;
-
-jest.mock("./fetch", () => ({
-  fetch: jest.fn(),
+// Mock the file system
+jest.mock("fs", () => ({
+  ...(jest.requireActual("fs") as object), // Preserve the rest of the fs module
+  writeFileSync: jest.fn(), // Mock only writeFileSync
+  existsSync: jest.fn(),
+  readFileSync: jest.fn(),
 }));
-
+jest.mock("./fetch");
+jest.mock("quicktype-core", () => {
+  const actualQuicktypeCore = jest.requireActual<typeof import("quicktype-core")>("quicktype-core");
+  return {
+    quicktype: jest.fn(),
+    JSONSchemaInput: actualQuicktypeCore.JSONSchemaInput,
+    FetchingJSONSchemaStore: actualQuicktypeCore.FetchingJSONSchemaStore,
+    InputData: actualQuicktypeCore.InputData,
+  };
+});
+jest.mock("@kubernetes/client-node", () => {
+  const actualModule = jest.requireActual("@kubernetes/client-node");
+  return {
+    ...(typeof actualModule === "object" ? actualModule : {}),
+    loadAllYaml: jest.fn(), // Mock only the specific method
+  };
+});
 jest.mock("./fluent", () => ({
   K8s: jest.fn(),
 }));
+jest.mock("./generate", () => {
+  const actualGenerate = jest.requireActual("./generate");
+  return {
+    ...(typeof actualGenerate === "object" ? actualGenerate : {}),
+    resolveFilePath: jest.fn(), // Mock resolveFilePath globally
+    tryParseUrl: jest.fn(),
+  };
+});
+
+// Sample CRD content to use in tests
+const sampleCrd = {
+  apiVersion: "apiextensions.k8s.io/v1",
+  kind: "CustomResourceDefinition",
+  metadata: { name: "movies.example.com" },
+  spec: {
+    group: "example.com",
+    names: { kind: "Movie", plural: "movies" },
+    scope: "Namespaced",
+    versions: [
+      {
+        name: "v1",
+        served: true,
+        storage: true,
+        schema: {
+          openAPIV3Schema: {
+            type: "object",
+            description: "Movie nerd",
+            properties: {
+              spec: {
+                properties: {
+                  title: { type: "string" },
+                  author: { type: "string" },
+                },
+              },
+            },
+          },
+        },
+      },
+    ],
+  },
+};
+
+const expectedMovie = [
+  "/**",
+  " * Movie nerd",
+  " */",
+  "export interface Movie {",
+  "    spec?: any[] | boolean | number | number | null | SpecObject | string;",
+  "    [property: string]: any;",
+  "}",
+  "",
+  "export interface SpecObject {",
+  "    author?: string;",
+  "    title?: string;",
+  "    [property: string]: any;",
+  "}",
+  "",
+];
 
 describe("CRD Generate", () => {
-  const originalReadFileSync = fs.readFileSync;
-
-  jest.spyOn(fs, "existsSync").mockReturnValue(true);
-  jest.spyOn(fs, "readFileSync").mockImplementation((...args) => {
-    // Super janky hack due ot source-map-support calling readFileSync internally
-    if (args[0].toString().includes("test-crd.yaml")) {
-      return sampleYaml;
-    }
-    return originalReadFileSync(...args);
+  let logFn: jest.Mock; // Mock log function
+
+  beforeEach(() => {
+    jest.clearAllMocks(); // Reset all mocks before each test
+    logFn = jest.fn(); // Mock the log function with correct typing
+  });
+
+  test("convertCRDtoTS should generate the expected TypeScript file", async () => {
+    // Mock convertCRDtoTS to return a valid result structure
+    (quicktype as jest.MockedFunction<typeof quicktype>).mockResolvedValueOnce({
+      lines: expectedMovie,
+      annotations: [],
+    });
+
+    const options = {
+      source: "test-crd.yaml",
+      language: "ts",
+      logFn,
+      directory: "test-dir",
+      plain: false,
+      npmPackage: "kubernetes-fluent-client",
+    };
+
+    // Call convertCRDtoTS with sample CRD
+    const result = await convertCRDtoTS(sampleCrd, options);
+
+    // Extract the generated types from the result
+    const generatedTypes = result[0].results["movie-v1"];
+
+    // Assert that the generated types match the expected TypeScript code
+    expect(generatedTypes).toEqual(expectedMovie);
+
+    // Assert the file writing happens with the expected TypeScript content
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      path.join("test-dir", "movie-v1.ts"),
+      expectedMovie.join("\n"),
+    );
+
+    // Assert the logs contain expected log messages
+    expect(logFn).toHaveBeenCalledWith("- Generating example.com/v1 types for Movie");
   });
-  const mkdirSyncSpy = jest.spyOn(fs, "mkdirSync").mockReturnValue(undefined);
-  const writeFileSyncSpy = jest.spyOn(fs, "writeFileSync").mockReturnValue(undefined);
+});
+
+describe("readOrFetchCrd", () => {
+  let mockOpts: GenerateOptions;
 
   beforeEach(() => {
     jest.clearAllMocks();
+    mockOpts = {
+      source: "mock-file-path",
+      logFn: jest.fn(),
+    };
+
+    // Reapply mock for resolveFilePath inside beforeEach
+    const { resolveFilePath } = jest.requireMock("./generate") as { resolveFilePath: jest.Mock };
+    resolveFilePath.mockReturnValue("mock-file-path");
   });
 
-  test("converts CRD to TypeScript", async () => {
-    const options = { source: "test-crd.yaml", language: "ts", logFn: jest.fn() };
-
-    const actual = await generate(options);
-    const expectedMovie = [
-      "// This file is auto-generated by kubernetes-fluent-client, do not edit manually\n",
-      'import { GenericKind, RegisterKind } from "kubernetes-fluent-client";\n',
-      "/**",
-      " * Movie nerd",
-      " */",
-      "export class Movie extends GenericKind {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-      "RegisterKind(Movie, {",
-      '  group: "example.com",',
-      '  version: "v1",',
-      '  kind: "Movie",',
-      '  plural: "movies",',
-      "});",
-    ];
-    const expectedBookV1 = [
-      "// This file is auto-generated by kubernetes-fluent-client, do not edit manually\n",
-      'import { GenericKind, RegisterKind } from "kubernetes-fluent-client";\n',
-      "/**",
-      " * Book nerd",
-      " */",
-      "export class Book extends GenericKind {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-      "RegisterKind(Book, {",
-      '  group: "example.com",',
-      '  version: "v1",',
-      '  kind: "Book",',
-      '  plural: "books",',
-      "});",
-    ];
-    const expectedBookV2 = expectedBookV1
-      .filter(line => !line.includes("title?"))
-      .map(line => line.replace("v1", "v2"));
-
-    expect(actual["movie-v1"]).toEqual(expectedMovie);
-    expect(actual["book-v1"]).toEqual(expectedBookV1);
-    expect(actual["book-v2"]).toEqual(expectedBookV2);
+  test("should load CRD from a local file", async () => {
+    // Inside the test:
+    const absoluteFilePath = path.join(process.cwd(), "mock-file-path");
+
+    // Mock file system functions
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockReturnValue("mock file content");
+
+    // Mock loadAllYaml to return parsed CRD
+    const mockCrd = [{ kind: "CustomResourceDefinition" }] as CustomResourceDefinition[];
+    (loadAllYaml as jest.Mock).mockReturnValue(mockCrd);
+
+    // Call the function
+    const result = await readOrFetchCrd(mockOpts);
+
+    // Assert fs and loadAllYaml were called with correct args
+    expect(fs.existsSync).toHaveBeenCalledWith(absoluteFilePath);
+    expect(fs.readFileSync).toHaveBeenCalledWith(absoluteFilePath, "utf8");
+    expect(loadAllYaml).toHaveBeenCalledWith("mock file content");
+
+    // Assert the result matches the mocked CRD
+    expect(result).toEqual(mockCrd);
+
+    // Assert log function was called with correct message
+    expect(mockOpts.logFn).toHaveBeenCalledWith(
+      "Attempting to load mock-file-path as a local file",
+    );
   });
+});
+
+describe("readOrFetchCrd with URL", () => {
+  let mockOpts: GenerateOptions;
 
-  test("converts CRD to TypeScript with plain option", async () => {
-    const options = { source: "test-crd.yaml", language: "ts", plain: true, logFn: jest.fn() };
-
-    const actual = await generate(options);
-    const expectedMovie = [
-      "/**",
-      " * Movie nerd",
-      " */",
-      "export interface Movie {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-    ];
-    const expectedBookV1 = [
-      "/**",
-      " * Book nerd",
-      " */",
-      "export interface Book {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-    ];
-    const expectedBookV2 = expectedBookV1
-      .filter(line => !line.includes("title?"))
-      .map(line => line.replace("v1", "v2"));
-
-    expect(actual["movie-v1"]).toEqual(expectedMovie);
-    expect(actual["book-v1"]).toEqual(expectedBookV1);
-    expect(actual["book-v2"]).toEqual(expectedBookV2);
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockOpts = {
+      source: "http://example.com/mock-crd",
+      logFn: jest.fn(),
+    };
+
+    // Mock resolveFilePath to simulate URL logic
+    const { resolveFilePath } = jest.requireMock("./generate") as {
+      resolveFilePath: jest.Mock;
+    };
+    resolveFilePath.mockReturnValue("mock-file-path");
+
+    // Ensure fs.existsSync returns false for URL tests to skip file logic
+    (fs.existsSync as jest.Mock).mockReturnValue(false);
   });
 
-  test("converts CRD to TypeScript with other options", async () => {
-    const options = {
-      source: "test-crd.yaml",
-      npmPackage: "test-package",
+  test("should fetch CRD from a URL and parse YAML", async () => {
+    const { tryParseUrl } = jest.requireMock("./generate") as { tryParseUrl: jest.Mock };
+    tryParseUrl.mockReturnValue(new URL("http://example.com/mock-crd"));
+
+    // Mock fetch to return a valid response
+    (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValue({
+      ok: true,
+      data: "mock fetched data",
+      status: 0,
+      statusText: "",
+    });
+
+    // Mock loadAllYaml to return parsed CRD
+    const mockCrd = [{ kind: "CustomResourceDefinition" }] as CustomResourceDefinition[];
+    (loadAllYaml as jest.Mock).mockReturnValue(mockCrd);
+
+    // Call the function
+    const result = await readOrFetchCrd(mockOpts);
+
+    // Assert fetch was called with correct URL
+    expect(fetch).toHaveBeenCalledWith("http://example.com/mock-crd");
+
+    // Assert loadAllYaml was called with fetched data
+    expect(loadAllYaml).toHaveBeenCalledWith("mock fetched data");
+
+    // Assert the result matches the mocked CRD
+    expect(result).toEqual(mockCrd);
+
+    // Assert log function was called with correct message
+    expect(mockOpts.logFn).toHaveBeenCalledWith(
+      "Attempting to load http://example.com/mock-crd as a URL",
+    );
+  });
+});
+
+describe("readOrFetchCrd from Kubernetes cluster", () => {
+  let mockOpts: GenerateOptions;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockOpts = {
+      source: "my-crd",
       logFn: jest.fn(),
     };
 
-    const actual = await generate(options);
-    const expectedMovie = [
-      "// This file is auto-generated by test-package, do not edit manually\n",
-      'import { GenericKind, RegisterKind } from "test-package";\n',
-      "/**",
-      " * Movie nerd",
-      " */",
-      "export class Movie extends GenericKind {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-      "RegisterKind(Movie, {",
-      '  group: "example.com",',
-      '  version: "v1",',
-      '  kind: "Movie",',
-      '  plural: "movies",',
-      "});",
-    ];
-    const expectedBookV1 = [
-      "// This file is auto-generated by test-package, do not edit manually\n",
-      'import { GenericKind, RegisterKind } from "test-package";\n',
-      "/**",
-      " * Book nerd",
-      " */",
-      "export class Book extends GenericKind {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-      "RegisterKind(Book, {",
-      '  group: "example.com",',
-      '  version: "v1",',
-      '  kind: "Book",',
-      '  plural: "books",',
-      "});",
-    ];
-    const expectedBookV2 = expectedBookV1
-      .filter(line => !line.includes("title?"))
-      .map(line => line.replace("v1", "v2"));
-
-    expect(actual["movie-v1"]).toEqual(expectedMovie);
-    expect(actual["book-v1"]).toEqual(expectedBookV1);
-    expect(actual["book-v2"]).toEqual(expectedBookV2);
+    // Mock resolveFilePath and tryParseUrl to return null or invalid results
+    const { resolveFilePath, tryParseUrl } = jest.requireMock("./generate") as {
+      resolveFilePath: jest.Mock;
+      tryParseUrl: jest.Mock;
+    };
+    resolveFilePath.mockReturnValue("mock-file-path");
+    tryParseUrl.mockReturnValue(null);
+
+    // Ensure fs.existsSync returns false to force fallback to Kubernetes
+    (fs.existsSync as jest.Mock).mockReturnValue(false);
   });
 
-  test("converts CRD to TypeScript and writes to the given directory", async () => {
-    const options = {
-      source: "test-crd.yaml",
-      directory: "test",
+  test("should load CRD from Kubernetes cluster", async () => {
+    // Mock K8s to return a mocked CRD from the Kubernetes cluster
+    const mockCrd = { kind: "CustomResourceDefinition" } as CustomResourceDefinition;
+    const mockK8sGet = jest
+      .fn<() => Promise<CustomResourceDefinition>>()
+      .mockResolvedValue(mockCrd);
+    (K8s as jest.Mock).mockReturnValue({ Get: mockK8sGet });
+
+    // Call the function
+    const result = await readOrFetchCrd(mockOpts);
+
+    // Assert K8s.Get was called with the correct source
+    expect(K8s).toHaveBeenCalledWith(CustomResourceDefinition);
+    expect(mockK8sGet).toHaveBeenCalledWith("my-crd");
+
+    // Assert the result matches the mocked CRD
+    expect(result).toEqual([mockCrd]);
+
+    // Assert log function was called with correct message
+    expect(mockOpts.logFn).toHaveBeenCalledWith(
+      "Attempting to read my-crd from the Kubernetes cluster",
+    );
+  });
+
+  test("should log an error if Kubernetes cluster read fails", async () => {
+    // Mock K8s to throw an error
+    const mockError = new Error("Kubernetes API error");
+    const mockK8sGet = jest.fn<() => Promise<never>>().mockRejectedValue(mockError);
+    (K8s as jest.Mock).mockReturnValue({ Get: mockK8sGet });
+
+    // Call the function and assert that it throws an error
+    await expect(readOrFetchCrd(mockOpts)).rejects.toThrowError(
+      `Failed to read my-crd as a file, URL, or Kubernetes CRD`,
+    );
+
+    // Assert log function was called with error message
+    expect(mockOpts.logFn).toHaveBeenCalledWith("Error loading CRD: Kubernetes API error");
+
+    // Assert K8s.Get was called with the correct source
+    expect(K8s).toHaveBeenCalledWith(CustomResourceDefinition);
+    expect(mockK8sGet).toHaveBeenCalledWith("my-crd");
+  });
+});
+
+describe("readOrFetchCrd error handling", () => {
+  let mockOpts: GenerateOptions;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockOpts = {
+      source: "mock-source",
       logFn: jest.fn(),
     };
+  });
+
+  test("should throw an error if file reading fails", async () => {
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockImplementation(() => {
+      throw new Error("File read error");
+    });
+
+    await expect(readOrFetchCrd(mockOpts)).rejects.toThrowError(
+      "Failed to read mock-source as a file, URL, or Kubernetes CRD",
+    );
 
-    await generate(options);
-    const expectedMovie = [
-      "// This file is auto-generated by kubernetes-fluent-client, do not edit manually\n",
-      'import { GenericKind, RegisterKind } from "kubernetes-fluent-client";\n',
-      "/**",
-      " * Movie nerd",
-      " */",
-      "export class Movie extends GenericKind {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-      "RegisterKind(Movie, {",
-      '  group: "example.com",',
-      '  version: "v1",',
-      '  kind: "Movie",',
-      '  plural: "movies",',
-      "});",
-    ];
-    const expectedBookV1 = [
-      "// This file is auto-generated by kubernetes-fluent-client, do not edit manually\n",
-      'import { GenericKind, RegisterKind } from "kubernetes-fluent-client";\n',
-      "/**",
-      " * Book nerd",
-      " */",
-      "export class Book extends GenericKind {",
-      "    spec?: Spec;",
-      "}",
-      "",
-      "export interface Spec {",
-      "    author?: string;",
-      "    title?:  string;",
-      "}",
-      "",
-      "RegisterKind(Book, {",
-      '  group: "example.com",',
-      '  version: "v1",',
-      '  kind: "Book",',
-      '  plural: "books",',
-      "});",
-    ];
-    const expectedBookV2 = expectedBookV1
-      .filter(line => !line.includes("title?"))
-      .map(line => line.replace("v1", "v2"));
-
-    expect(mkdirSyncSpy).toHaveBeenCalledWith("test", { recursive: true });
-    expect(writeFileSyncSpy).toHaveBeenCalledWith("test/movie-v1.ts", expectedMovie.join("\n"));
-    expect(writeFileSyncSpy).toHaveBeenCalledWith("test/book-v1.ts", expectedBookV1.join("\n"));
-    expect(writeFileSyncSpy).toHaveBeenCalledWith("test/book-v2.ts", expectedBookV2.join("\n"));
+    expect(mockOpts.logFn).toHaveBeenCalledWith("Error loading CRD: File read error");
   });
+});
+
+describe("convertCRDtoTS with invalid CRD", () => {
+  test("should skip CRD with no versions", async () => {
+    const invalidCrd = {
+      ...sampleCrd,
+      spec: {
+        ...sampleCrd.spec,
+        versions: [], // CRD with no versions
+      },
+    };
+
+    const options = {
+      source: "mock-source",
+      language: "ts",
+      logFn: jest.fn(), // Ensure the mock log function is set
+      directory: "test-dir",
+      plain: false,
+      npmPackage: "kubernetes-fluent-client",
+    };
+
+    const result = await convertCRDtoTS(invalidCrd, options);
+
+    // Assert that result is empty due to invalid CRD
+    expect(result).toEqual([]);
+
+    // Assert the log function is called with the correct message
+    expect(options.logFn).toHaveBeenCalledWith(
+      "Skipping movies.example.com, it does not appear to be a CRD",
+    );
+  });
+
+  test("should handle schema with no OpenAPI schema", async () => {
+    // Modify the sampleCrd to simulate the invalid CRD
+    const invalidCrd = {
+      ...sampleCrd,
+      spec: {
+        ...sampleCrd.spec,
+        versions: [
+          {
+            name: "v1",
+            served: true,
+            storage: true,
+            schema: undefined, // No OpenAPI schema
+          },
+        ],
+      },
+    };
+
+    const options = {
+      source: "mock-source",
+      language: "ts",
+      logFn: jest.fn(), // Mock log function
+      directory: "test-dir",
+      plain: false,
+      npmPackage: "kubernetes-fluent-client",
+    };
+
+    // Call the convertCRDtoTS function with the invalid CRD
+    const result = await convertCRDtoTS(invalidCrd, options);
+
+    // Assert that result is empty due to invalid schema
+    expect(result).toEqual([]);
 
-  test("converts CRD to Go", async () => {
-    const options = { source: "test-crd.yaml", language: "go", logFn: jest.fn() };
-
-    const actual = await generate(options);
-    const expectedMovie = [
-      "// Movie nerd",
-      "type Movie struct {",
-      '\tSpec *Spec `json:"spec,omitempty"`',
-      "}",
-      "",
-      "type Spec struct {",
-      '\tAuthor *string `json:"author,omitempty"`',
-      '\tTitle  *string `json:"title,omitempty"`',
-      "}",
-      "",
-    ];
-    const expectedBookV1 = [
-      "// Book nerd",
-      "type Book struct {",
-      '\tSpec *Spec `json:"spec,omitempty"`',
-      "}",
-      "",
-      "type Spec struct {",
-      '\tAuthor *string `json:"author,omitempty"`',
-      '\tTitle  *string `json:"title,omitempty"`',
-      "}",
-      "",
-    ];
-    const expectedBookV2 = expectedBookV1
-      .filter(line => !line.includes("Title"))
-      .map(line => line.replace("v1", "v2"));
-
-    expect(actual["movie-v1"]).toEqual(expectedMovie);
-    expect(actual["book-v1"]).toEqual(expectedBookV1);
-    expect(actual["book-v2"]).toEqual(expectedBookV2);
+    // Assert that the log function was called with the appropriate message
+    expect(options.logFn).toHaveBeenCalledWith(
+      "Skipping movies.example.com, it does not appear to have a valid schema",
+    );
   });
 });