@unito/integration-sdk 2.3.13 → 2.3.15

package/dist/test/resources/provider.test.js

@@ -1,5 +1,8 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
+import { Readable } from 'stream';
+import nock from 'nock';
+import https from 'https';
 import { Provider } from '../../src/resources/provider.js';
 import * as HttpErrors from '../../src/httpErrors.js';
 import Logger from '../../src/resources/logger.js';
@@ -21,6 +24,21 @@ describe('Provider', () => {
         },
     });
     const logger = new Logger();
+    // Helper to spy on https.request and capture options
+    const spyOnHttpsRequest = () => {
+        let capturedOptions;
+        const originalRequest = https.request;
+        https.request = function (options, callback) {
+            capturedOptions = options;
+            return originalRequest.call(https, options, callback);
+        };
+        return {
+            getCapturedOptions: () => capturedOptions,
+            restore: () => {
+                https.request = originalRequest;
+            },
+        };
+    };
     it('get', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
@@ -29,7 +47,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         });
@@ -58,7 +76,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'text/html; charset=UTF-8' },
         });
@@ -87,7 +105,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'application/schema+json; charset=UTF-8' },
         });
@@ -116,7 +134,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'application/swagger+json; charset=UTF-8' },
         });
@@ -145,7 +163,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         });
@@ -174,7 +192,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.streamingGet('/endpoint/123', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: {
                 Accept: 'application/json',
@@ -193,7 +211,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('https://my-cdn.my-domain.com/file.png', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
         });
         assert.equal(fetchMock.mock.calls.length, 1);
@@ -220,7 +238,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
         });
         assert.equal(fetchMock.mock.calls.length, 1);
@@ -249,7 +267,7 @@ describe('Provider', () => {
             data: 'createdItemInfo',
         }, {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'Content-Type': 'application/x-www-form-urlencoded', 'X-Additional-Header': 'value1' },
         });
@@ -282,7 +300,7 @@ describe('Provider', () => {
             { data: '3', data2: '4' },
         ], {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'Content-Type': 'application/json-patch+json', 'X-Additional-Header': 'value1' },
         });
@@ -315,7 +333,7 @@ describe('Provider', () => {
             data: 'updatedItemInfo',
         }, {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/json' },
         });
@@ -347,7 +365,7 @@ describe('Provider', () => {
         // What matters is that the body of put is a buffer
         const actualResponse = await provider.putBuffer('endpoint/123', buffer, {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/octet-stream' },
         });
@@ -379,7 +397,7 @@ describe('Provider', () => {
             data: 'updatedItemInfo',
         }, {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             queryParams: { param1: 'value1', param2: 'value2' },
             additionnalheaders: { 'X-Additional-Header': 'value1' },
@@ -410,7 +428,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.delete('/endpoint/123', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         });
@@ -440,7 +458,7 @@ describe('Provider', () => {
         const requestBody = { webhookIds: [1, 2, 3] };
         const actualResponse = await provider.delete('/webhook', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         }, requestBody);
@@ -483,7 +501,7 @@ describe('Provider', () => {
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         };
@@ -529,7 +547,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         };
@@ -570,7 +588,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         };
@@ -606,7 +624,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
             additionnalheaders: { 'X-Additional-Header': 'value1' },
         };
@@ -628,7 +646,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.get('/endpoint/123', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
         });
         assert.ok(providerResponse);
@@ -642,7 +660,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.get('/endpoint/123', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
         });
         assert.ok(providerResponse);
@@ -656,7 +674,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.streamingGet('/endpoint/123', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
         });
         assert.ok(providerResponse);
