@helia/interop 3.0.1 → 4.0.0-e554493

package/src/json.spec.ts

@@ -0,0 +1,65 @@
+/* eslint-env mocha */
+
+import { json, type JSON, type AddOptions } from '@helia/json'
+import { expect } from 'aegir/chai'
+import { CID } from 'multiformats/cid'
+import * as jsonCodec from 'multiformats/codecs/json'
+import { createHeliaNode } from './fixtures/create-helia.js'
+import { createKuboNode } from './fixtures/create-kubo.js'
+import type { HeliaLibp2p } from 'helia'
+import type { PutOptions as KuboAddOptions } from 'ipfs-core-types/src/block/index.js'
+import type { Controller } from 'ipfsd-ctl'
+
+describe('@helia/json', () => {
+  let helia: HeliaLibp2p
+  let j: JSON
+  let kubo: Controller
+
+  async function expectSameCid (data: () => any, heliaOpts: Partial<AddOptions> = {}, kuboOpts: KuboAddOptions = { format: 'json' }): Promise<void> {
+    const heliaCid = await j.add(data(), heliaOpts)
+    const kuboCid = await kubo.api.block.put(jsonCodec.encode(data()), kuboOpts)
+
+    expect(heliaCid.toString()).to.equal(kuboCid.toString())
+  }
+
+  beforeEach(async () => {
+    helia = await createHeliaNode()
+    j = json(helia)
+    kubo = await createKuboNode()
+
+    await helia.libp2p.dial((await (kubo.api.id())).addresses)
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+
+    if (kubo != null) {
+      await kubo.stop()
+    }
+  })
+
+  it('should create the same CID for a string', async () => {
+    const candidate = (): any => ({ hello: 'world' })
+
+    await expectSameCid(candidate)
+  })
+
+  it('should add to helia and fetch from kubo', async () => {
+    const input = { hello: 'world' }
+    const cid = await j.add(input)
+    const block = await kubo.api.block.get(cid)
+    const output = jsonCodec.decode(block)
+
+    expect(output).to.deep.equal(input)
+  })
+
+  it('should add to kubo and fetch from helia', async () => {
+    const input = { hello: 'world' }
+    const cid = await kubo.api.block.put(jsonCodec.encode(input))
+    const output = await j.get(CID.parse(cid.toString()))
+
+    expect(output).to.deep.equal(input)
+  })
+})

package/src/mfs.spec.ts

