refactored util lib and unit tests with mocks

Author: christroutner

lib/Util.ts

@@ -32,14 +32,13 @@ export class Util {
 
         // Array of blocks.
       } else if (Array.isArray(address)) {
-        const options: AxiosRequestConfig = {
-          method: "POST",
-          url: `${this.restURL}util/validateAddress`,
-          data: {
+        // Dev note: must use axios.post for unit test stubbing.
+        const response: AxiosResponse = await axios.post(
+          `${this.restURL}util/validateAddress`,
+          {
             addresses: address
           }
-        }
-        const response: AxiosResponse = await axios(options)
+        )
 
         return response.data
       }

test/unit/Util.ts

@@ -4,11 +4,14 @@ import { BITBOX } from "../../lib/BITBOX"
 import { Util } from "../../lib/Util"
 import { resturl } from "../../lib/BITBOX"
 import * as util from "util"
-import { AddressValidateResult } from "bitcoin-com-rest";
+import { AddressValidateResult } from "bitcoin-com-rest"
+import axios from "axios"
+import * as sinon from "sinon"
 
 // conts
 const bitbox: BITBOX = new BITBOX()
 const assert: Chai.AssertStatic = chai.assert
+const mockData = require("./mocks/util-mock")
 
 util.inspect.defaultOptions = {
   showHidden: true,
@@ -17,6 +20,10 @@ util.inspect.defaultOptions = {
 }
 
 describe("#Util", (): void => {
+  let sandbox: any
+  beforeEach(() => (sandbox = sinon.sandbox.create()))
+  afterEach(() => sandbox.restore())
+
   describe("#UtilConstructor", (): void => {
     it("should create instance of Util", (): void => {
       const util: Util = new Util()
@@ -31,29 +38,32 @@ describe("#Util", (): void => {
 
   describe(`#validateAddress`, (): void => {
     it(`should return false for testnet addr on mainnet`, async () => {
-      const address: string = `bchtest:qqqk4y6lsl5da64sg5qc3xezmplyu5kmpyz2ysaa5y`
-
-      const result: AddressValidateResult | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
+      // Mock the call to rest to prevent live network calls.
+      const resolved = new Promise(r => r({ data: mockData.invalid }))
+      sandbox.stub(axios, "get").returns(resolved)
 
-      assert.hasAllKeys(result, ["isvalid"])
-      if (!Array.isArray(result)) {
-        assert.equal(result.isvalid, false)
-      }
-    })
+      const address: string = `bchtest:qqqk4y6lsl5da64sg5qc3xezmplyu5kmpyz2ysaa5y`
 
-    it(`should return false for bad address`, async () => {
-      const address: string = `bitcoincash:qp4k8fjtgunhdr7yq30ha4peu`
-      const result: AddressValidateResult | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
+      const result:
+        | AddressValidateResult
+        | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
+      //console.log(`result: ${JSON.stringify(result,null,2)}`)
 
       assert.hasAllKeys(result, ["isvalid"])
-      if (!Array.isArray(result)) {
-        assert.equal(result.isvalid, false)
-      }
+      if (!Array.isArray(result)) assert.equal(result.isvalid, false)
     })
 
     it(`should validate valid address`, async () => {
+      // Mock the call to rest to prevent live network calls.
+      const resolved = new Promise(r => r({ data: mockData.valid }))
+      sandbox.stub(axios, "get").returns(resolved)
+
       const address: string = `bitcoincash:qp4k8fjtgunhdr7yq30ha4peuwupzan2vcnwrmpy0z`
-      const result: AddressValidateResult | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
+
+      const result:
+        | AddressValidateResult
+        | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
+      //console.log(`result: ${JSON.stringify(result,null,2)}`)
 
       assert.hasAllKeys(result, [
         "isvalid",
@@ -63,18 +73,23 @@ describe("#Util", (): void => {
         "iswatchonly",
         "isscript"
       ])
-      if (!Array.isArray(result)) {
-        assert.equal(result.isvalid, true)
-      }
+      if (!Array.isArray(result)) assert.equal(result.isvalid, true)
     })
 
     it(`should validate an array of addresses`, async () => {
+      // Mock the call to rest to prevent live network calls.
+      const testData = [mockData.valid, mockData.valid]
+      const resolved = new Promise(r => r({ data: testData }))
+      sandbox.stub(axios, "post").returns(resolved)
+
       const address: string[] = [
         `bitcoincash:qp4k8fjtgunhdr7yq30ha4peuwupzan2vcnwrmpy0z`,
         `bitcoincash:qp4k8fjtgunhdr7yq30ha4peuwupzan2vcnwrmpy0z`
       ]
 
-      const result: AddressValidateResult | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
+      const result:
+        | AddressValidateResult
+        | AddressValidateResult[] = await bitbox.Util.validateAddress(address)
 
       assert.isArray(result)
       if (Array.isArray(result)) {
@@ -89,32 +104,24 @@ describe("#Util", (): void => {
       }
     })
 
-    it(`should throw an error for improper single input`, async () => {
+    it(`should pass error from server to user`, async () => {
       try {
+        // Mock out data for unit test, to prevent live network call.
+        sandbox
+          .stub(axios, "get")
+          .throws("error", "Input must be a string or array of strings.")
+
         const address: any = 15432
 
         await bitbox.Util.validateAddress(address)
         assert.equal(true, false, "Unexpected result!")
       } catch (err) {
+        //console.log(`err: ${util.inspect(err)}`)
         assert.include(
           err.message,
           `Input must be a string or array of strings.`
         )
       }
     })
-
-    it(`should throw error on array size rate limit`, async () => {
-      try {
-        const dataMock: string = `bitcoincash:qp4k8fjtgunhdr7yq30ha4peuwupzan2vcnwrmpy0z`
-        const data: string[] = []
-        for (let i: number = 0; i < 25; i++) data.push(dataMock)
-
-        const result: AddressValidateResult | AddressValidateResult[] = await bitbox.Util.validateAddress(data)
-        assert.equal(true, false, "Unexpected result!")
-      } catch (err) {
-        assert.hasAnyKeys(err, ["error"])
-        assert.include(err.error, "Array too large")
-      }
-    })
   })
 })

test/unit/mocks/util-mock.js

@@ -0,0 +1,18 @@
+/*
+  Mock data used for unit testing.
+*/
+
+module.exports = {
+  invalid: {
+    isvalid: false
+  },
+
+  valid: {
+    isvalid: true,
+    address: "bitcoincash:qp4k8fjtgunhdr7yq30ha4peuwupzan2vcnwrmpy0z",
+    scriptPubKey: "76a9146b63a64b4727768fc4045f7ed439e3b811766a6688ac",
+    ismine: false,
+    iswatchonly: false,
+    isscript: false
+  }
+}