@helia/interop 3.0.0 → 3.0.1-19bf9ce

package/src/unixfs-bitswap.spec.ts

@@ -0,0 +1,86 @@
+/* eslint-env mocha */
+
+import { type UnixFS, unixfs } from '@helia/unixfs'
+import { expect } from 'aegir/chai'
+import toBuffer from 'it-to-buffer'
+import { CID } from 'multiformats/cid'
+import { createHeliaNode } from './fixtures/create-helia.js'
+import { createKuboNode } from './fixtures/create-kubo.js'
+import type { HeliaLibp2p } from 'helia'
+import type { FileCandidate } from 'ipfs-unixfs-importer'
+import type { Controller } from 'ipfsd-ctl'
+
+describe('@helia/unixfs - bitswap', () => {
+  let helia: HeliaLibp2p
+  let unixFs: UnixFS
+  let kubo: Controller
+
+  beforeEach(async () => {
+    helia = await createHeliaNode()
+    unixFs = unixfs(helia)
+    kubo = await createKuboNode()
+
+    // connect helia to kubo
+    await helia.libp2p.dial(kubo.peer.addresses)
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+
+    if (kubo != null) {
+      await kubo.stop()
+    }
+  })
+
+  it('should add a large file to helia and fetch it from kubo', async () => {
+    const chunkSize = 1024 * 1024
+    const size = chunkSize * 10
+    const input: Uint8Array[] = []
+
+    const candidate: FileCandidate = {
+      content: (async function * () {
+        for (let i = 0; i < size; i += chunkSize) {
+          const buf = new Uint8Array(chunkSize)
+          input.push(buf)
+
+          yield buf
+        }
+      }())
+    }
+
+    const cid = await unixFs.addFile(candidate)
+
+    const output: Uint8Array[] = []
+
+    for await (const b of kubo.api.cat(cid)) {
+      output.push(b)
+    }
+
+    expect(toBuffer(output)).to.equalBytes(toBuffer(input))
+  })
+
+  it('should add a large file to kubo and fetch it from helia', async () => {
+    const chunkSize = 1024 * 1024
+    const size = chunkSize * 10
+    const input: Uint8Array[] = []
+
+    const candidate: FileCandidate = {
+      content: (async function * () {
+        for (let i = 0; i < size; i += chunkSize) {
+          const buf = new Uint8Array(chunkSize)
+          input.push(buf)
+
+          yield buf
+        }
+      }())
+    }
+
+    const { cid } = await kubo.api.add(candidate.content)
+
+    const bytes = await toBuffer(unixFs.cat(CID.parse(cid.toString())))
+
+    expect(bytes).to.equalBytes(toBuffer(input))
+  })
+})

package/src/unixfs-files.spec.ts

@@ -0,0 +1,89 @@
+/* eslint-env mocha */
+
+import { type AddOptions, type UnixFS, unixfs } from '@helia/unixfs'
+import { expect } from 'aegir/chai'
+import { fixedSize } from 'ipfs-unixfs-importer/chunker'
+import { balanced } from 'ipfs-unixfs-importer/layout'
+import { CID } from 'multiformats/cid'
+import { createHeliaNode } from './fixtures/create-helia.js'
+import { createKuboNode } from './fixtures/create-kubo.js'
+import type { HeliaLibp2p } from 'helia'
+import type { AddOptions as KuboAddOptions } from 'ipfs-core-types/src/root.js'
+import type { FileCandidate } from 'ipfs-unixfs-importer'
+import type { Controller } from 'ipfsd-ctl'
+
+describe('@helia/unixfs - files', () => {
+  let helia: HeliaLibp2p
+  let unixFs: UnixFS
+  let kubo: Controller
+
+  async function importToHelia (data: FileCandidate, opts?: Partial<AddOptions>): Promise<CID> {
+    const cid = await unixFs.addFile(data, opts)
+
+    return cid
+  }
+
+  async function importToKubo (data: FileCandidate, opts?: KuboAddOptions): Promise<CID> {
+    const result = await kubo.api.add(data.content, opts)
+
+    return CID.parse(result.cid.toString())
+  }
+
+  async function expectSameCid (data: () => FileCandidate, heliaOpts: Partial<AddOptions> = {}, kuboOpts: KuboAddOptions = {}): Promise<void> {
+    const heliaCid = await importToHelia(data(), {
+      // these are the default kubo options
+      cidVersion: 0,
+      rawLeaves: false,
+      layout: balanced({
+        maxChildrenPerNode: 174
+      }),
+      chunker: fixedSize({
+        chunkSize: 262144
+      }),
+
+      ...heliaOpts
+    })
+    const kuboCid = await importToKubo(data(), kuboOpts)
+
+    expect(heliaCid.toString()).to.equal(kuboCid.toString())
+  }
+
+  beforeEach(async () => {
+    helia = await createHeliaNode()
+    unixFs = unixfs(helia)
+    kubo = await createKuboNode()
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+
+    if (kubo != null) {
+      await kubo.stop()
+    }
+  })
+
+  it('should create the same CID for a small file', async () => {
+    const candidate = (): FileCandidate => ({
+      content: Uint8Array.from([0, 1, 2, 3, 4])
+    })
+
+    await expectSameCid(candidate)
+  })
+
+  it('should create the same CID for a large file', async () => {
+    const chunkSize = 1024 * 1024
+    const size = chunkSize * 10
+
+    const candidate = (): FileCandidate => ({
+      content: (async function * () {
+        for (let i = 0; i < size; i += chunkSize) {
+          yield new Uint8Array(chunkSize)
+        }
+      }())
+    })
+
+    await expectSameCid(candidate)
+  })
+})