From ed477289417471edb4e3c9472cead4ee7a4a8016 Mon Sep 17 00:00:00 2001 From: Hugo Dias Date: Wed, 24 Jul 2019 14:56:01 +0100 Subject: [PATCH] fix: reword resolve test with async/await --- src/miscellaneous/resolve.js | 154 ++++++++++------------------------- 1 file changed, 45 insertions(+), 109 deletions(-) diff --git a/src/miscellaneous/resolve.js b/src/miscellaneous/resolve.js index 282140db..6f465efb 100644 --- a/src/miscellaneous/resolve.js +++ b/src/miscellaneous/resolve.js @@ -4,10 +4,8 @@ const isIpfs = require('is-ipfs') const loadFixture = require('aegir/fixtures') const hat = require('hat') -const waterfall = require('async/waterfall') const multibase = require('multibase') const { spawnNodeWithId } = require('../utils/spawn') -const { connect } = require('../utils/swarm') const { getDescribe, getIt, expect } = require('../utils/mocha') module.exports = (createCommon, options) => { @@ -16,150 +14,88 @@ module.exports = (createCommon, options) => { const common = createCommon() describe('.resolve', () => { - let factory, ipfs + let ipfs + let nodeId before(function (done) { - // CI takes longer to instantiate the daemon, so we need to increase the - // timeout for the before step - this.timeout(60 * 1000) - - common.setup((err, f) => { + common.setup((err, factory) => { expect(err).to.not.exist() - factory = f - factory.spawnNode((err, node) => { + spawnNodeWithId(factory, (err, node) => { expect(err).to.not.exist() + ipfs = node + nodeId = node.peerId.id done() }) }) }) - after(function (done) { - this.timeout(10 * 1000) - common.teardown(done) - }) + after(common.teardown) - it('should resolve an IPFS hash', (done) => { + it('should resolve an IPFS hash', async () => { const content = loadFixture('test/fixtures/testfile.txt', 'interface-ipfs-core') - ipfs.add(content, (err, res) => { - expect(err).to.not.exist() - expect(isIpfs.cid(res[0].hash)).to.be.true() - - ipfs.resolve(`/ipfs/${res[0].hash}`, (err, path) => { - expect(err).to.not.exist() - expect(path).to.equal(`/ipfs/${res[0].hash}`) - done() - }) - }) + const [ { hash } ] = await ipfs.add(content) + const path = await ipfs.resolve(`/ipfs/${hash}`) + expect(path).to.equal(`/ipfs/${hash}`) }) - it('should resolve an IPFS hash and return a base64url encoded CID in path', (done) => { - const content = Buffer.from('TEST' + Date.now()) - - ipfs.add(content, (err, res) => { - expect(err).to.not.exist() + it('should resolve an IPFS hash and return a base64url encoded CID in path', async () => { + const [ { hash } ] = await ipfs.add(Buffer.from('base64url encoded')) + const path = await ipfs.resolve(`/ipfs/${hash}`, { cidBase: 'base64url' }) + const [,, cid] = path.split('/') - ipfs.resolve(`/ipfs/${res[0].hash}`, { cidBase: 'base64url' }, (err, path) => { - expect(err).to.not.exist() - const cid = path.split('/')[2] - expect(multibase.isEncoded(cid)).to.equal('base64url') - done() - }) - }) + expect(multibase.isEncoded(cid)).to.equal('base64url') }) // Test resolve turns /ipfs/QmRootHash/path/to/file into /ipfs/QmFileHash - it('should resolve an IPFS path link', (done) => { + it('should resolve an IPFS path link', async () => { const path = 'path/to/testfile.txt' const content = loadFixture('test/fixtures/testfile.txt', 'interface-ipfs-core') + const [{ hash: fileHash }, , , { hash: rootHash }] = await ipfs.add([{ path, content }], { wrapWithDirectory: true }) + const resolve = await ipfs.resolve(`/ipfs/${rootHash}/${path}`) - ipfs.add([{ path, content }], { wrapWithDirectory: true }, (err, res) => { - expect(err).to.not.exist() - - const rootHash = res.find(r => r.path === '').hash - const fileHash = res.find(r => r.path === path).hash - - ipfs.resolve(`/ipfs/${rootHash}/${path}`, (err, path) => { - expect(err).to.not.exist() - expect(path).to.equal(`/ipfs/${fileHash}`) - done() - }) - }) + expect(resolve).to.equal(`/ipfs/${fileHash}`) }) - it('should resolve up to the last node', (done) => { + it('should resolve up to the last node', async () => { const content = { path: { to: { file: hat() } } } const options = { format: 'dag-cbor', hashAlg: 'sha2-256' } + const cid = await ipfs.dag.put(content, options) + const path = `/ipfs/${cid}/path/to/file` + const resolved = await ipfs.resolve(path) - ipfs.dag.put(content, options, (err, cid) => { - expect(err).to.not.exist() - - const path = `/ipfs/${cid}/path/to/file` - ipfs.resolve(path, (err, resolved) => { - expect(err).to.not.exist() - expect(resolved).to.equal(path) - done() - }) - }) + expect(resolved).to.equal(path) }) - it('should resolve up to the last node across multiple nodes', (done) => { + it('should resolve up to the last node across multiple nodes', async () => { const options = { format: 'dag-cbor', hashAlg: 'sha2-256' } + const childCid = await ipfs.dag.put({ node: { with: { file: hat() } } }, options) + const parentCid = await ipfs.dag.put({ path: { to: childCid } }, options) + const resolved = await ipfs.resolve(`/ipfs/${parentCid}/path/to/node/with/file`) - waterfall([ - cb => { - const content = { node: { with: { file: hat() } } } - ipfs.dag.put(content, options, cb) - }, - (childCid, cb) => { - const content = { path: { to: childCid } } - ipfs.dag.put(content, options, (err, parentCid) => cb(err, { childCid, parentCid })) - } - ], (err, res) => { - expect(err).to.not.exist() - - const path = `/ipfs/${res.parentCid}/path/to/node/with/file` - ipfs.resolve(path, (err, resolved) => { - expect(err).to.not.exist() - expect(resolved).to.equal(`/ipfs/${res.childCid}/node/with/file`) - done() - }) - }) + expect(resolved).to.equal(`/ipfs/${childCid}/node/with/file`) }) // Test resolve turns /ipns/domain.com into /ipfs/QmHash - it('should resolve an IPNS DNS link', function (done) { - this.timeout(20 * 1000) + it('should resolve an IPNS DNS link', async function () { + this.retries(3) + const resolved = await ipfs.resolve('/ipns/ipfs.io') - ipfs.resolve('/ipns/ipfs.io', { r: true }, (err, path) => { - expect(err).to.not.exist() - expect(isIpfs.ipfsPath(path)).to.be.true() - done() - }) + expect(isIpfs.ipfsPath(resolved)).to.be.true() }) - // Test resolve turns /ipns/QmPeerHash into /ipns/domain.com into /ipfs/QmHash - it('should resolve IPNS link recursively', function (done) { - this.timeout(5 * 60 * 1000) - - waterfall([ - // Ensure node has another node to publish a name to - (cb) => spawnNodeWithId(factory, cb), - (ipfsB, cb) => { - const addr = ipfsB.peerId.addresses.find((a) => a.includes('127.0.0.1')) - connect(ipfs, addr, cb) - }, - (cb) => ipfs.name.publish('/ipns/ipfs.io', { resolve: false }, cb), - (res, cb) => { - ipfs.resolve(`/ipns/${res.name}`, { recursive: true }, (err, res) => { - expect(err).to.not.exist() - expect(res).to.not.equal('/ipns/ipfs.io') - expect(isIpfs.ipfsPath(res)).to.be.true() - cb() - }) - } - ], done) + it('should resolve IPNS link recursively', async function () { + this.timeout(20 * 1000) + + const [{ path }] = await ipfs.add(Buffer.from('should resolve a record recursive === true')) + const { id: keyId } = await ipfs.key.gen('key-name', { type: 'rsa', size: 2048 }) + + await ipfs.name.publish(path, { 'allow-offline': true }) + await ipfs.name.publish(`/ipns/${nodeId}`, { 'allow-offline': true, key: 'key-name' }) + + return expect(await ipfs.resolve(`/ipns/${keyId}`, { recursive: true })) + .to.eq(`/ipfs/${path}`) }) }) }