@bitgo-beta/sdk-core 8.2.1-beta.20 → 8.2.1-beta.2000

package/dist/test/unit/bitgo/address-book/address-book.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon = __importStar(require("sinon"));
+const superagent = __importStar(require("superagent"));
+require("should");
+const address_book_1 = require("../../../../src/bitgo/address-book/address-book");
+describe('AddressBook', function () {
+    let addressBook;
+    let mockBitGo;
+    const enterpriseId = 'test-enterprise-id';
+    function makeGetStub() {
+        const queryStub = sinon.stub().returns({ result: sinon.stub().resolves({}) });
+        const setStub = sinon.stub().returns({ query: queryStub });
+        mockBitGo.get.returns({ set: setStub });
+        return { setStub, queryStub };
+    }
+    function makeParameterlessGetStub(response = {}) {
+        const resultStub = sinon.stub().resolves(response);
+        const setStub = sinon.stub().returns({ result: resultStub });
+        mockBitGo.get.returns({ set: setStub });
+        return { setStub, resultStub };
+    }
+    beforeEach(function () {
+        mockBitGo = {
+            get: sinon.stub(),
+            microservicesUrl: sinon.stub().callsFake((path) => `https://app.bitgo.com${path}`),
+        };
+        addressBook = new address_book_1.AddressBook(enterpriseId, mockBitGo);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('getConnections', function () {
+        it('should pass params as query string, not request body', async function () {
+            const { queryStub } = makeGetStub();
+            const params = { connectionType: 'DVP', status: 'INACTIVE', offset: 0, limit: 10 };
+            await addressBook.getConnections(params);
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/connections');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, params);
+        });
+        it('should work with no params', async function () {
+            const { queryStub } = makeGetStub();
+            await addressBook.getConnections();
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/connections');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, {});
+        });
+        it('should pass array filters to query unchanged', async function () {
+            const { queryStub } = makeGetStub();
+            const params = {
+                ownerWalletId: ['wallet-a', 'wallet-b'],
+                targetWalletId: ['wallet-c'],
+            };
+            await addressBook.getConnections(params);
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/connections');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, params);
+        });
+    });
+    describe('getConnections array query param serialization', function () {
+        it('superagent serializes string[] as repeated keys, which address-book accepts via nonEmptyArrayFromQueryParam', function () {
+            const req = superagent.get('https://example.com').query({
+                ownerWalletId: ['wallet-a', 'wallet-b'],
+                targetWalletId: ['wallet-c'],
+            });
+            // Trigger superagent's query-string assembly without sending the request.
+            req.end(() => undefined);
+            req.url.should.equal('https://example.com?ownerWalletId=wallet-a&ownerWalletId=wallet-b&targetWalletId=wallet-c');
+        });
+    });
+    describe('getListing', function () {
+        it('should use GET with enterprise-id header and no query or body', async function () {
+            const listing = {
+                id: 'listing-id',
+                enterpriseId,
+                name: 'Test Listing',
+                owner: 'owner',
+                createdAt: '2024-01-01',
+                updatedAt: '2024-01-01',
+            };
+            const { setStub, resultStub } = makeParameterlessGetStub(listing);
+            const result = await addressBook.getListing();
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/global');
+            sinon.assert.calledOnce(setStub);
+            sinon.assert.calledWith(setStub, 'enterprise-id', enterpriseId);
+            sinon.assert.calledOnce(resultStub);
+            result.should.deepEqual(listing);
+        });
+    });
+    describe('getListingEntryContacts', function () {
+        it('should pass params as query string, not request body', async function () {
+            const { queryStub } = makeGetStub();
+            const params = { status: 'ACTIVE', limit: 5 };
+            await addressBook.getListingEntryContacts(params);
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/contacts');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, params);
+        });
+        it('should work with no params', async function () {
+            const { queryStub } = makeGetStub();
+            await addressBook.getListingEntryContacts();
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/contacts');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, {});
+        });
+    });
+    describe('getListingEntryDirectory', function () {
+        it('should pass params as query string, not request body', async function () {
+            const { queryStub } = makeGetStub();
+            const params = { status: 'ACTIVE', limit: 5 };
+            await addressBook.getListingEntryDirectory(params);
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/directory');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, params);
+        });
+        it('should work with no params', async function () {
+            const { queryStub } = makeGetStub();
+            await addressBook.getListingEntryDirectory();
+            sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/directory');
+            sinon.assert.calledOnce(queryStub);
+            sinon.assert.calledWith(queryStub, {});
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"address-book.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/address-book/address-book.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sinon from 'sinon';\nimport * as superagent from 'superagent';\nimport 'should';\nimport { AddressBook } from '../../../../src/bitgo/address-book/address-book';\n\ndescribe('AddressBook', function () {\n  let addressBook: AddressBook;\n  let mockBitGo: any;\n  const enterpriseId = 'test-enterprise-id';\n\n  function makeGetStub() {\n    const queryStub = sinon.stub().returns({ result: sinon.stub().resolves({}) });\n    const setStub = sinon.stub().returns({ query: queryStub });\n    mockBitGo.get.returns({ set: setStub });\n    return { setStub, queryStub };\n  }\n\n  function makeParameterlessGetStub(response: Record<string, unknown> = {}) {\n    const resultStub = sinon.stub().resolves(response);\n    const setStub = sinon.stub().returns({ result: resultStub });\n    mockBitGo.get.returns({ set: setStub });\n    return { setStub, resultStub };\n  }\n\n  beforeEach(function () {\n    mockBitGo = {\n      get: sinon.stub(),\n      microservicesUrl: sinon.stub().callsFake((path: string) => `https://app.bitgo.com${path}`),\n    };\n    addressBook = new AddressBook(enterpriseId, mockBitGo);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('getConnections', function () {\n    it('should pass params as query string, not request body', async function () {\n      const { queryStub } = makeGetStub();\n      const params = { connectionType: 'DVP' as const, status: 'INACTIVE' as const, offset: 0, limit: 10 };\n\n      await addressBook.getConnections(params);\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/connections');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, params);\n    });\n\n    it('should work with no params', async function () {\n      const { queryStub } = makeGetStub();\n\n      await addressBook.getConnections();\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/connections');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, {});\n    });\n\n    it('should pass array filters to query unchanged', async function () {\n      const { queryStub } = makeGetStub();\n      const params = {\n        ownerWalletId: ['wallet-a', 'wallet-b'],\n        targetWalletId: ['wallet-c'],\n      };\n\n      await addressBook.getConnections(params);\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/connections');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, params);\n    });\n  });\n\n  describe('getConnections array query param serialization', function () {\n    it('superagent serializes string[] as repeated keys, which address-book accepts via nonEmptyArrayFromQueryParam', function () {\n      const req = superagent.get('https://example.com').query({\n        ownerWalletId: ['wallet-a', 'wallet-b'],\n        targetWalletId: ['wallet-c'],\n      });\n      // Trigger superagent's query-string assembly without sending the request.\n      req.end(() => undefined);\n\n      req.url!.should.equal(\n        'https://example.com?ownerWalletId=wallet-a&ownerWalletId=wallet-b&targetWalletId=wallet-c'\n      );\n    });\n  });\n\n  describe('getListing', function () {\n    it('should use GET with enterprise-id header and no query or body', async function () {\n      const listing = {\n        id: 'listing-id',\n        enterpriseId,\n        name: 'Test Listing',\n        owner: 'owner',\n        createdAt: '2024-01-01',\n        updatedAt: '2024-01-01',\n      };\n      const { setStub, resultStub } = makeParameterlessGetStub(listing);\n\n      const result = await addressBook.getListing();\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/global');\n      sinon.assert.calledOnce(setStub);\n      sinon.assert.calledWith(setStub, 'enterprise-id', enterpriseId);\n      sinon.assert.calledOnce(resultStub);\n      result.should.deepEqual(listing);\n    });\n  });\n\n  describe('getListingEntryContacts', function () {\n    it('should pass params as query string, not request body', async function () {\n      const { queryStub } = makeGetStub();\n      const params = { status: 'ACTIVE' as const, limit: 5 };\n\n      await addressBook.getListingEntryContacts(params);\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/contacts');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, params);\n    });\n\n    it('should work with no params', async function () {\n      const { queryStub } = makeGetStub();\n\n      await addressBook.getListingEntryContacts();\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/contacts');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, {});\n    });\n  });\n\n  describe('getListingEntryDirectory', function () {\n    it('should pass params as query string, not request body', async function () {\n      const { queryStub } = makeGetStub();\n      const params = { status: 'ACTIVE' as const, limit: 5 };\n\n      await addressBook.getListingEntryDirectory(params);\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/directory');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, params);\n    });\n\n    it('should work with no params', async function () {\n      const { queryStub } = makeGetStub();\n\n      await addressBook.getListingEntryDirectory();\n\n      sinon.assert.calledWith(mockBitGo.get, 'https://app.bitgo.com/api/address-book/v1/listing/entry/directory');\n      sinon.assert.calledOnce(queryStub);\n      sinon.assert.calledWith(queryStub, {});\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/defi/defiVault.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=defiVault.d.ts.map

package/dist/test/unit/bitgo/defi/defiVault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defiVault.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/defi/defiVault.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,CAAC"}