@@ -670,7 +688,7 @@ describe('Provider', () => {
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.post('/endpoint/123', {}, {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-            logger: logger,
+            logger,
             signal: new AbortController().signal,
         });
         assert.ok(providerResponse);
@@ -688,7 +706,7 @@ describe('Provider', () => {
         try {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-                logger: logger,
+                logger,
                 signal: new AbortController().signal,
             });
         }
@@ -708,7 +726,7 @@ describe('Provider', () => {
         try {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-                logger: logger,
+                logger,
                 signal: new AbortController().signal,
             });
         }
@@ -728,7 +746,7 @@ describe('Provider', () => {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
                 signal: new AbortController().signal,
-                logger: logger,
+                logger,
             });
         }
         catch (e) {
@@ -748,7 +766,7 @@ describe('Provider', () => {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
                 signal: new AbortController().signal,
-                logger: logger,
+                logger,
             });
         }
         catch (e) {
@@ -768,7 +786,7 @@ describe('Provider', () => {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
                 signal: new AbortController().signal,
-                logger: logger,
+                logger,
             });
         }
         catch (e) {
@@ -786,7 +804,7 @@ describe('Provider', () => {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
                 signal: new AbortController().signal,
-                logger: logger,
+                logger,
             });
         }
         catch (e) {
@@ -810,7 +828,7 @@ describe('Provider', () => {
             await provider.get('/endpoint/123', {
                 credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
                 signal: new AbortController().signal,
-                logger: logger,
+                logger,
             });
         }
         catch (e) {
@@ -826,9 +844,325 @@ describe('Provider', () => {
         await provider.get('/endpoint/123', {
             credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
             signal: new AbortController().signal,
-            logger: logger,
+            logger,
         });
         assert.equal(loggerStub.mock.callCount(), 1);
         assert.match(String(loggerStub.mock.calls[0]?.arguments[0]), /Connector API Request GET www.myApi.com\/endpoint\/123 201 - \d+ ms/);
     });
+    // Stream upload will not load the data in memory and sending a binary in the body
+    it('postStream streams data without buffering', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.${requestOptions.credentials.domain ?? 'myApi.com'}`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const testData = 'test binary data for streaming';
+        const stream = Readable.from([testData]);
+        const scope = nock('https://www.myApi.com')
+            .post('/upload', testData)
+            .matchHeader('content-type', 'application/octet-stream')
+            .matchHeader('accept', 'application/json')
+            .matchHeader('x-custom-provider-header', 'value')
+            .matchHeader('x-provider-credential-header', 'apikey#1111')
+            .reply(201, { success: true, id: '12345' });
+        const response = await streamProvider.postStream('/upload', stream, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+        });
+        assert.ok(scope.isDone(), 'HTTPS request should have been made');
+        assert.equal(response.status, 201);
+        assert.deepEqual(response.body, { success: true, id: '12345' });
+    });
+    it('postStream with query params', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const testData = 'data with params';
+        const stream = Readable.from([testData]);
+        const scope = nock('https://www.myApi.com')
+            .post('/upload?key=value&format=json', testData)
+            .reply(200, { uploaded: true });
+        const response = await streamProvider.postStream('/upload', stream, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+            queryParams: { key: 'value', format: 'json' },
+        });
+        assert.ok(scope.isDone());
+        assert.equal(response.status, 200);
+        assert.deepEqual(response.body, { uploaded: true });
+    });
+    it('postStream handles error responses', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const stream = Readable.from(['error test data']);
+        nock('https://www.myApi.com').post('/upload').reply(400, 'Bad request error');
+        let error;
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.BadRequestError);
+        assert.equal(error.message, 'Bad request error');
+    });
+    it('postStream with rate limiter', async () => {
+        let rateLimiterCalled = false;
+        let rateLimiterCredentials;
+        const mockRateLimiter = async (options, request) => {
+            rateLimiterCalled = true;
+            rateLimiterCredentials = options.credentials;
+            return request();
+        };
+        const rateLimitedProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+            rateLimiter: mockRateLimiter,
+        });
+        const testData = 'rate limited data';
+        const stream = Readable.from([testData]);
+        nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+        await rateLimitedProvider.postStream('/upload', stream, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+        });
+        assert.ok(rateLimiterCalled, 'Rate limiter should have been called');
+        assert.deepEqual(rateLimiterCredentials, {
+            apiKey: 'apikey#1111',
+            unitoCredentialId: '123',
+        });
+    });
+    it('postStream sets timeout to 0 (no timeout)', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const testData = 'timeout test data';
+        const stream = Readable.from([testData]);
+        const spy = spyOnHttpsRequest();
+        const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+            });
+            assert.ok(scope.isDone());
+            assert.equal(spy.getCapturedOptions().timeout, 0, 'Timeout should be set to 0 (no timeout)');
+        }
+        finally {
+            spy.restore();
+        }
+    });
+    it('postStream handles AbortSignal for request cancellation', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const stream = Readable.from(['abort signal test']);
+        const abortController = new AbortController();
+        // Simulate aborting the request immediately
+        abortController.abort();
+        let error;
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postStream handles AbortSignal timeout during request', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const stream = Readable.from(['timeout during request test']);
+        const abortController = new AbortController();
+        // Delay response to simulate a slow server
+        nock('https://www.myApi.com').post('/upload').delayConnection(100).reply(201, { success: true });
+        // Abort after 50ms
+        setTimeout(() => abortController.abort(), 50);
+        let error;
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postStream cleans up AbortSignal listener on success', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const testData = 'cleanup test';
+        const stream = Readable.from([testData]);
+        const abortController = new AbortController();
+        const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+        const response = await streamProvider.postStream('/upload', stream, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+            signal: abortController.signal,
+        });
+        assert.ok(scope.isDone());
+        assert.equal(response.status, 201);
+        // Verify the listener was removed by checking that aborting after completion
+        // doesn't cause any side effects (if listener wasn't removed, this could cause issues)
+        assert.doesNotThrow(() => {
+            abortController.abort();
+        }, 'Aborting after completion should not throw or cause issues');
+        // Verify the signal is indeed aborted
+        assert.ok(abortController.signal.aborted, 'Signal should be aborted');
+    });
+    it('postForm handles AbortSignal for request cancellation', async () => {
+        const FormData = (await import('form-data')).default;
+        const formProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const form = new FormData();
+        form.append('field1', 'value1');
+        form.append('field2', 'value2');
+        const abortController = new AbortController();
+        // Simulate aborting the request immediately
+        abortController.abort();
+        let error;
+        try {
+            await formProvider.postForm('/upload-form', form, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postForm handles AbortSignal timeout during request', async () => {
+        const FormData = (await import('form-data')).default;
+        const formProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const form = new FormData();
+        form.append('field1', 'value1');
+        const abortController = new AbortController();
+        // Mock a delayed response
+        nock('https://www.myApi.com').post('/upload-form').delayConnection(100).reply(201, { success: true, id: '12345' });
+        // Abort after 50ms
+        setTimeout(() => abortController.abort(), 50);
+        let error;
+        try {
+            await formProvider.postForm('/upload-form', form, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postForm successfully completes with AbortSignal provided', async () => {
+        const FormData = (await import('form-data')).default;
+        const formProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const form = new FormData();
+        form.append('field1', 'value1');
+        form.append('field2', 'value2');
+        const abortController = new AbortController();
+        const scope = nock('https://www.myApi.com').post('/upload-form').reply(201, { success: true, id: '12345' });
+        const response = await formProvider.postForm('/upload-form', form, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+            signal: abortController.signal,
+        });
+        assert.ok(scope.isDone());
+        assert.equal(response.status, 201);
+        assert.deepEqual(response.body, { success: true, id: '12345' });
+        // Verify the listener was removed by checking that aborting after completion
+        // doesn't cause any side effects
+        assert.doesNotThrow(() => {
+            abortController.abort();
+        }, 'Aborting after completion should not throw or cause issues');
+        // Verify the signal is indeed aborted
+        assert.ok(abortController.signal.aborted, 'Signal should be aborted');
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.3.13",
+  "version": "2.3.15",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",
@@ -44,6 +44,7 @@
     "@typescript-eslint/eslint-plugin": "7.x",
     "@typescript-eslint/parser": "7.x",
     "eslint": "8.x",
+    "nock": "14.x",
     "nodemon": "3.x",
     "prettier": "3.x",
     "rollup": "4.x",