chore: Increase test coverage

dataset/file/copy.spec.ts

@@ -0,0 +1,134 @@
+import * as fs from "node:fs/promises"
+import * as path from "node:path"
+import { temporaryDirectory } from "tempy"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { copyFile } from "./copy.ts"
+import { writeTempFile } from "./temp.ts"
+
+describe("copyFile", () => {
+  let testDir: string
+
+  beforeEach(() => {
+    testDir = temporaryDirectory()
+  })
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true })
+    } catch (error) {
+      if (error instanceof Error && !error.message.includes("ENOENT")) {
+        console.error(`Failed to clean up test directory: ${testDir}`, error)
+      }
+    }
+  })
+
+  it("should copy file from source to target", async () => {
+    const sourcePath = await writeTempFile("test content")
+    const targetPath = path.join(testDir, "target.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const fileExists = await fs
+      .stat(targetPath)
+      .then(() => true)
+      .catch(() => false)
+    expect(fileExists).toBe(true)
+
+    const content = await fs.readFile(targetPath, "utf-8")
+    expect(content).toBe("test content")
+  })
+
+  it("should copy file with exact content", async () => {
+    const content = "Hello, World! This is a test file."
+    const sourcePath = await writeTempFile(content)
+    const targetPath = path.join(testDir, "copy.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const copiedContent = await fs.readFile(targetPath, "utf-8")
+    expect(copiedContent).toBe(content)
+  })
+
+  it("should copy binary file", async () => {
+    const binaryData = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10])
+    const sourcePath = await writeTempFile(binaryData)
+    const targetPath = path.join(testDir, "binary.bin")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const copiedData = await fs.readFile(targetPath)
+    expect(Buffer.compare(copiedData, binaryData)).toBe(0)
+  })
+
+  it("should copy empty file", async () => {
+    const sourcePath = await writeTempFile("")
+    const targetPath = path.join(testDir, "empty.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const content = await fs.readFile(targetPath, "utf-8")
+    expect(content).toBe("")
+  })
+
+  it("should copy large file", async () => {
+    const largeContent = "x".repeat(100000)
+    const sourcePath = await writeTempFile(largeContent)
+    const targetPath = path.join(testDir, "large.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const copiedContent = await fs.readFile(targetPath, "utf-8")
+    expect(copiedContent).toBe(largeContent)
+    expect(copiedContent.length).toBe(100000)
+  })
+
+  it("should copy file with special characters", async () => {
+    const content = "Special characters: é, ñ, ü, ö, à, 中文, 日本語"
+    const sourcePath = await writeTempFile(content)
+    const targetPath = path.join(testDir, "special.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const copiedContent = await fs.readFile(targetPath, "utf-8")
+    expect(copiedContent).toBe(content)
+  })
+
+  it("should copy file to nested directory", async () => {
+    const sourcePath = await writeTempFile("nested content")
+    const targetPath = path.join(testDir, "nested", "dir", "file.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const fileExists = await fs
+      .stat(targetPath)
+      .then(() => true)
+      .catch(() => false)
+    expect(fileExists).toBe(true)
+
+    const content = await fs.readFile(targetPath, "utf-8")
+    expect(content).toBe("nested content")
+  })
+
+  it("should copy json file", async () => {
+    const jsonContent = JSON.stringify({ name: "test", value: 123 })
+    const sourcePath = await writeTempFile(jsonContent)
+    const targetPath = path.join(testDir, "data.json")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const copiedContent = await fs.readFile(targetPath, "utf-8")
+    expect(copiedContent).toBe(jsonContent)
+    expect(JSON.parse(copiedContent)).toEqual({ name: "test", value: 123 })
+  })
+
+  it("should copy file with newlines", async () => {
+    const content = "Line 1\nLine 2\nLine 3\n"
+    const sourcePath = await writeTempFile(content)
+    const targetPath = path.join(testDir, "multiline.txt")
+
+    await copyFile({ sourcePath, targetPath })
+
+    const copiedContent = await fs.readFile(targetPath, "utf-8")
+    expect(copiedContent).toBe(content)
+  })
+})

dataset/plugins/descriptor/plugin.spec.ts

@@ -0,0 +1,227 @@
+import type { Package } from "@dpkit/metadata"
+import * as metadataModule from "@dpkit/metadata"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { DescriptorPlugin } from "./plugin.ts"
+
+vi.mock("@dpkit/metadata", async () => {
+  const actual = await vi.importActual("@dpkit/metadata")
+  return {
+    ...actual,
+    loadPackageDescriptor: vi.fn(),
+    savePackageDescriptor: vi.fn(),
+  }
+})
+
+describe("DescriptorPlugin", () => {
+  let plugin: DescriptorPlugin
+  let mockLoadPackageDescriptor: ReturnType<typeof vi.fn>
+  let mockSavePackageDescriptor: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    plugin = new DescriptorPlugin()
+    mockLoadPackageDescriptor = vi.mocked(metadataModule.loadPackageDescriptor)
+    mockSavePackageDescriptor = vi.mocked(metadataModule.savePackageDescriptor)
+    vi.clearAllMocks()
+  })
+
+  describe("loadPackage", () => {
+    it("should load package from local datapackage.json file", async () => {
+      const mockPackage: Package = {
+        name: "test-package",
+        resources: [{ name: "test", data: [] }],
+      }
+      mockLoadPackageDescriptor.mockResolvedValue(mockPackage)
+
+      const result = await plugin.loadPackage("./datapackage.json")
+
+      expect(mockLoadPackageDescriptor).toHaveBeenCalledWith(
+        "./datapackage.json",
+      )
+      expect(result).toEqual(mockPackage)
+    })
+
+    it("should load package from local json file", async () => {
+      const mockPackage: Package = {
+        name: "test-package",
+        resources: [{ name: "test", data: [] }],
+      }
+      mockLoadPackageDescriptor.mockResolvedValue(mockPackage)
+
+      const result = await plugin.loadPackage("./package.json")
+
+      expect(mockLoadPackageDescriptor).toHaveBeenCalledWith("./package.json")
+      expect(result).toEqual(mockPackage)
+    })
+
+    it("should return undefined for remote json urls", async () => {
+      const result = await plugin.loadPackage(
+        "https://example.com/datapackage.json",
+      )
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for http remote json urls", async () => {
+      const result = await plugin.loadPackage(
+        "http://example.com/datapackage.json",
+      )
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for local csv files", async () => {
+      const result = await plugin.loadPackage("./data.csv")
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for local xlsx files", async () => {
+      const result = await plugin.loadPackage("./data.xlsx")
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for local parquet files", async () => {
+      const result = await plugin.loadPackage("./data.parquet")
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should handle absolute paths", async () => {
+      const mockPackage: Package = {
+        name: "test-package",
+        resources: [{ name: "test", data: [] }],
+      }
+      mockLoadPackageDescriptor.mockResolvedValue(mockPackage)
+
+      const result = await plugin.loadPackage("/absolute/path/datapackage.json")
+
+      expect(mockLoadPackageDescriptor).toHaveBeenCalledWith(
+        "/absolute/path/datapackage.json",
+      )
+      expect(result).toEqual(mockPackage)
+    })
+
+    it("should return undefined for github urls", async () => {
+      const result = await plugin.loadPackage(
+        "https://github.com/owner/repo/datapackage.json",
+      )
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for zenodo urls", async () => {
+      const result = await plugin.loadPackage("https://zenodo.org/record/123")
+
+      expect(mockLoadPackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe("savePackage", () => {
+    const mockPackage: Package = {
+      name: "test-package",
+      resources: [{ name: "test", data: [] }],
+    }
+
+    it("should save package to local datapackage.json file", async () => {
+      mockSavePackageDescriptor.mockResolvedValue(undefined)
+
+      const result = await plugin.savePackage(mockPackage, {
+        target: "./datapackage.json",
+      })
+
+      expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {
+        path: "./datapackage.json",
+      })
+      expect(result).toEqual({ path: "./datapackage.json" })
+    })
+
+    it("should save package with absolute path", async () => {
+      mockSavePackageDescriptor.mockResolvedValue(undefined)
+
+      const result = await plugin.savePackage(mockPackage, {
+        target: "/absolute/path/datapackage.json",
+      })
+
+      expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {
+        path: "/absolute/path/datapackage.json",
+      })
+      expect(result).toEqual({ path: "/absolute/path/datapackage.json" })
+    })
+
+    it("should return undefined for remote urls", async () => {
+      const result = await plugin.savePackage(mockPackage, {
+        target: "https://example.com/datapackage.json",
+      })
+
+      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for local json files not named datapackage.json", async () => {
+      const result = await plugin.savePackage(mockPackage, {
+        target: "./package.json",
+      })
+
+      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for local csv files", async () => {
+      const result = await plugin.savePackage(mockPackage, {
+        target: "./data.csv",
+      })
+
+      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for local xlsx files", async () => {
+      const result = await plugin.savePackage(mockPackage, {
+        target: "./data.xlsx",
+      })
+
+      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should return undefined for http urls", async () => {
+      const result = await plugin.savePackage(mockPackage, {
+        target: "http://example.com/datapackage.json",
+      })
+
+      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+
+    it("should ignore withRemote option for local files", async () => {
+      mockSavePackageDescriptor.mockResolvedValue(undefined)
+
+      const result = await plugin.savePackage(mockPackage, {
+        target: "./datapackage.json",
+        withRemote: true,
+      })
+
+      expect(mockSavePackageDescriptor).toHaveBeenCalledWith(mockPackage, {
+        path: "./datapackage.json",
+      })
+      expect(result).toEqual({ path: "./datapackage.json" })
+    })
+
+    it("should return undefined for local directories", async () => {
+      const result = await plugin.savePackage(mockPackage, {
+        target: "./data",
+      })
+
+      expect(mockSavePackageDescriptor).not.toHaveBeenCalled()
+      expect(result).toBeUndefined()
+    })
+  })
+})