@@ -0,0 +1,105 @@
+/* eslint-env mocha */
+
+import { type MFS, mfs } from '@helia/mfs'
+import { expect } from 'aegir/chai'
+import { createHeliaNode } from './fixtures/create-helia.js'
+import { createKuboNode } from './fixtures/create-kubo.js'
+import type { HeliaLibp2p } from 'helia'
+import type { Controller } from 'ipfsd-ctl'
+
+describe('@helia/mfs', () => {
+  let helia: HeliaLibp2p
+  let fs: MFS
+  let kubo: Controller
+
+  beforeEach(async () => {
+    helia = await createHeliaNode()
+    fs = mfs(helia)
+    kubo = await createKuboNode()
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+
+    if (kubo != null) {
+      await kubo.stop()
+    }
+  })
+
+  it('should have the same CID initially', async () => {
+    const heliaStat = await fs.stat('/')
+    const kuboStat = await kubo.api.files.stat('/')
+
+    expect(heliaStat.cid.toV1().toString()).to.equal(kuboStat.cid.toV1().toString())
+  })
+
+  it('should have the same CID after creating a directory', async () => {
+    const dirPath = '/foo'
+    await fs.mkdir(dirPath)
+    await kubo.api.files.mkdir(dirPath, {
+      cidVersion: 1
+    })
+
+    const heliaStat = await fs.stat('/')
+    const kuboStat = await kubo.api.files.stat('/')
+
+    expect(heliaStat.cid.toV1().toString()).to.equal(kuboStat.cid.toV1().toString())
+  })
+
+  it('should have the same CID after removing a directory', async () => {
+    const dirPath = '/foo'
+    await fs.mkdir(dirPath)
+    await fs.rm(dirPath)
+    await kubo.api.files.mkdir(dirPath, {
+      cidVersion: 1
+    })
+    await kubo.api.files.rm(dirPath, {
+      recursive: true
+    })
+
+    const heliaStat = await fs.stat('/')
+    const kuboStat = await kubo.api.files.stat('/')
+
+    expect(heliaStat.cid.toV1().toString()).to.equal(kuboStat.cid.toV1().toString())
+  })
+
+  it('should have the same CID after creating a file', async () => {
+    const filePath = '/foo.txt'
+    const fileData = Uint8Array.from([0, 1, 2, 3, 4])
+    await fs.writeBytes(fileData, filePath, {
+      rawLeaves: true,
+      reduceSingleLeafToSelf: false
+    })
+    await kubo.api.files.write(filePath, fileData, {
+      cidVersion: 1,
+      create: true
+    })
+
+    const heliaStat = await fs.stat('/')
+    const kuboStat = await kubo.api.files.stat('/')
+
+    expect(heliaStat.cid.toV1().toString()).to.equal(kuboStat.cid.toV1().toString())
+  })
+
+  it('should have the same CID after removing a file', async () => {
+    const filePath = '/foo.txt'
+    const fileData = Uint8Array.from([0, 1, 2, 3, 4])
+    await fs.writeBytes(fileData, filePath, {
+      rawLeaves: true,
+      reduceSingleLeafToSelf: false
+    })
+    await fs.rm(filePath)
+    await kubo.api.files.write(filePath, fileData, {
+      cidVersion: 1,
+      create: true
+    })
+    await kubo.api.files.rm(filePath)
+
+    const heliaStat = await fs.stat('/')
+    const kuboStat = await kubo.api.files.stat('/')
+
+    expect(heliaStat.cid.toV1().toString()).to.equal(kuboStat.cid.toV1().toString())
+  })
+})

package/src/strings.spec.ts

@@ -0,0 +1,67 @@
+/* eslint-env mocha */
+
+import { strings, type Strings, type AddOptions } from '@helia/strings'
+import { expect } from 'aegir/chai'
+import { CID } from 'multiformats/cid'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { createHeliaNode } from './fixtures/create-helia.js'
+import { createKuboNode } from './fixtures/create-kubo.js'
+import type { HeliaLibp2p } from 'helia'
+import type { PutOptions as KuboAddOptions } from 'ipfs-core-types/src/block/index.js'
+import type { Controller } from 'ipfsd-ctl'
+
+describe('@helia/strings', () => {
+  let helia: HeliaLibp2p
+  let str: Strings
+  let kubo: Controller
+
+  async function expectSameCid (data: () => string, heliaOpts: Partial<AddOptions> = {}, kuboOpts: KuboAddOptions = {}): Promise<void> {
+    const heliaCid = await str.add(data(), heliaOpts)
+    const kuboCid = await kubo.api.block.put(uint8ArrayFromString(data()), kuboOpts)
+
+    expect(heliaCid.toString()).to.equal(kuboCid.toString())
+  }
+
+  beforeEach(async () => {
+    helia = await createHeliaNode()
+    str = strings(helia)
+    kubo = await createKuboNode()
+
+    const id = await kubo.api.id()
+    await helia.libp2p.dial(id.addresses)
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+
+    if (kubo != null) {
+      await kubo.stop()
+    }
+  })
+
+  it('should create the same CID for a string', async () => {
+    const candidate = (): string => 'hello world'
+
+    await expectSameCid(candidate)
+  })
+
+  it('should add to helia and fetch from kubo', async () => {
+    const input = 'hello world'
+    const cid = await str.add(input)
+    const block = await kubo.api.block.get(cid)
+    const output = uint8ArrayToString(block)
+
+    expect(output).to.equal(input)
+  })
+
+  it('should add to kubo and fetch from helia', async () => {
+    const input = 'hello world'
+    const cid = await kubo.api.block.put(uint8ArrayFromString(input))
+    const output = await str.get(CID.parse(cid.toString()))
+
+    expect(output).to.equal(input)
+  })
+})

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)
+  })
+})