mirror of
https://github.com/fullstack-cash/bch-api.git
synced 2026-09-21 16:52:04 -07:00
1272 lines
44 KiB
JavaScript
1272 lines
44 KiB
JavaScript
/*
|
|
TODO:
|
|
-getRawMempool
|
|
--Add tests for 'verbose' input values
|
|
-getMempoolEntry & getMempoolEntryBulk
|
|
--Needs e2e test to create unconfirmed tx, for real-world test.
|
|
*/
|
|
|
|
"use strict"
|
|
|
|
const chai = require("chai")
|
|
const assert = chai.assert
|
|
const nock = require("nock") // HTTP mocking
|
|
const sinon = require("sinon")
|
|
// const blockchainRoute = require("../../src/routes/v3/full-node/blockchain")
|
|
|
|
const Blockchain = require("../../src/routes/v3/full-node/blockchain2")
|
|
const uut = new Blockchain()
|
|
|
|
const util = require("util")
|
|
util.inspect.defaultOptions = { depth: 1 }
|
|
|
|
if (!process.env.TEST) process.env.TEST = "unit"
|
|
|
|
// Mocking data.
|
|
const { mockReq, mockRes } = require("./mocks/express-mocks")
|
|
const mockData = require("./mocks/blockchain-mock")
|
|
|
|
let originalEnvVars // Used during transition from integration to unit tests.
|
|
|
|
describe("#BlockchainRouter2", () => {
|
|
let req, res
|
|
let sandbox
|
|
|
|
// local node will be started in regtest mode on the port 48332
|
|
//before(panda.runLocalNode)
|
|
|
|
before(() => {
|
|
// Save existing environment variables.
|
|
originalEnvVars = {
|
|
BITCOINCOM_BASEURL: process.env.BITCOINCOM_BASEURL,
|
|
RPC_BASEURL: process.env.RPC_BASEURL,
|
|
RPC_USERNAME: process.env.RPC_USERNAME,
|
|
RPC_PASSWORD: process.env.RPC_PASSWORD
|
|
}
|
|
|
|
// Set default environment variables for unit tests.
|
|
if (process.env.TEST === "unit") {
|
|
process.env.BITCOINCOM_BASEURL = "http://fakeurl/api/"
|
|
process.env.RPC_BASEURL = "http://fakeurl/api"
|
|
process.env.RPC_USERNAME = "fakeusername"
|
|
process.env.RPC_PASSWORD = "fakepassword"
|
|
}
|
|
})
|
|
|
|
// Setup the mocks before each test.
|
|
beforeEach(() => {
|
|
// Mock the req and res objects used by Express routes.
|
|
req = mockReq
|
|
res = mockRes
|
|
|
|
// Explicitly reset the parmas and body.
|
|
req.params = {}
|
|
req.body = {}
|
|
|
|
// Activate nock if it's inactive.
|
|
if (!nock.isActive()) nock.activate()
|
|
|
|
sandbox = sinon.createSandbox()
|
|
})
|
|
|
|
afterEach(() => {
|
|
// Clean up HTTP mocks.
|
|
nock.cleanAll() // clear interceptor list.
|
|
nock.restore()
|
|
|
|
sandbox.restore()
|
|
})
|
|
|
|
after(() => {
|
|
// otherwise the panda will run forever
|
|
//process.exit()
|
|
|
|
// Restore any pre-existing environment variables.
|
|
process.env.BITCOINCOM_BASEURL = originalEnvVars.BITCOINCOM_BASEURL
|
|
process.env.RPC_BASEURL = originalEnvVars.RPC_BASEURL
|
|
process.env.RPC_USERNAME = originalEnvVars.RPC_USERNAME
|
|
process.env.RPC_PASSWORD = originalEnvVars.RPC_PASSWORD
|
|
})
|
|
|
|
describe("#root", () => {
|
|
it("should respond to GET for base route", async () => {
|
|
const result = uut.root(req, res)
|
|
|
|
assert.equal(result.status, "blockchain", "Returns static string")
|
|
})
|
|
})
|
|
|
|
describe("getBestBlockHash()", () => {
|
|
// block route handler.
|
|
// const getBestBlockHash = blockchainRoute.testableComponents.getBestBlockHash
|
|
|
|
it("should throw 503 when network issues", async () => {
|
|
// Save the existing RPC URL.
|
|
const savedUrl2 = process.env.RPC_BASEURL
|
|
|
|
// Manipulate the URL to cause a 500 network error.
|
|
process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
|
|
const result = await uut.getBestBlockHash(req, res)
|
|
// console.log(`result: ${util.inspect(result)}`)
|
|
|
|
// Restore the saved URL.
|
|
process.env.RPC_BASEURL = savedUrl2
|
|
|
|
assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
assert.include(
|
|
result.error,
|
|
"Could not communicate with full node",
|
|
"Error message expected"
|
|
)
|
|
})
|
|
|
|
it("returns proper error when downstream service stalls", async () => {
|
|
// Mock the timeout error.
|
|
sandbox.stub(uut.axios, "request").throws({ code: "ECONNABORTED" })
|
|
|
|
const result = await uut.getBestBlockHash(req, res)
|
|
// console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
|
|
assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
assert.include(
|
|
result.error,
|
|
"Could not communicate with full node",
|
|
"Error message expected"
|
|
)
|
|
})
|
|
|
|
it("returns proper error when downstream service is down", async () => {
|
|
// Mock the timeout error.
|
|
sandbox.stub(uut.axios, "request").throws({ code: "ECONNREFUSED" })
|
|
|
|
const result = await uut.getBestBlockHash(req, res)
|
|
// console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
|
|
assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
assert.include(
|
|
result.error,
|
|
"Could not communicate with full node",
|
|
"Error message expected"
|
|
)
|
|
})
|
|
|
|
it("should GET /getBestBlockHash", async () => {
|
|
// Mock the RPC call for unit tests.
|
|
if (process.env.TEST === "unit") {
|
|
sandbox
|
|
.stub(uut.axios, "request")
|
|
.resolves({ data: { result: mockData.mockBlockHash } })
|
|
}
|
|
|
|
const result = await uut.getBestBlockHash(req, res)
|
|
// console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
|
|
assert.isString(result)
|
|
assert.equal(result.length, 64, "Hash string is fixed length")
|
|
})
|
|
})
|
|
|
|
describe("getBlockchainInfo()", () => {
|
|
// block route handler.
|
|
// const getBlockchainInfo =
|
|
// blockchainRoute.testableComponents.getBlockchainInfo
|
|
|
|
it("should throw 503 when network issues", async () => {
|
|
// Save the existing RPC URL.
|
|
const savedUrl2 = process.env.RPC_BASEURL
|
|
|
|
// Manipulate the URL to cause a 500 network error.
|
|
process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
|
|
const result = await uut.getBlockchainInfo(req, res)
|
|
//console.log(`result: ${util.inspect(result)}`)
|
|
|
|
// Restore the saved URL.
|
|
process.env.RPC_BASEURL = savedUrl2
|
|
|
|
assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
assert.include(
|
|
result.error,
|
|
"Could not communicate with full node",
|
|
"Error message expected"
|
|
)
|
|
})
|
|
|
|
it("returns proper error when downstream service stalls", async () => {
|
|
// Mock the timeout error.
|
|
sandbox.stub(uut.axios, "request").throws({ code: "ECONNABORTED" })
|
|
|
|
const result = await uut.getBestBlockHash(req, res)
|
|
// console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
|
|
assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
assert.include(
|
|
result.error,
|
|
"Could not communicate with full node",
|
|
"Error message expected"
|
|
)
|
|
})
|
|
|
|
it("returns proper error when downstream service is down", async () => {
|
|
// Mock the timeout error.
|
|
sandbox.stub(uut.axios, "request").throws({ code: "ECONNREFUSED" })
|
|
|
|
const result = await uut.getBestBlockHash(req, res)
|
|
// console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
|
|
assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
assert.include(
|
|
result.error,
|
|
"Could not communicate with full node",
|
|
"Error message expected"
|
|
)
|
|
})
|
|
|
|
it("should GET /getBlockchainInfo", async () => {
|
|
// Mock the RPC call for unit tests.
|
|
if (process.env.TEST === "unit") {
|
|
nock(`${process.env.RPC_BASEURL}`)
|
|
.post(uri => uri.includes("/"))
|
|
.reply(200, { result: mockData.mockBlockchainInfo })
|
|
}
|
|
|
|
const result = await uut.getBlockchainInfo(req, res)
|
|
//console.log(`result: ${util.inspect(result)}`)
|
|
|
|
assert.hasAnyKeys(result, [
|
|
"chain",
|
|
"blocks",
|
|
"headers",
|
|
"bestblockhash",
|
|
"difficulty",
|
|
"mediantime",
|
|
"verificationprogress",
|
|
"chainwork",
|
|
"pruned",
|
|
"softforks",
|
|
"bip9_softforks"
|
|
])
|
|
})
|
|
})
|
|
|
|
// describe("getBlockCount()", () => {
|
|
// // block route handler.
|
|
// const getBlockCount = blockchainRoute.testableComponents.getBlockCount
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// const result = await getBlockCount(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getBlockCount", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: 126769 })
|
|
// }
|
|
//
|
|
// const result = await getBlockCount(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isNumber(result)
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getBlockHeaderSingle()", async () => {
|
|
// const getBlockHeader =
|
|
// blockchainRoute.testableComponents.getBlockHeaderSingle
|
|
//
|
|
// it("should throw 400 error if hash is missing", async () => {
|
|
// const result = await getBlockHeader(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "hash can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// req.params.hash =
|
|
// "00000000000008c3679777df34f1a09565f98b2400a05b7c8da72525fdca3900"
|
|
//
|
|
// const result = await getBlockHeader(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Network error: Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET block header", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, {
|
|
// result:
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c"
|
|
// })
|
|
// }
|
|
//
|
|
// req.params.hash =
|
|
// "000000000000000002fa9d7851b284c53a5831651b04211c266badf2ad2d8ef0"
|
|
//
|
|
// const result = await getBlockHeader(req, res)
|
|
// // console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isString(result)
|
|
// assert.equal(
|
|
// result,
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET verbose block header", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockBlockHeader })
|
|
// }
|
|
//
|
|
// req.query.verbose = true
|
|
// req.params.hash =
|
|
// "000000000000000002fa9d7851b284c53a5831651b04211c266badf2ad2d8ef0"
|
|
//
|
|
// const result = await getBlockHeader(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, [
|
|
// "hash",
|
|
// "confirmations",
|
|
// "height",
|
|
// "version",
|
|
// "versionHex",
|
|
// "merkleroot",
|
|
// "time",
|
|
// "mediantime",
|
|
// "nonce",
|
|
// "bits",
|
|
// "difficulty",
|
|
// "chainwork",
|
|
// "previousblockhash",
|
|
// "nextblockhash"
|
|
// ])
|
|
// })
|
|
// })
|
|
//
|
|
// describe("#getBlockHeaderBulk", () => {
|
|
// // route handler.
|
|
// const getBlockHeaderBulk =
|
|
// blockchainRoute.testableComponents.getBlockHeaderBulk
|
|
//
|
|
// it("should throw an error for an empty body", async () => {
|
|
// req.body = {}
|
|
//
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "hashes needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should error on non-array single hash", async () => {
|
|
// req.body.hashes =
|
|
// "00000000000008c3679777df34f1a09565f98b2400a05b7c8da72525fdca3900"
|
|
//
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "hashes needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should throw 400 error if addresses array is too large", async () => {
|
|
// const testArray = []
|
|
// for (var i = 0; i < 25; i++) testArray.push("")
|
|
//
|
|
// req.body.hashes = testArray
|
|
//
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "Array too large")
|
|
// })
|
|
//
|
|
// it("should throw a 400 error for an invalid hash", async () => {
|
|
// req.body.hashes = ["badHash"]
|
|
//
|
|
// await getBlockHeaderBulk(req, res)
|
|
// // console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// })
|
|
//
|
|
// it("should throw 500 when network issues", async () => {
|
|
// const savedUrl = process.env.BITCOINCOM_BASEURL
|
|
//
|
|
// try {
|
|
// req.body.hashes = [
|
|
// "00000000000008c3679777df34f1a09565f98b2400a05b7c8da72525fdca3900"
|
|
// ]
|
|
//
|
|
// // Switch the Insight URL to something that will error out.
|
|
// process.env.BITCOINCOM_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.BITCOINCOM_BASEURL = savedUrl
|
|
//
|
|
// assert.equal(res.statusCode, 500, "HTTP status code 500 expected.")
|
|
// assert.include(result.error, "ENOTFOUND", "Error message expected")
|
|
// } catch (err) {
|
|
// // Restore the saved URL.
|
|
// process.env.BITCOINCOM_BASEURL = savedUrl
|
|
// }
|
|
// })
|
|
//
|
|
// it("should get concise block header for a single hash", async () => {
|
|
// req.body.hashes = [
|
|
// "000000000000000002fa9d7851b284c53a5831651b04211c266badf2ad2d8ef0"
|
|
// ]
|
|
//
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockBlockHeaderConcise })
|
|
// }
|
|
//
|
|
// // Call the details API.
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
// // console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Assert that required fields exist in the returned object.
|
|
// assert.isArray(result)
|
|
// assert.equal(
|
|
// result[0],
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should get verbose block header for a single hash", async () => {
|
|
// req.body = {
|
|
// hashes: [
|
|
// "000000000000000002fa9d7851b284c53a5831651b04211c266badf2ad2d8ef0"
|
|
// ],
|
|
// verbose: true
|
|
// }
|
|
//
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockBlockHeader })
|
|
// }
|
|
//
|
|
// // Call the details API.
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Assert that required fields exist in the returned object.
|
|
// assert.isArray(result)
|
|
// assert.hasAllKeys(result[0], [
|
|
// "hash",
|
|
// "confirmations",
|
|
// "height",
|
|
// "version",
|
|
// "versionHex",
|
|
// "merkleroot",
|
|
// "time",
|
|
// "mediantime",
|
|
// "nonce",
|
|
// "bits",
|
|
// "difficulty",
|
|
// "chainwork",
|
|
// "previousblockhash",
|
|
// "nextblockhash"
|
|
// ])
|
|
// })
|
|
//
|
|
// it("should get details for multiple block heights", async () => {
|
|
// req.body.hashes = [
|
|
// "000000000000000002fa9d7851b284c53a5831651b04211c266badf2ad2d8ef0",
|
|
// "000000000000000002fa9d7851b284c53a5831651b04211c266badf2ad2d8ef0"
|
|
// ]
|
|
//
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .times(2)
|
|
// .reply(200, { result: mockData.mockBlockHeaderConcise })
|
|
// }
|
|
//
|
|
// // Call the details API.
|
|
// const result = await getBlockHeaderBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.equal(result.length, 2, "2 outputs for 2 inputs")
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getChainTips()", () => {
|
|
// // block route handler.
|
|
// const getChainTips = blockchainRoute.testableComponents.getChainTips
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// const result = await getChainTips(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getChainTips", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockChainTips })
|
|
// }
|
|
//
|
|
// const result = await getChainTips(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.hasAnyKeys(result[0], ["height", "hash", "branchlen", "status"])
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getDifficulty()", () => {
|
|
// // block route handler.
|
|
// const getDifficulty = blockchainRoute.testableComponents.getDifficulty
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// const result = await getDifficulty(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getDifficulty", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: 4049809.205246544 })
|
|
// }
|
|
//
|
|
// const result = await getDifficulty(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isNumber(result)
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getMempoolInfo()", () => {
|
|
// // block route handler.
|
|
// const getMempoolInfo = blockchainRoute.testableComponents.getMempoolInfo
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// const result = await getMempoolInfo(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getMempoolInfo", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockMempoolInfo })
|
|
// }
|
|
//
|
|
// const result = await getMempoolInfo(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAnyKeys(result, [
|
|
// "result",
|
|
// "bytes",
|
|
// "usage",
|
|
// "maxmempool",
|
|
// "mempoolminfree"
|
|
// ])
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getRawMempool()", () => {
|
|
// // block route handler.
|
|
// const getRawMempool = blockchainRoute.testableComponents.getRawMempool
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// const result = await getRawMempool(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getMempoolInfo", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockRawMempool })
|
|
// }
|
|
//
|
|
// const result = await getRawMempool(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// // Not sure what other assertions should be made here.
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getMempoolEntry()", () => {
|
|
// // block route handler.
|
|
// const getMempoolEntry =
|
|
// blockchainRoute.testableComponents.getMempoolEntrySingle
|
|
//
|
|
// it("should throw 400 if txid is empty", async () => {
|
|
// const result = await getMempoolEntry(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "txid can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// req.params.txid = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
//
|
|
// const result = await getMempoolEntry(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getMempoolEntry", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: { error: "Transaction not in mempool" } })
|
|
// }
|
|
//
|
|
// req.params.txid = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
//
|
|
// const result = await getMempoolEntry(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.isString(result.error)
|
|
// assert.equal(result.error, "Transaction not in mempool")
|
|
// })
|
|
// })
|
|
//
|
|
// describe("#getMempoolEntryBulk", () => {
|
|
// // route handler.
|
|
// const getMempoolEntryBulk =
|
|
// blockchainRoute.testableComponents.getMempoolEntryBulk
|
|
//
|
|
// it("should throw an error for an empty body", async () => {
|
|
// req.body = {}
|
|
//
|
|
// const result = await getMempoolEntryBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "txids needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should error on non-array single txid", async () => {
|
|
// req.body.txids = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
//
|
|
// const result = await getMempoolEntryBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "txids needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should throw 400 error if addresses array is too large", async () => {
|
|
// const testArray = []
|
|
// for (var i = 0; i < 25; i++) testArray.push("")
|
|
//
|
|
// req.body.txids = testArray
|
|
//
|
|
// const result = await getMempoolEntryBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "Array too large")
|
|
// })
|
|
//
|
|
// // Only execute on integration tests.
|
|
// if (process.env.TEST !== "unit") {
|
|
// // Dev-note: This test passes because it expects an error. TXIDs do not
|
|
// // stay in the mempool for long, so it does not work well for a unit or
|
|
// // integration test.
|
|
// it("should retrieve single mempool entry", async () => {
|
|
// req.body.txids = [
|
|
// `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
// ]
|
|
//
|
|
// const result = await getMempoolEntryBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.isString(result.error)
|
|
// assert.equal(result.error, "Transaction not in mempool")
|
|
// })
|
|
//
|
|
// // Dev-note: This test passes because it expects an error. TXIDs do not
|
|
// // stay in the mempool for long, so it does not work well for a unit or
|
|
// // integration test.
|
|
// it("should retrieve multiple mempool entries", async () => {
|
|
// req.body.txids = [
|
|
// `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`,
|
|
// `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
// ]
|
|
//
|
|
// const result = await getMempoolEntryBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.isString(result.error)
|
|
// assert.equal(result.error, "Transaction not in mempool")
|
|
// })
|
|
// }
|
|
// })
|
|
//
|
|
// describe("getMempoolAncestorsSingle()", () => {
|
|
// // block route handler.
|
|
// const getMempoolAncestorsSingle =
|
|
// blockchainRoute.testableComponents.getMempoolAncestorsSingle
|
|
//
|
|
// it("should throw 400 if txid is empty", async () => {
|
|
// const result = await getMempoolAncestorsSingle(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "txid can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// req.params.txid = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
//
|
|
// const result = await getMempoolAncestorsSingle(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getMempoolAncestorsSingle", async () => {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockAncestors })
|
|
//
|
|
// req.params.txid = `bb0d349892d351da2767f8c45f6f7949713ff09bd12838d53e76158ddee3ce93`
|
|
//
|
|
// const result = await getMempoolAncestorsSingle(req, res)
|
|
// // console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getTxOut()", () => {
|
|
// // block route handler.
|
|
// const getTxOut = blockchainRoute.testableComponents.getTxOut
|
|
//
|
|
// it("should throw 400 if txid is empty", async () => {
|
|
// const result = await getTxOut(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "txid can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 400 if n is empty", async () => {
|
|
// req.params.txid = `sometxid`
|
|
// const result = await getTxOut(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "n can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// req.params.txid = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
// req.params.n = 0
|
|
//
|
|
// const result = await getTxOut(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// // This test can only run for unit tests. See TODO at the top of this file.
|
|
// it("should GET /getTxOut", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockTxOut })
|
|
// }
|
|
//
|
|
// req.params.txid = `197dcda59864b1eee05498fd3c52cad787ec56ab7e635503cb39f9ab6f295d5d`
|
|
// req.params.n = 0
|
|
// req.query.include_mempool = "true"
|
|
//
|
|
// const result = await getTxOut(req, res)
|
|
// // console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.hasAllKeys(result, [
|
|
// "bestblock",
|
|
// "confirmations",
|
|
// "value",
|
|
// "scriptPubKey",
|
|
// "coinbase"
|
|
// ])
|
|
// assert.hasAllKeys(result.scriptPubKey, [
|
|
// "asm",
|
|
// "hex",
|
|
// "reqSigs",
|
|
// "type",
|
|
// "addresses"
|
|
// ])
|
|
// assert.isArray(result.scriptPubKey.addresses)
|
|
// })
|
|
// })
|
|
//
|
|
// describe("getTxOutProof()", () => {
|
|
// const getTxOutProof = blockchainRoute.testableComponents.getTxOutProofSingle
|
|
//
|
|
// it("should throw 400 if txid is empty", async () => {
|
|
// const result = await getTxOutProof(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "txid can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// req.params.txid = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
//
|
|
// const result = await getTxOutProof(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /getTxOutProof", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockTxOutProof })
|
|
// }
|
|
//
|
|
// req.params.txid = `2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266`
|
|
//
|
|
// const result = await getTxOutProof(req, res)
|
|
// // console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.isString(result)
|
|
// })
|
|
// })
|
|
//
|
|
// describe("#getTxOutProofBulk", () => {
|
|
// // route handler.
|
|
// const getTxOutProofBulk =
|
|
// blockchainRoute.testableComponents.getTxOutProofBulk
|
|
//
|
|
// it("should throw an error for an empty body", async () => {
|
|
// req.body = {}
|
|
//
|
|
// const result = await getTxOutProofBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "txids needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should error on non-array single txid", async () => {
|
|
// req.body.txids = `d65881582ff2bff36747d7a0d0e273f10281abc8bd5c15df5d72f8f3fa779cde`
|
|
//
|
|
// const result = await getTxOutProofBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "txids needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should throw 400 error if addresses array is too large", async () => {
|
|
// const testArray = []
|
|
// for (var i = 0; i < 25; i++) testArray.push("")
|
|
//
|
|
// req.body.txids = testArray
|
|
//
|
|
// const result = await getTxOutProofBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "Array too large")
|
|
// })
|
|
//
|
|
// it("should GET proof for single txid", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: mockData.mockTxOutProof })
|
|
// }
|
|
//
|
|
// req.body.txids = [
|
|
// `2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266`
|
|
// ]
|
|
//
|
|
// const result = await getTxOutProofBulk(req, res)
|
|
// //console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.isString(result[0])
|
|
// })
|
|
//
|
|
// it("should GET proof for multiple txids", async () => {
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .times(2)
|
|
// .reply(200, { result: mockData.mockTxOutProof })
|
|
// }
|
|
//
|
|
// req.body.txids = [
|
|
// `2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266`,
|
|
// `2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266`
|
|
// ]
|
|
//
|
|
// const result = await getTxOutProofBulk(req, res)
|
|
// //console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.equal(result.length, 2, "Correct length of returned array")
|
|
// })
|
|
// })
|
|
//
|
|
// describe("verifyTxOutProof()", () => {
|
|
// const verifyTxOutProof =
|
|
// blockchainRoute.testableComponents.verifyTxOutProofSingle
|
|
//
|
|
// it("should throw 400 if proof is empty", async () => {
|
|
// const result = await verifyTxOutProof(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "proof can not be empty")
|
|
// })
|
|
//
|
|
// it("should throw 503 when network issues", async () => {
|
|
// // Save the existing RPC URL.
|
|
// const savedUrl2 = process.env.RPC_BASEURL
|
|
//
|
|
// // Manipulate the URL to cause a 500 network error.
|
|
// process.env.RPC_BASEURL = "http://fakeurl/api/"
|
|
//
|
|
// req.params.proof = mockData.mockTxOutProof
|
|
//
|
|
// const result = await verifyTxOutProof(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// // Restore the saved URL.
|
|
// process.env.RPC_BASEURL = savedUrl2
|
|
//
|
|
// assert.isAbove(res.statusCode, 499, "HTTP status code 503 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "Could not communicate with full node",
|
|
// "Error message expected"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should GET /verifyTxOutProof", async () => {
|
|
// const expected =
|
|
// "2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266"
|
|
//
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: [expected] })
|
|
// }
|
|
//
|
|
// req.params.proof =
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c1e000000067139f230701a2819a76795564bd2f67ded7eeae68596f368eddb3dd5bc54e59320e896f71d61cfc3ae3d4a90fca08b1aa35ba91256d8939d2cad11e638c0081f66724abdef55cf7b8b9fed064bce0369171434f8b289c1330ccef765f8e97a2c0d794d81aafb535855f7daa6bb51e40f77c6b59d7af7f62d0eb726a4fc4df82353d56fcbda7c7ea6bd935d61af8fb3b295637e6f323b10231135b3f10a034cfb238f635830c0595e52c6c31247cf677b555f7a287076e20cd0e1d3cc9af7260f02b700"
|
|
//
|
|
// const result = await verifyTxOutProof(req, res)
|
|
// //console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.isString(result[0])
|
|
// assert.equal(result[0], expected)
|
|
// })
|
|
// })
|
|
//
|
|
// describe("#verifyTxOutProofBulk", () => {
|
|
// // route handler.
|
|
// const verifyTxOutProofBulk =
|
|
// blockchainRoute.testableComponents.verifyTxOutProofBulk
|
|
//
|
|
// it("should throw an error for an empty body", async () => {
|
|
// req.body = {}
|
|
//
|
|
// const result = await verifyTxOutProofBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "proofs needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should error on non-array single txid", async () => {
|
|
// req.body.proofs = mockData.mockTxOutProof
|
|
//
|
|
// const result = await verifyTxOutProofBulk(req, res)
|
|
//
|
|
// assert.equal(res.statusCode, 400, "HTTP status code 400 expected.")
|
|
// assert.include(
|
|
// result.error,
|
|
// "proofs needs to be an array",
|
|
// "Proper error message"
|
|
// )
|
|
// })
|
|
//
|
|
// it("should throw 400 error if addresses array is too large", async () => {
|
|
// const testArray = []
|
|
// for (var i = 0; i < 25; i++) testArray.push("")
|
|
//
|
|
// req.body.proofs = testArray
|
|
//
|
|
// const result = await verifyTxOutProofBulk(req, res)
|
|
// //console.log(`result: ${util.inspect(result)}`)
|
|
//
|
|
// assert.hasAllKeys(result, ["error"])
|
|
// assert.include(result.error, "Array too large")
|
|
// })
|
|
//
|
|
// it("should get single proof", async () => {
|
|
// const expected =
|
|
// "2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266"
|
|
//
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .reply(200, { result: [expected] })
|
|
// }
|
|
//
|
|
// req.body.proofs = [
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c1e000000067139f230701a2819a76795564bd2f67ded7eeae68596f368eddb3dd5bc54e59320e896f71d61cfc3ae3d4a90fca08b1aa35ba91256d8939d2cad11e638c0081f66724abdef55cf7b8b9fed064bce0369171434f8b289c1330ccef765f8e97a2c0d794d81aafb535855f7daa6bb51e40f77c6b59d7af7f62d0eb726a4fc4df82353d56fcbda7c7ea6bd935d61af8fb3b295637e6f323b10231135b3f10a034cfb238f635830c0595e52c6c31247cf677b555f7a287076e20cd0e1d3cc9af7260f02b700"
|
|
// ]
|
|
//
|
|
// const result = await verifyTxOutProofBulk(req, res)
|
|
// //console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.isString(result[0])
|
|
// assert.equal(result[0], expected)
|
|
// })
|
|
//
|
|
// it("should get multiple proofs", async () => {
|
|
// const expected =
|
|
// "2c7ae9f865f7ce0c33c189b2f83414176903ce4b06ed9f8b7bcf55efbd4a7266"
|
|
//
|
|
// // Mock the RPC call for unit tests.
|
|
// if (process.env.TEST === "unit") {
|
|
// nock(`${process.env.RPC_BASEURL}`)
|
|
// .post(uri => uri.includes("/"))
|
|
// .times(2)
|
|
// .reply(200, { result: [expected] })
|
|
// }
|
|
//
|
|
// req.body.proofs = [
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c1e000000067139f230701a2819a76795564bd2f67ded7eeae68596f368eddb3dd5bc54e59320e896f71d61cfc3ae3d4a90fca08b1aa35ba91256d8939d2cad11e638c0081f66724abdef55cf7b8b9fed064bce0369171434f8b289c1330ccef765f8e97a2c0d794d81aafb535855f7daa6bb51e40f77c6b59d7af7f62d0eb726a4fc4df82353d56fcbda7c7ea6bd935d61af8fb3b295637e6f323b10231135b3f10a034cfb238f635830c0595e52c6c31247cf677b555f7a287076e20cd0e1d3cc9af7260f02b700",
|
|
// "000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c1e000000067139f230701a2819a76795564bd2f67ded7eeae68596f368eddb3dd5bc54e59320e896f71d61cfc3ae3d4a90fca08b1aa35ba91256d8939d2cad11e638c0081f66724abdef55cf7b8b9fed064bce0369171434f8b289c1330ccef765f8e97a2c0d794d81aafb535855f7daa6bb51e40f77c6b59d7af7f62d0eb726a4fc4df82353d56fcbda7c7ea6bd935d61af8fb3b295637e6f323b10231135b3f10a034cfb238f635830c0595e52c6c31247cf677b555f7a287076e20cd0e1d3cc9af7260f02b700"
|
|
// ]
|
|
//
|
|
// const result = await verifyTxOutProofBulk(req, res)
|
|
// //console.log(`result: ${JSON.stringify(result, null, 2)}`)
|
|
//
|
|
// assert.isArray(result)
|
|
// assert.isString(result[0])
|
|
// assert.equal(result[0], expected)
|
|
// assert.equal(result.length, 2)
|
|
// })
|
|
// })
|
|
})
|