@unito/integration-sdk 2.3.14 → 2.4.0

package/test/resources/provider.test.ts

@@ -2,6 +2,7 @@ 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';
@@ -28,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,
@@ -1132,4 +1151,254 @@ describe('Provider', () => {
       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');
+  });
 });