@unito/integration-sdk 2.3.13 → 2.3.15

package/test/resources/provider.test.ts

@@ -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';
@@ -26,6 +29,24 @@ describe('Provider', () => {
 
   const logger = new Logger();
 
+  // Helper to spy on https.request and capture options
+  const spyOnHttpsRequest = (): { getCapturedOptions: () => any; restore: () => void } => {
+    let capturedOptions: any;
+    const originalRequest = https.request;
+
+    (https as any).request = function (options: any, callback: any) {
+      capturedOptions = options;
+      return originalRequest.call(https, options, callback);
+    };
+
+    return {
+      getCapturedOptions: () => capturedOptions,
+      restore: () => {
+        (https as any).request = originalRequest;
+      },
+    };
+  };
+
   it('get', async context => {
     const response = new Response('{"data": "value"}', {
       status: 200,
@@ -36,7 +57,7 @@ describe('Provider', () => {
 
     const actualResponse = await provider.get('/endpoint', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: { 'X-Additional-Header': 'value1' },
     });
@@ -69,7 +90,7 @@ describe('Provider', () => {
 
     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' },
     });
@@ -104,7 +125,7 @@ describe('Provider', () => {
 
     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' },
     });
@@ -139,7 +160,7 @@ describe('Provider', () => {
 
     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' },
     });
@@ -174,7 +195,7 @@ describe('Provider', () => {
 
     const actualResponse = await provider.get('/endpoint', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: { 'X-Additional-Header': 'value1' },
     });
@@ -209,7 +230,7 @@ describe('Provider', () => {
 
     const providerResponse = await provider.streamingGet('/endpoint/123', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: {
         Accept: 'application/json',
@@ -232,7 +253,7 @@ describe('Provider', () => {
 
     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,
     });
 
@@ -263,7 +284,7 @@ describe('Provider', () => {
 
     const actualResponse = await provider.get('', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
     });
 
@@ -299,7 +320,7 @@ describe('Provider', () => {
       },
       {
         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' },
       },
@@ -340,7 +361,7 @@ describe('Provider', () => {
       ],
       {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
         additionnalheaders: { 'Content-Type': 'application/json-patch+json', 'X-Additional-Header': 'value1' },
       },
@@ -381,7 +402,7 @@ describe('Provider', () => {
       },
       {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
         additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/json' },
       },
@@ -419,7 +440,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' },
     });
@@ -458,7 +479,7 @@ describe('Provider', () => {
       },
       {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
         queryParams: { param1: 'value1', param2: 'value2' },
         additionnalheaders: { 'X-Additional-Header': 'value1' },
@@ -494,7 +515,7 @@ describe('Provider', () => {
 
     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' },
     });
@@ -530,7 +551,7 @@ describe('Provider', () => {
       '/webhook',
       {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
         additionnalheaders: { 'X-Additional-Header': 'value1' },
       },
@@ -581,7 +602,7 @@ describe('Provider', () => {
 
     const options = {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: { 'X-Additional-Header': 'value1' },
     };
@@ -634,7 +655,7 @@ describe('Provider', () => {
 
     const options = {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: { 'X-Additional-Header': 'value1' },
     };
@@ -681,7 +702,7 @@ describe('Provider', () => {
 
     const options = {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: { 'X-Additional-Header': 'value1' },
     };
@@ -722,7 +743,7 @@ describe('Provider', () => {
 
     const options = {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
       additionnalheaders: { 'X-Additional-Header': 'value1' },
     };
@@ -748,7 +769,7 @@ describe('Provider', () => {
 
     const providerResponse = await provider.get<{ validJson: boolean }>('/endpoint/123', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
     });
 
@@ -766,7 +787,7 @@ describe('Provider', () => {
 
     const providerResponse = await provider.get<{ validJson: boolean }>('/endpoint/123', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
     });
 
@@ -784,7 +805,7 @@ describe('Provider', () => {
 
     const providerResponse = await provider.streamingGet('/endpoint/123', {
       credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-      logger: logger,
+      logger,
       signal: new AbortController().signal,
     });
 
@@ -805,7 +826,7 @@ describe('Provider', () => {
       {},
       {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
       },
     );
@@ -829,7 +850,7 @@ describe('Provider', () => {
     try {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
       });
     } catch (e) {
@@ -853,7 +874,7 @@ describe('Provider', () => {
     try {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
-        logger: logger,
+        logger,
         signal: new AbortController().signal,
       });
     } catch (e) {
@@ -877,7 +898,7 @@ describe('Provider', () => {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
         signal: new AbortController().signal,
-        logger: logger,
+        logger,
       });
     } catch (e) {
       error = e;
@@ -900,7 +921,7 @@ describe('Provider', () => {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
         signal: new AbortController().signal,
-        logger: logger,
+        logger,
       });
     } catch (e) {
       error = e;
@@ -923,7 +944,7 @@ describe('Provider', () => {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
         signal: new AbortController().signal,
-        logger: logger,
+        logger,
       });
     } catch (e) {
       error = e;
@@ -944,7 +965,7 @@ describe('Provider', () => {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
         signal: new AbortController().signal,
-        logger: logger,
+        logger,
       });
     } catch (e) {
       error = e;
@@ -972,7 +993,7 @@ describe('Provider', () => {
       await provider.get('/endpoint/123', {
         credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
         signal: new AbortController().signal,
-        logger: logger,
+        logger,
       });
     } catch (e) {
       error = e;
@@ -992,7 +1013,7 @@ 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);
@@ -1001,4 +1022,383 @@ describe('Provider', () => {
       /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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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: any, request: () => Promise<any>) => {
+      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 as string,
+        },
+      }),
+      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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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 as string,
+        },
+      }),
+    });
+
+    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');
+  });
 });