@frictionless-ts/dataset 1.0.1

package/build/plugins/github/package/save.spec.js

@@ -0,0 +1,566 @@
+import { relative } from "node:path";
+import { loadPackageDescriptor } from "@frictionless-ts/metadata";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { savePackageToGithub } from "./save.js";
+describe("savePackageToGithub", () => {
+    const getFixturePath = (name) => relative(process.cwd(), `${import.meta.dirname}/fixtures/${name}`);
+    const mockPackage = {
+        name: "test-package",
+        title: "Test Package",
+        description: "A test package",
+        version: "1.0.0",
+        resources: [
+            {
+                name: "test-resource",
+                path: getFixturePath("data.csv"),
+                format: "csv",
+                bytes: 100,
+            },
+        ],
+    };
+    const mockOptions = {
+        apiKey: "test-api-key",
+        repo: "test-repo",
+    };
+    const originalFetch = globalThis.fetch;
+    let fetchMock;
+    beforeEach(() => {
+        fetchMock = vi.fn();
+        // @ts-ignore
+        globalThis.fetch = fetchMock;
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.resetAllMocks();
+    });
+    it.skip("should save a package", async () => {
+        const dataPackage = await loadPackageDescriptor("core/package/fixtures/package.json");
+        const result = await savePackageToGithub(dataPackage, {
+            apiKey: "<key>",
+            repo: "test",
+        });
+        console.log(result);
+        expect(true).toBeDefined();
+    });
+    it("creates a repository in GitHub with correct API calls", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "data.csv",
+                    path: "data.csv",
+                    sha: "abc123",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "datapackage.json",
+                    path: "datapackage.json",
+                    sha: "def456",
+                },
+            }),
+        });
+        const result = await savePackageToGithub(mockPackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        const repoCreateCall = fetchMock.mock.calls[0];
+        expect(repoCreateCall).toBeDefined();
+        if (!repoCreateCall)
+            return;
+        expect(repoCreateCall[0]).toEqual("https://api.github.com/user/repos");
+        expect(repoCreateCall[1]).toMatchObject({
+            method: "POST",
+            headers: {
+                Authorization: "Bearer test-api-key",
+                "Content-Type": "application/json",
+            },
+        });
+        const repoPayload = JSON.parse(repoCreateCall[1].body);
+        expect(repoPayload.name).toEqual("test-repo");
+        expect(repoPayload.auto_init).toEqual(true);
+        expect(result).toEqual({
+            path: "https://raw.githubusercontent.com/test-user/test-repo/refs/heads/main/dataPackage.json",
+            repoUrl: "https://github.com/test-user/test-repo",
+        });
+    });
+    it("creates a repository in an organization when org is specified", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-org/test-repo",
+                owner: {
+                    login: "test-org",
+                    id: 2,
+                    avatar_url: "https://avatars.githubusercontent.com/u/2",
+                    html_url: "https://github.com/test-org",
+                    type: "Organization",
+                },
+                html_url: "https://github.com/test-org/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-org/test-repo.git",
+                ssh_url: "git@github.com:test-org/test-repo.git",
+                clone_url: "https://github.com/test-org/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "file",
+                    path: "file",
+                    sha: "abc123",
+                },
+            }),
+        });
+        await savePackageToGithub(mockPackage, {
+            ...mockOptions,
+            org: "test-org",
+        });
+        const repoCreateCall = fetchMock.mock.calls[0];
+        expect(repoCreateCall).toBeDefined();
+        if (!repoCreateCall)
+            return;
+        expect(repoCreateCall[0]).toEqual("https://api.github.com/orgs/test-org/repos");
+    });
+    it("uploads resource files with base64 encoding", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "data.csv",
+                    path: "data.csv",
+                    sha: "abc123",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "datapackage.json",
+                    path: "datapackage.json",
+                    sha: "def456",
+                },
+            }),
+        });
+        await savePackageToGithub(mockPackage, mockOptions);
+        const fileUploadCall = fetchMock.mock.calls[1];
+        expect(fileUploadCall).toBeDefined();
+        if (!fileUploadCall)
+            return;
+        expect(fileUploadCall[0]).toEqual("https://api.github.com/repos/test-user/test-repo/contents/data.csv");
+        expect(fileUploadCall[1]).toMatchObject({
+            method: "PUT",
+            headers: {
+                Authorization: "Bearer test-api-key",
+                "Content-Type": "application/json",
+            },
+        });
+        const filePayload = JSON.parse(fileUploadCall[1].body);
+        expect(filePayload.path).toEqual("data.csv");
+        expect(filePayload.message).toEqual('Added file "data.csv"');
+        expect(filePayload.content).toBeDefined();
+        expect(typeof filePayload.content).toEqual("string");
+    });
+    it("uploads datapackage.json metadata file", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "data.csv",
+                    path: "data.csv",
+                    sha: "abc123",
+                },
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "datapackage.json",
+                    path: "datapackage.json",
+                    sha: "def456",
+                },
+            }),
+        });
+        await savePackageToGithub(mockPackage, mockOptions);
+        const datapackageUploadCall = fetchMock.mock.calls[2];
+        expect(datapackageUploadCall).toBeDefined();
+        if (!datapackageUploadCall)
+            return;
+        expect(datapackageUploadCall[0]).toEqual("https://api.github.com/repos/test-user/test-repo/contents/datapackage.json");
+        const datapackagePayload = JSON.parse(datapackageUploadCall[1].body);
+        expect(datapackagePayload.path).toEqual("datapackage.json");
+        expect(datapackagePayload.message).toEqual('Added file "datapackage.json"');
+        expect(datapackagePayload.content).toBeDefined();
+        expect(typeof datapackagePayload.content).toEqual("string");
+    });
+    it("passes API key as Bearer token in Authorization header", async () => {
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        await savePackageToGithub(mockPackage, {
+            ...mockOptions,
+            apiKey: "custom-api-key",
+        });
+        const firstCall = fetchMock.mock.calls[0];
+        expect(firstCall).toBeDefined();
+        if (!firstCall)
+            return;
+        const headers = firstCall[1].headers;
+        expect(headers.Authorization).toEqual("Bearer custom-api-key");
+    });
+    it("handles API errors from repository creation", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: false,
+            status: 400,
+            statusText: "Bad Request",
+            text: () => Promise.resolve("Repository name already exists"),
+        });
+        await expect(savePackageToGithub(mockPackage, mockOptions)).rejects.toThrow("Github API error: 400 Bad Request");
+    });
+    it("handles API errors from file upload", async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            statusText: "Internal Server Error",
+            text: () => Promise.resolve("Failed to upload file"),
+        });
+        await expect(savePackageToGithub(mockPackage, mockOptions)).rejects.toThrow("Github API error: 500 Internal Server Error");
+    });
+    it("handles packages with multiple resources", async () => {
+        const multiResourcePackage = {
+            ...mockPackage,
+            resources: [
+                {
+                    name: "resource-1",
+                    path: getFixturePath("data.csv"),
+                    format: "csv",
+                },
+                {
+                    name: "resource-2",
+                    path: getFixturePath("data.csv"),
+                    format: "json",
+                },
+            ],
+        };
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        await savePackageToGithub(multiResourcePackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(4);
+        const secondFileUploadCall = fetchMock.mock.calls[2];
+        expect(secondFileUploadCall).toBeDefined();
+        if (!secondFileUploadCall)
+            return;
+        expect(secondFileUploadCall[0]).toContain("/contents/");
+    });
+    it("handles packages with no resources", async () => {
+        const emptyPackage = {
+            ...mockPackage,
+            resources: [],
+        };
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "datapackage.json",
+                    path: "datapackage.json",
+                    sha: "def456",
+                },
+            }),
+        });
+        const result = await savePackageToGithub(emptyPackage, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(result.repoUrl).toEqual("https://github.com/test-user/test-repo");
+    });
+    it("skips resources without path", async () => {
+        const packageWithoutPath = {
+            ...mockPackage,
+            resources: [
+                {
+                    name: "resource-without-path",
+                    format: "csv",
+                },
+            ],
+        };
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                id: 12345,
+                name: "test-repo",
+                full_name: "test-user/test-repo",
+                owner: {
+                    login: "test-user",
+                    id: 1,
+                    avatar_url: "https://avatars.githubusercontent.com/u/1",
+                    html_url: "https://github.com/test-user",
+                    type: "User",
+                },
+                html_url: "https://github.com/test-user/test-repo",
+                description: null,
+                created_at: "2024-01-01T00:00:00Z",
+                updated_at: "2024-01-01T00:00:00Z",
+                homepage: null,
+                size: 0,
+                stargazers_count: 0,
+                watchers_count: 0,
+                language: null,
+                license: null,
+                default_branch: "main",
+                topics: [],
+                private: false,
+                archived: false,
+                git_url: "git://github.com/test-user/test-repo.git",
+                ssh_url: "git@github.com:test-user/test-repo.git",
+                clone_url: "https://github.com/test-user/test-repo.git",
+            }),
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                content: {
+                    name: "datapackage.json",
+                    path: "datapackage.json",
+                    sha: "def456",
+                },
+            }),
+        });
+        await savePackageToGithub(packageWithoutPath, mockOptions);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../../../plugins/github/package/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative } from \"node:path\"\nimport type { Package } from \"@frictionless-ts/metadata\"\nimport { loadPackageDescriptor } from \"@frictionless-ts/metadata\"\nimport { afterEach, beforeEach, describe, expect, it, vi } from \"vitest\"\nimport { savePackageToGithub } from \"./save.ts\"\n\ndescribe(\"savePackageToGithub\", () => {\n  const getFixturePath = (name: string) =>\n    relative(process.cwd(), `${import.meta.dirname}/fixtures/${name}`)\n\n  const mockPackage: Package = {\n    name: \"test-package\",\n    title: \"Test Package\",\n    description: \"A test package\",\n    version: \"1.0.0\",\n    resources: [\n      {\n        name: \"test-resource\",\n        path: getFixturePath(\"data.csv\"),\n        format: \"csv\",\n        bytes: 100,\n      },\n    ],\n  }\n\n  const mockOptions = {\n    apiKey: \"test-api-key\",\n    repo: \"test-repo\",\n  }\n\n  const originalFetch = globalThis.fetch\n  let fetchMock: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    fetchMock = vi.fn()\n    // @ts-ignore\n    globalThis.fetch = fetchMock\n  })\n\n  afterEach(() => {\n    globalThis.fetch = originalFetch\n    vi.resetAllMocks()\n  })\n\n  it.skip(\"should save a package\", async () => {\n    const dataPackage = await loadPackageDescriptor(\n      \"core/package/fixtures/package.json\",\n    )\n\n    const result = await savePackageToGithub(dataPackage, {\n      apiKey: \"<key>\",\n      repo: \"test\",\n    })\n\n    console.log(result)\n\n    expect(true).toBeDefined()\n  })\n\n  it(\"creates a repository in GitHub with correct API calls\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"data.csv\",\n            path: \"data.csv\",\n            sha: \"abc123\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"datapackage.json\",\n            path: \"datapackage.json\",\n            sha: \"def456\",\n          },\n        }),\n    })\n\n    const result = await savePackageToGithub(mockPackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(3)\n\n    const repoCreateCall = fetchMock.mock.calls[0]\n    expect(repoCreateCall).toBeDefined()\n    if (!repoCreateCall) return\n\n    expect(repoCreateCall[0]).toEqual(\"https://api.github.com/user/repos\")\n    expect(repoCreateCall[1]).toMatchObject({\n      method: \"POST\",\n      headers: {\n        Authorization: \"Bearer test-api-key\",\n        \"Content-Type\": \"application/json\",\n      },\n    })\n\n    const repoPayload = JSON.parse(repoCreateCall[1].body)\n    expect(repoPayload.name).toEqual(\"test-repo\")\n    expect(repoPayload.auto_init).toEqual(true)\n\n    expect(result).toEqual({\n      path: \"https://raw.githubusercontent.com/test-user/test-repo/refs/heads/main/dataPackage.json\",\n      repoUrl: \"https://github.com/test-user/test-repo\",\n    })\n  })\n\n  it(\"creates a repository in an organization when org is specified\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-org/test-repo\",\n          owner: {\n            login: \"test-org\",\n            id: 2,\n            avatar_url: \"https://avatars.githubusercontent.com/u/2\",\n            html_url: \"https://github.com/test-org\",\n            type: \"Organization\",\n          },\n          html_url: \"https://github.com/test-org/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-org/test-repo.git\",\n          ssh_url: \"git@github.com:test-org/test-repo.git\",\n          clone_url: \"https://github.com/test-org/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"file\",\n            path: \"file\",\n            sha: \"abc123\",\n          },\n        }),\n    })\n\n    await savePackageToGithub(mockPackage, {\n      ...mockOptions,\n      org: \"test-org\",\n    })\n\n    const repoCreateCall = fetchMock.mock.calls[0]\n    expect(repoCreateCall).toBeDefined()\n    if (!repoCreateCall) return\n\n    expect(repoCreateCall[0]).toEqual(\n      \"https://api.github.com/orgs/test-org/repos\",\n    )\n  })\n\n  it(\"uploads resource files with base64 encoding\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"data.csv\",\n            path: \"data.csv\",\n            sha: \"abc123\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"datapackage.json\",\n            path: \"datapackage.json\",\n            sha: \"def456\",\n          },\n        }),\n    })\n\n    await savePackageToGithub(mockPackage, mockOptions)\n\n    const fileUploadCall = fetchMock.mock.calls[1]\n    expect(fileUploadCall).toBeDefined()\n    if (!fileUploadCall) return\n\n    expect(fileUploadCall[0]).toEqual(\n      \"https://api.github.com/repos/test-user/test-repo/contents/data.csv\",\n    )\n    expect(fileUploadCall[1]).toMatchObject({\n      method: \"PUT\",\n      headers: {\n        Authorization: \"Bearer test-api-key\",\n        \"Content-Type\": \"application/json\",\n      },\n    })\n\n    const filePayload = JSON.parse(fileUploadCall[1].body)\n    expect(filePayload.path).toEqual(\"data.csv\")\n    expect(filePayload.message).toEqual('Added file \"data.csv\"')\n    expect(filePayload.content).toBeDefined()\n    expect(typeof filePayload.content).toEqual(\"string\")\n  })\n\n  it(\"uploads datapackage.json metadata file\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"data.csv\",\n            path: \"data.csv\",\n            sha: \"abc123\",\n          },\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"datapackage.json\",\n            path: \"datapackage.json\",\n            sha: \"def456\",\n          },\n        }),\n    })\n\n    await savePackageToGithub(mockPackage, mockOptions)\n\n    const datapackageUploadCall = fetchMock.mock.calls[2]\n    expect(datapackageUploadCall).toBeDefined()\n    if (!datapackageUploadCall) return\n\n    expect(datapackageUploadCall[0]).toEqual(\n      \"https://api.github.com/repos/test-user/test-repo/contents/datapackage.json\",\n    )\n\n    const datapackagePayload = JSON.parse(datapackageUploadCall[1].body)\n    expect(datapackagePayload.path).toEqual(\"datapackage.json\")\n    expect(datapackagePayload.message).toEqual('Added file \"datapackage.json\"')\n    expect(datapackagePayload.content).toBeDefined()\n    expect(typeof datapackagePayload.content).toEqual(\"string\")\n  })\n\n  it(\"passes API key as Bearer token in Authorization header\", async () => {\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    await savePackageToGithub(mockPackage, {\n      ...mockOptions,\n      apiKey: \"custom-api-key\",\n    })\n\n    const firstCall = fetchMock.mock.calls[0]\n    expect(firstCall).toBeDefined()\n    if (!firstCall) return\n\n    const headers = firstCall[1].headers\n    expect(headers.Authorization).toEqual(\"Bearer custom-api-key\")\n  })\n\n  it(\"handles API errors from repository creation\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: false,\n      status: 400,\n      statusText: \"Bad Request\",\n      text: () => Promise.resolve(\"Repository name already exists\"),\n    })\n\n    await expect(savePackageToGithub(mockPackage, mockOptions)).rejects.toThrow(\n      \"Github API error: 400 Bad Request\",\n    )\n  })\n\n  it(\"handles API errors from file upload\", async () => {\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: false,\n      status: 500,\n      statusText: \"Internal Server Error\",\n      text: () => Promise.resolve(\"Failed to upload file\"),\n    })\n\n    await expect(savePackageToGithub(mockPackage, mockOptions)).rejects.toThrow(\n      \"Github API error: 500 Internal Server Error\",\n    )\n  })\n\n  it(\"handles packages with multiple resources\", async () => {\n    const multiResourcePackage: Package = {\n      ...mockPackage,\n      resources: [\n        {\n          name: \"resource-1\",\n          path: getFixturePath(\"data.csv\"),\n          format: \"csv\",\n        },\n        {\n          name: \"resource-2\",\n          path: getFixturePath(\"data.csv\"),\n          format: \"json\",\n        },\n      ],\n    }\n\n    fetchMock.mockResolvedValue({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    await savePackageToGithub(multiResourcePackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(4)\n\n    const secondFileUploadCall = fetchMock.mock.calls[2]\n    expect(secondFileUploadCall).toBeDefined()\n    if (!secondFileUploadCall) return\n\n    expect(secondFileUploadCall[0]).toContain(\"/contents/\")\n  })\n\n  it(\"handles packages with no resources\", async () => {\n    const emptyPackage: Package = {\n      ...mockPackage,\n      resources: [],\n    }\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"datapackage.json\",\n            path: \"datapackage.json\",\n            sha: \"def456\",\n          },\n        }),\n    })\n\n    const result = await savePackageToGithub(emptyPackage, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(2)\n    expect(result.repoUrl).toEqual(\"https://github.com/test-user/test-repo\")\n  })\n\n  it(\"skips resources without path\", async () => {\n    const packageWithoutPath: Package = {\n      ...mockPackage,\n      resources: [\n        {\n          name: \"resource-without-path\",\n          format: \"csv\",\n        },\n      ],\n    }\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          id: 12345,\n          name: \"test-repo\",\n          full_name: \"test-user/test-repo\",\n          owner: {\n            login: \"test-user\",\n            id: 1,\n            avatar_url: \"https://avatars.githubusercontent.com/u/1\",\n            html_url: \"https://github.com/test-user\",\n            type: \"User\",\n          },\n          html_url: \"https://github.com/test-user/test-repo\",\n          description: null,\n          created_at: \"2024-01-01T00:00:00Z\",\n          updated_at: \"2024-01-01T00:00:00Z\",\n          homepage: null,\n          size: 0,\n          stargazers_count: 0,\n          watchers_count: 0,\n          language: null,\n          license: null,\n          default_branch: \"main\",\n          topics: [],\n          private: false,\n          archived: false,\n          git_url: \"git://github.com/test-user/test-repo.git\",\n          ssh_url: \"git@github.com:test-user/test-repo.git\",\n          clone_url: \"https://github.com/test-user/test-repo.git\",\n        }),\n    })\n\n    fetchMock.mockResolvedValueOnce({\n      ok: true,\n      json: () =>\n        Promise.resolve({\n          content: {\n            name: \"datapackage.json\",\n            path: \"datapackage.json\",\n            sha: \"def456\",\n          },\n        }),\n    })\n\n    await savePackageToGithub(packageWithoutPath, mockOptions)\n\n    expect(fetchMock).toHaveBeenCalledTimes(2)\n  })\n})\n"]}