@bitgo/sdk-api 1.75.5 → 1.76.1

package/dist/test/unit/hmacStrategy.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const nock_1 = __importDefault(require("nock"));
+const bitgoAPI_1 = require("../../src/bitgoAPI");
+const node_assert_1 = __importDefault(require("node:assert"));
+const TEST_TOKEN = 'v2x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefab';
+const TEST_URI = 'https://app.example.local';
+/**
+ * Mock strategy that records calls and returns predictable values.
+ */
+class MockHmacAuthStrategy {
+    constructor() {
+        this.calculateRequestHeadersCalls = [];
+        this.verifyResponseCalls = [];
+        this.calculateHMACCalls = [];
+    }
+    async calculateRequestHeaders(params) {
+        this.calculateRequestHeadersCalls.push(params);
+        return {
+            hmac: 'mock-hmac-value',
+            timestamp: 1672531200000,
+            tokenHash: 'mock-token-hash',
+        };
+    }
+    async verifyResponse(params) {
+        this.verifyResponseCalls.push(params);
+        return {
+            isValid: true,
+            expectedHmac: 'mock-hmac-value',
+            signatureSubject: 'mock-subject',
+            isInResponseValidityWindow: true,
+            verificationTime: Date.now(),
+        };
+    }
+    async calculateHMAC(key, message) {
+        this.calculateHMACCalls.push({ key, message });
+        return 'mock-hmac-password';
+    }
+}
+describe('BitGoAPI HMAC Strategy Injection', function () {
+    afterEach(function () {
+        nock_1.default.cleanAll();
+    });
+    describe('constructor', function () {
+        it('should accept a custom hmacAuthStrategy', function () {
+            const strategy = new MockHmacAuthStrategy();
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: TEST_URI,
+                hmacAuthStrategy: strategy,
+            });
+            bitgo.should.be.ok();
+        });
+        it('should default to DefaultHmacAuthStrategy when none is provided', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: TEST_URI,
+            });
+            bitgo.should.be.ok();
+        });
+    });
+    describe('request signing via strategy', function () {
+        it('should use the custom strategy for HMAC header calculation', async function () {
+            const strategy = new MockHmacAuthStrategy();
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: TEST_URI,
+                accessToken: TEST_TOKEN,
+                hmacAuthStrategy: strategy,
+            });
+            const scope = (0, nock_1.default)(TEST_URI)
+                .get('/api/v2/wallet')
+                .matchHeader('HMAC', 'mock-hmac-value')
+                .matchHeader('Authorization', 'Bearer mock-token-hash')
+                .matchHeader('Auth-Timestamp', '1672531200000')
+                .reply(200, { wallets: [] }, {
+                hmac: 'response-hmac',
+                timestamp: Date.now().toString(),
+            });
+            await bitgo.get(bitgo.url('/wallet', 2)).result();
+            strategy.calculateRequestHeadersCalls.length.should.equal(1);
+            const call = strategy.calculateRequestHeadersCalls[0];
+            call.token.should.equal(TEST_TOKEN);
+            call.method.should.equal('get');
+            scope.isDone().should.be.true();
+        });
+        it('should use the custom strategy for response verification', async function () {
+            const strategy = new MockHmacAuthStrategy();
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: TEST_URI,
+                accessToken: TEST_TOKEN,
+                hmacAuthStrategy: strategy,
+            });
+            (0, nock_1.default)(TEST_URI).get('/api/v2/wallet').reply(200, { wallets: [] }, {
+                hmac: 'server-response-hmac',
+                timestamp: Date.now().toString(),
+            });
+            await bitgo.get(bitgo.url('/wallet', 2)).result();
+            strategy.verifyResponseCalls.length.should.equal(1);
+            const call = strategy.verifyResponseCalls[0];
+            call.hmac.should.equal('server-response-hmac');
+            (0, node_assert_1.default)(call.statusCode, 'statusCode is required');
+            call.statusCode.should.equal(200);
+        });
+    });
+    describe('password HMAC via strategy', function () {
+        it('should use the custom strategy for password hashing in preprocessAuthenticationParams', async function () {
+            const strategy = new MockHmacAuthStrategy();
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: TEST_URI,
+                hmacAuthStrategy: strategy,
+            });
+            (0, nock_1.default)(TEST_URI)
+                .post('/api/auth/v1/session')
+                .reply(200, { access_token: TEST_TOKEN, user: { username: 'test@test.com' } }, {
+                hmac: 'resp-hmac',
+                timestamp: Date.now().toString(),
+            });
+            await bitgo.authenticate({
+                username: 'test@test.com',
+                password: 'mypassword',
+            });
+            strategy.calculateHMACCalls.length.should.be.greaterThan(0);
+            const hmacCall = strategy.calculateHMACCalls[0];
+            hmacCall.key.should.equal('test@test.com');
+            hmacCall.message.should.equal('mypassword');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hmacStrategy.js","sourceRoot":"","sources":["../../../test/unit/hmacStrategy.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport nock from 'nock';\nimport { BitGoAPI } from '../../src/bitgoAPI';\nimport type {\n  IHmacAuthStrategy,\n  CalculateRequestHeadersOptions,\n  RequestHeaders,\n  VerifyResponseOptions,\n  VerifyResponseInfo,\n} from '@bitgo/sdk-hmac';\nimport assert from 'node:assert';\n\nconst TEST_TOKEN = 'v2x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefab';\nconst TEST_URI = 'https://app.example.local';\n\n/**\n * Mock strategy that records calls and returns predictable values.\n */\nclass MockHmacAuthStrategy implements IHmacAuthStrategy {\n  public calculateRequestHeadersCalls: CalculateRequestHeadersOptions[] = [];\n  public verifyResponseCalls: VerifyResponseOptions[] = [];\n  public calculateHMACCalls: Array<{ key: string; message: string }> = [];\n\n  async calculateRequestHeaders(params: CalculateRequestHeadersOptions): Promise<RequestHeaders> {\n    this.calculateRequestHeadersCalls.push(params);\n    return {\n      hmac: 'mock-hmac-value',\n      timestamp: 1672531200000,\n      tokenHash: 'mock-token-hash',\n    };\n  }\n\n  async verifyResponse(params: VerifyResponseOptions): Promise<VerifyResponseInfo> {\n    this.verifyResponseCalls.push(params);\n    return {\n      isValid: true,\n      expectedHmac: 'mock-hmac-value',\n      signatureSubject: 'mock-subject',\n      isInResponseValidityWindow: true,\n      verificationTime: Date.now(),\n    };\n  }\n\n  async calculateHMAC(key: string, message: string): Promise<string> {\n    this.calculateHMACCalls.push({ key, message });\n    return 'mock-hmac-password';\n  }\n}\n\ndescribe('BitGoAPI HMAC Strategy Injection', function () {\n  afterEach(function () {\n    nock.cleanAll();\n  });\n\n  describe('constructor', function () {\n    it('should accept a custom hmacAuthStrategy', function () {\n      const strategy = new MockHmacAuthStrategy();\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: TEST_URI,\n        hmacAuthStrategy: strategy,\n      });\n\n      bitgo.should.be.ok();\n    });\n\n    it('should default to DefaultHmacAuthStrategy when none is provided', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: TEST_URI,\n      });\n\n      bitgo.should.be.ok();\n    });\n  });\n\n  describe('request signing via strategy', function () {\n    it('should use the custom strategy for HMAC header calculation', async function () {\n      const strategy = new MockHmacAuthStrategy();\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: TEST_URI,\n        accessToken: TEST_TOKEN,\n        hmacAuthStrategy: strategy,\n      });\n\n      const scope = nock(TEST_URI)\n        .get('/api/v2/wallet')\n        .matchHeader('HMAC', 'mock-hmac-value')\n        .matchHeader('Authorization', 'Bearer mock-token-hash')\n        .matchHeader('Auth-Timestamp', '1672531200000')\n        .reply(\n          200,\n          { wallets: [] },\n          {\n            hmac: 'response-hmac',\n            timestamp: Date.now().toString(),\n          }\n        );\n\n      await bitgo.get(bitgo.url('/wallet', 2)).result();\n\n      strategy.calculateRequestHeadersCalls.length.should.equal(1);\n      const call = strategy.calculateRequestHeadersCalls[0];\n      call.token.should.equal(TEST_TOKEN);\n      call.method.should.equal('get');\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should use the custom strategy for response verification', async function () {\n      const strategy = new MockHmacAuthStrategy();\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: TEST_URI,\n        accessToken: TEST_TOKEN,\n        hmacAuthStrategy: strategy,\n      });\n\n      nock(TEST_URI).get('/api/v2/wallet').reply(\n        200,\n        { wallets: [] },\n        {\n          hmac: 'server-response-hmac',\n          timestamp: Date.now().toString(),\n        }\n      );\n\n      await bitgo.get(bitgo.url('/wallet', 2)).result();\n\n      strategy.verifyResponseCalls.length.should.equal(1);\n      const call = strategy.verifyResponseCalls[0];\n      call.hmac.should.equal('server-response-hmac');\n      assert(call.statusCode, 'statusCode is required');\n      call.statusCode.should.equal(200);\n    });\n  });\n\n  describe('password HMAC via strategy', function () {\n    it('should use the custom strategy for password hashing in preprocessAuthenticationParams', async function () {\n      const strategy = new MockHmacAuthStrategy();\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: TEST_URI,\n        hmacAuthStrategy: strategy,\n      });\n\n      nock(TEST_URI)\n        .post('/api/auth/v1/session')\n        .reply(\n          200,\n          { access_token: TEST_TOKEN, user: { username: 'test@test.com' } },\n          {\n            hmac: 'resp-hmac',\n            timestamp: Date.now().toString(),\n          }\n        );\n\n      await bitgo.authenticate({\n        username: 'test@test.com',\n        password: 'mypassword',\n      });\n\n      strategy.calculateHMACCalls.length.should.be.greaterThan(0);\n      const hmacCall = strategy.calculateHMACCalls[0];\n      hmacCall.key.should.equal('test@test.com');\n      hmacCall.message.should.equal('mypassword');\n    });\n  });\n});\n"]}