@tetrascience-npm/ts-connectors-sdk 3.1.0

package/dist/test/tdp-client.test.js

@@ -0,0 +1,1204 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("aws-sdk-client-mock-jest");
+const s3 = __importStar(require("@aws-sdk/client-s3"));
+const sqs = __importStar(require("@aws-sdk/client-sqs"));
+const ssm = __importStar(require("@aws-sdk/client-ssm"));
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const aws_sdk_client_mock_1 = require("aws-sdk-client-mock");
+const axios_1 = __importDefault(require("axios"));
+const ts_lib_shared_schema_1 = require("ts-lib-shared-schema");
+const uuid_1 = require("uuid");
+const manifest = __importStar(require("../src/manifest"));
+const src_1 = require("../src");
+const sqsClientMock = (0, aws_sdk_client_mock_1.mockClient)(sqs.SQSClient);
+const s3ClientMock = (0, aws_sdk_client_mock_1.mockClient)(s3.S3Client);
+const ssmClientMock = (0, aws_sdk_client_mock_1.mockClient)(ssm.SSMClient);
+const mockUploadFileRequestSchemaParse = jest.fn();
+jest.mock('axios');
+jest.mock('../src/schemas', () => ({
+    UploadFileRequestSchema: {
+        parse: (...args) => mockUploadFileRequestSchemaParse(...args),
+    },
+}));
+const mockUploadDone = jest.fn().mockResolvedValue({ versionId: 'someVersion' });
+jest.mock('@aws-sdk/lib-storage', () => ({
+    Upload: jest.fn().mockImplementation(() => ({
+        done: mockUploadDone,
+    })),
+}));
+describe('TDPClient', () => {
+    const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+    beforeEach(() => {
+        sqsClientMock.reset();
+        s3ClientMock.reset();
+        mockUploadFileRequestSchemaParse.mockReset();
+        axiosCreateSpy.mockReset();
+        axiosCreateSpy.mockImplementation(() => {
+            return {
+                defaults: { headers: { common: {} } },
+                request: jest.fn().mockImplementation((request) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (request.url == '/v1/data-acquisition/connectors/some-target-id')
+                        return {
+                            data: {
+                                artifact: {
+                                    namespace: 'test-namespace',
+                                    slug: 'test-slug',
+                                    version: 'v1.0.0',
+                                },
+                            },
+                        };
+                    if (request.url == '/v1/certificates?includeContent=true&includeDisabled=false') {
+                        console.log('returning empty array');
+                        return [];
+                    }
+                    return { data: {} };
+                })),
+            };
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('constructor', () => {
+        it('should be able to create TDP client', () => {
+            const tdpClient = new src_1.TDPClient();
+            expect(tdpClient).not.toBeNull();
+        });
+    });
+    describe('init', () => {
+        const envBackup = process.env;
+        beforeEach(() => {
+            process.env = Object.assign({}, envBackup);
+            sqsClientMock.reset();
+            ssmClientMock.reset();
+            sqsClientMock.on(sqs.ReceiveMessageCommand).resolves({ Messages: [] });
+            ssmClientMock.on(ssm.GetParameterCommand).resolves({ Parameter: { Value: 'jwt-secret' } });
+        });
+        it('should initialize AWSRefreshClientProvider and UserSuppliedAuthTokenProvider when CONNECTOR_TOKEN is set', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.CONNECTOR_TOKEN = 'test-connector-token';
+            process.env.SKIP_CLOUDWATCH = 'true';
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'test-org',
+                awsRegion: 'us-west-2',
+                connectorId: 'test-connector-id',
+                tdpEndpoint: 'https://tdp.example.com',
+            });
+            const createProxyNodeHttpHandlerSpy = jest
+                .spyOn(tdpClient, 'createProxyNodeHttpHandler')
+                .mockReturnValue(new node_http_handler_1.NodeHttpHandler());
+            yield tdpClient.init();
+            expect(createProxyNodeHttpHandlerSpy).toHaveBeenCalled();
+            expect(tdpClient['awsClientProvider']).toBeInstanceOf(src_1.AwsRefreshClientProvider);
+            expect(tdpClient['authTokenProvider']).toBeInstanceOf(src_1.UserSuppliedAuthTokenProvider);
+            expect(tdpClient['authTokenProvider']).toEqual(expect.objectContaining({
+                token: 'test-connector-token',
+            }));
+        }));
+        it('should verify TLS by default', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const tdpClient = new src_1.TDPClient();
+            jest.spyOn(tdpClient, 'createProxyAgentsForBaseUrl');
+            // act
+            yield tdpClient.init();
+            // assert
+            expect(tdpClient.createProxyAgentsForBaseUrl).toHaveBeenCalledWith(expect.objectContaining({
+                rejectUnauthorized: true,
+            }));
+        }));
+        it('should ignore TLS errors if overridden by env variables', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const tdpClient = new src_1.TDPClient();
+            jest.spyOn(tdpClient, 'createProxyAgentsForBaseUrl');
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            // act
+            yield tdpClient.init();
+            // assert
+            expect(tdpClient.createProxyAgentsForBaseUrl).toHaveBeenCalledWith(expect.objectContaining({
+                rejectUnauthorized: false,
+            }));
+        }));
+        it('should create patched https agent by default', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const tdpClient = new src_1.TDPClient({
+                tdpEndpoint: 'https://tdp.com',
+            });
+            jest.spyOn(tdpClient, 'createProxyAgentsForBaseUrl');
+            process.env.HTTP_PROXY = 'http://some-proxy:8080';
+            process.env.HTTPS_PROXY = 'http://some-proxy:8080';
+            // act
+            yield tdpClient.init();
+            // assert
+            expect(tdpClient.createProxyAgentsForBaseUrl).toHaveReturnedWith(expect.objectContaining({
+                httpsAgent: expect.not.objectContaining({
+                    // this fields is present in hpagent but not ir https-proxy-agent agent
+                    proxyRequestOptions: expect.any(Object),
+                }),
+            }));
+        }));
+        it('should create hpagent https agent if overridden', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const tdpClient = new src_1.TDPClient({
+                tdpEndpoint: 'https://tdp.com',
+            });
+            jest.spyOn(tdpClient, 'createProxyAgentsForBaseUrl');
+            process.env.HTTP_PROXY = 'http://some-proxy:8080';
+            process.env.HTTPS_PROXY = 'http://some-proxy:8080';
+            process.env.HTTPS_AGENT = 'hpagent';
+            // act
+            yield tdpClient.init();
+            // assert
+            expect(tdpClient.createProxyAgentsForBaseUrl).toHaveReturnedWith(expect.objectContaining({
+                httpsAgent: expect.objectContaining({
+                    // this fields is present in hpagent
+                    proxyRequestOptions: expect.any(Object),
+                }),
+            }));
+        }));
+        it('should override http request timeout from envvar', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.HTTP_REQUEST_TIMEOUT_MS = '1234';
+            const tdpClient = new src_1.TDPClient();
+            expect(tdpClient.config.httpRequestTimeout).toEqual(1234);
+        }));
+        it('should ignore http request timeout envvar if not valid number', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.HTTP_REQUEST_TIMEOUT_MS = 'not a number';
+            const tdpClient = new src_1.TDPClient();
+            expect(tdpClient.config.httpRequestTimeout).toEqual(10000);
+        }));
+        it('should override http request timeout from options', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.HTTP_REQUEST_TIMEOUT_MS = '1234';
+            const tdpClient = new src_1.TDPClient({ httpRequestTimeout: 5678 });
+            expect(tdpClient.config.httpRequestTimeout).toEqual(5678);
+        }));
+        it('should call createAxiosInstance with timeout settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+            const tdpClient = new src_1.TDPClient({ httpRequestTimeout: 5678 });
+            yield tdpClient.init();
+            // act
+            tdpClient.createAxiosInstance({ baseUrl: 'https://example.com', includeAdditionalCertificates: false });
+            // assert
+            expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ timeout: 5678 }));
+        }));
+        it('should call createAxiosInstanceWithCertificatesAndHeaders with timeout settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+            const tdpClient = new src_1.TDPClient({ httpRequestTimeout: 9876 });
+            yield tdpClient.init();
+            tdpClient.createProxyAgentsForBaseUrl = jest.fn().mockReturnValue({});
+            // act
+            tdpClient.createAxiosInstanceWithCertificatesAndHeaders('https://example.com', 'orgSlug', 'jwt', []);
+            // assert
+            expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ timeout: 9876 }));
+        }));
+    });
+    describe('commands', () => {
+        it("should process commands that aren't expired", () => __awaiter(void 0, void 0, void 0, function* () {
+            const commandBody = {
+                commandId: 'some-command-id',
+                targetId: 'some-target-id',
+                status: src_1.CommandStatus.REJECTED,
+                createdAt: new Date('2023-01-01T00:00:00Z'),
+                expiresAt: new Date(),
+                action: 'Some.Command.Action',
+                body: {},
+            };
+            commandBody.expiresAt.setDate(commandBody.expiresAt.getDate() + 1);
+            sqsClientMock
+                .on(sqs.ReceiveMessageCommand)
+                .callsFakeOnce(() => {
+                return {
+                    Messages: [
+                        {
+                            MessageId: 'some-message-id',
+                            ReceiptHandle: 'some-receipt-handle',
+                            Body: JSON.stringify(commandBody),
+                        },
+                    ],
+                };
+            })
+                .callsFake(() => {
+                return { Messages: [] };
+            });
+            let resolveSendResponsePromise;
+            const sendResponsePromise = new Promise((resolve) => (resolveSendResponsePromise = resolve));
+            sqsClientMock.on(sqs.SendMessageCommand).callsFakeOnce((command) => {
+                expect(command.QueueUrl).toBe(undefined);
+                const body = JSON.parse(command.MessageBody);
+                expect(body.commandId).toBe(commandBody.commandId);
+                expect(body.status).toBe(src_1.CommandStatus.PROCESSING);
+                expect(body.targetId).toBe(commandBody.targetId);
+                expect(body.createdAt).not.toBeFalsy();
+                resolveSendResponsePromise();
+            });
+            let resolveDeleteMessagePromise;
+            const deleteMessagePromise = new Promise((resolve) => (resolveDeleteMessagePromise = resolve));
+            sqsClientMock.on(sqs.DeleteMessageCommand).callsFakeOnce((command) => {
+                expect(command.ReceiptHandle).toBe('some-receipt-handle');
+                resolveDeleteMessagePromise();
+            });
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            const commandListener = jest.fn();
+            tdpClient.commands.addListener('command', commandListener);
+            const actionListener = jest.fn();
+            tdpClient.commands.addListener('Some.Command.Action', actionListener);
+            yield tdpClient.init();
+            tdpClient.startCommandsListener();
+            yield sendResponsePromise;
+            yield deleteMessagePromise;
+            tdpClient.stopCommandsListener();
+            expect(sqsClientMock).toReceiveCommandTimes(sqs.SendMessageCommand, 1);
+            expect(sqsClientMock).toReceiveCommandTimes(sqs.DeleteMessageCommand, 1);
+            // Round trip through JSON converts the dates to strings, which matches what happens in real execution
+            expect(commandListener).toHaveBeenCalledWith(expect.objectContaining(JSON.parse(JSON.stringify(commandBody))));
+            expect(actionListener).toHaveBeenCalledWith(expect.objectContaining(JSON.parse(JSON.stringify(commandBody))));
+        }));
+        it('should reject expired commands', () => __awaiter(void 0, void 0, void 0, function* () {
+            const commandBody = {
+                commandId: 'some-command-id',
+                targetId: 'some-target-id',
+                status: src_1.CommandStatus.REJECTED,
+                createdAt: new Date('2023-01-01T00:00:00Z'),
+                expiresAt: new Date('2023-01-02T00:00:00Z'),
+                action: 'Some.Command.Action',
+                body: {},
+            };
+            sqsClientMock
+                .on(sqs.ReceiveMessageCommand)
+                .callsFakeOnce(() => {
+                return {
+                    Messages: [
+                        {
+                            MessageId: 'some-message-id',
+                            ReceiptHandle: 'some-receipt-handle',
+                            Body: JSON.stringify(commandBody),
+                        },
+                    ],
+                };
+            })
+                .callsFake(() => {
+                return { Messages: [] };
+            });
+            let resolveSendResponsePromise;
+            const sendResponsePromise = new Promise((resolve) => (resolveSendResponsePromise = resolve));
+            sqsClientMock.on(sqs.SendMessageCommand).callsFakeOnce((command) => {
+                expect(command.QueueUrl).toBe(undefined);
+                const body = JSON.parse(command.MessageBody);
+                expect(body.commandId).toBe(commandBody.commandId);
+                expect(body.status).toBe(src_1.CommandStatus.REJECTED);
+                expect(body.targetId).toBe(commandBody.targetId);
+                expect(body.createdAt).not.toBeFalsy();
+                resolveSendResponsePromise();
+            });
+            let resolveDeleteMessagePromise;
+            const deleteMessagePromise = new Promise((resolve) => (resolveDeleteMessagePromise = resolve));
+            sqsClientMock.on(sqs.DeleteMessageCommand).callsFakeOnce((command) => {
+                expect(command.ReceiptHandle).toBe('some-receipt-handle');
+                resolveDeleteMessagePromise();
+            });
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            tdpClient.startCommandsListener();
+            yield sendResponsePromise;
+            yield deleteMessagePromise;
+            tdpClient.stopCommandsListener();
+            expect(sqsClientMock).toReceiveCommandTimes(sqs.SendMessageCommand, 1);
+            expect(sqsClientMock).toReceiveCommandTimes(sqs.DeleteMessageCommand, 1);
+        }));
+        it('should handle command with body delivered via url', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const bodyUrl = 'https://aws.s3/body-url.json';
+            const responseBodyUploadUrl = 'https://aws.s3/response-body-url.json';
+            const commandBody = {
+                commandId: 'some-command-id',
+                targetId: 'some-target-id',
+                createdAt: new Date('2023-01-01T00:00:00Z'),
+                expiresAt: new Date(),
+                action: 'Some.Command.Action',
+                bodyDelivery: 'referenced',
+                bodyUrl,
+                responseBodyUploadUrl,
+            };
+            commandBody.expiresAt.setDate(commandBody.expiresAt.getDate() + 1);
+            sqsClientMock
+                .on(sqs.ReceiveMessageCommand)
+                .callsFakeOnce(() => {
+                return {
+                    Messages: [
+                        {
+                            MessageId: 'some-message-id',
+                            ReceiptHandle: 'some-receipt-handle',
+                            Body: JSON.stringify(commandBody),
+                        },
+                    ],
+                };
+            })
+                .callsFake(() => {
+                return { Messages: [] };
+            });
+            let resolveSendResponsePromise;
+            const sendResponsePromise = new Promise((resolve) => (resolveSendResponsePromise = resolve));
+            sqsClientMock.on(sqs.SendMessageCommand).callsFakeOnce(() => resolveSendResponsePromise());
+            let resolveDeleteMessagePromise;
+            const deleteMessagePromise = new Promise((resolve) => (resolveDeleteMessagePromise = resolve));
+            sqsClientMock.on(sqs.DeleteMessageCommand).callsFakeOnce(() => resolveDeleteMessagePromise());
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            jest.spyOn(tdpClient, 'createAxiosInstance').mockImplementation(() => ({
+                get: jest.fn().mockResolvedValue({ data: { foo: 'bar' } }),
+                put: jest.fn().mockResolvedValue({}),
+            }));
+            const receiveCommandBody = new Promise((resolve) => {
+                tdpClient.commands.addListener('command', (command) => {
+                    resolve(command.body);
+                });
+            });
+            // act
+            yield tdpClient.init();
+            tdpClient.startCommandsListener();
+            yield sendResponsePromise;
+            yield deleteMessagePromise;
+            const receivedCommandBody = yield receiveCommandBody;
+            tdpClient.stopCommandsListener();
+            // assert
+            expect(receivedCommandBody).toEqual({ foo: 'bar' });
+        }));
+        it('should be able to respond to command via pre-signed url', () => __awaiter(void 0, void 0, void 0, function* () {
+            // arrange
+            const responseBodyUploadUrl = 'https://aws.s3/response-body-url.json';
+            const commandBody = {
+                commandId: 'some-command-id',
+                targetId: 'some-target-id',
+                createdAt: new Date('2023-01-01T00:00:00Z'),
+                expiresAt: new Date(),
+                action: 'Some.Command.Action',
+                bodyDelivery: 'embedded',
+                body: {},
+                responseBodyUploadUrl,
+            };
+            commandBody.expiresAt.setDate(commandBody.expiresAt.getDate() + 1);
+            sqsClientMock
+                .on(sqs.ReceiveMessageCommand)
+                .callsFakeOnce(() => {
+                return {
+                    Messages: [
+                        {
+                            MessageId: 'some-message-id',
+                            ReceiptHandle: 'some-receipt-handle',
+                            Body: JSON.stringify(commandBody),
+                        },
+                    ],
+                };
+            })
+                .callsFake(() => {
+                return { Messages: [] };
+            });
+            let resolveSendResponsePromise;
+            const sendResponsePromise = new Promise((resolve) => (resolveSendResponsePromise = resolve));
+            sqsClientMock.on(sqs.SendMessageCommand).callsFakeOnce(() => resolveSendResponsePromise());
+            let resolveDeleteMessagePromise;
+            const deleteMessagePromise = new Promise((resolve) => (resolveDeleteMessagePromise = resolve));
+            sqsClientMock.on(sqs.DeleteMessageCommand).callsFakeOnce(() => resolveDeleteMessagePromise());
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            const axiosPutMock = jest.fn().mockResolvedValue({});
+            jest.spyOn(tdpClient, 'createAxiosInstance').mockImplementation(() => ({
+                put: axiosPutMock,
+            }));
+            const receiveCommandBody = new Promise((resolve) => {
+                tdpClient.commands.addListener('command', (command) => {
+                    tdpClient.sendCommandResponse(Object.assign(Object.assign({}, command), { body: {
+                            // This will make command to be delivered via pre-signed url
+                            large: 'x'.repeat(300 * 1024),
+                        } }));
+                    resolve(command.body);
+                });
+            });
+            // act
+            yield tdpClient.init();
+            tdpClient.startCommandsListener();
+            yield sendResponsePromise;
+            yield deleteMessagePromise;
+            yield receiveCommandBody;
+            tdpClient.stopCommandsListener();
+            // assert
+            expect(axiosPutMock).toHaveBeenCalledWith('/response-body-url.json', expect.any(Buffer), {
+                headers: { 'Content-Encoding': 'gzip', 'Content-Type': 'application/json' },
+            });
+            expect(sqsClientMock).toReceiveCommandWith(sqs.SendMessageCommand, {
+                MessageBody: expect.stringContaining('"referenced"'),
+            });
+        }));
+    });
+    describe('calculatePartSize', () => {
+        let tdpClient;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+        });
+        const defaultSize = 1024 * 1024 * 5;
+        const maxParts = 10000;
+        it('returns default size when object size is undefined', () => {
+            expect(tdpClient.calculatePartSize()).toEqual(defaultSize);
+        });
+        it('returns default size when object size is negative', () => {
+            expect(tdpClient.calculatePartSize(1024 * 1024 * maxParts * -10)).toEqual(defaultSize);
+        });
+        it('returns default size when object size does not require bigger part', () => {
+            expect(tdpClient.calculatePartSize(1024 * 1024 * 5 * (maxParts - 1))).toEqual(defaultSize);
+        });
+        it('returns large enough part size to transfer big object within max number of parts', () => {
+            const objectSize = 1024 * 1024 * 6 * maxParts;
+            const partSize = tdpClient.calculatePartSize(objectSize);
+            expect(partSize * maxParts).toBeGreaterThanOrEqual(objectSize);
+        });
+        it('returns an integer value, whether default or otherwise', () => {
+            const sizeDefault = tdpClient.calculatePartSize();
+            const sizeNondefault = tdpClient.calculatePartSize(1024 * 1024 * 6 * maxParts);
+            expect(Number.isInteger(sizeDefault)).toBe(true);
+            expect(Number.isInteger(sizeNondefault)).toBe(true);
+        });
+    });
+    describe('uploadFile', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should set connector metadata', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            yield tdpClient.uploadFile({
+                content: '',
+                filepath: '/',
+            });
+            const uploadCallArguments = lib_storage_1.Upload.mock.calls[0][0];
+            const metadata = uploadCallArguments.params.Metadata;
+            expect(metadata[ts_lib_shared_schema_1.S3MetadataFields.CONNECTOR_NAMESPACE]).toEqual('test-namespace');
+            expect(metadata[ts_lib_shared_schema_1.S3MetadataFields.CONNECTOR_SLUG]).toEqual('test-slug');
+            expect(metadata[ts_lib_shared_schema_1.S3MetadataFields.CONNECTOR_VERSION]).toEqual('v1.0.0');
+            expect(mockUploadDone).toHaveBeenCalledTimes(1);
+        }));
+        it('should set content type and encoding when available', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            yield tdpClient.uploadFile({
+                content: '',
+                filepath: '/',
+                contentEncoding: 'gzip',
+                contentType: 'application/json',
+            });
+            const uploadCallArguments = lib_storage_1.Upload.mock.calls[0][0];
+            expect(uploadCallArguments.params.ContentType).toEqual('application/json');
+            expect(uploadCallArguments.params.ContentEncoding).toEqual('gzip');
+            expect(mockUploadDone).toHaveBeenCalledTimes(1);
+        }));
+        it('should fail when destinationId is present and is the empty string', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            expect.assertions(1);
+            try {
+                yield tdpClient.uploadFile({
+                    content: '',
+                    filepath: '/',
+                    destinationId: '',
+                });
+            }
+            catch (error) {
+                expect(error.message).toMatch('destinationId must be a valid UUID');
+            }
+        }));
+        it('should fail when destinationId is present and not a UUID at all', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            expect.assertions(1);
+            try {
+                yield tdpClient.uploadFile({
+                    content: '',
+                    filepath: '/',
+                    destinationId: 'not-a-uuid',
+                });
+            }
+            catch (error) {
+                expect(error.message).toMatch('destinationId must be a valid UUID');
+            }
+        }));
+        it('should fail when destinationId is present and is a non-v4 UUID', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            expect.assertions(1);
+            try {
+                yield tdpClient.uploadFile({
+                    content: '',
+                    filepath: '/',
+                    destinationId: (0, uuid_1.v1)(),
+                });
+            }
+            catch (error) {
+                expect(error.message).toMatch('destinationId must be a UUIDv4');
+            }
+        }));
+        it('should use a valid destinationId as part of file key when present', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectorId = 'some-target-id';
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId,
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            const destinationId = (0, uuid_1.v4)();
+            yield tdpClient.uploadFile({
+                content: '',
+                filepath: '/',
+                destinationId,
+                labels: [{ name: 'test-label', value: 'cool-value' }],
+            });
+            const uploadCallArguments = lib_storage_1.Upload.mock.calls[0][0];
+            expect(uploadCallArguments.params.Key).toMatch(destinationId);
+            expect(uploadCallArguments.params.Key).not.toMatch(connectorId);
+            expect(mockUploadDone).toHaveBeenCalledTimes(1);
+            // also check label file
+            expect(s3ClientMock).toHaveReceivedCommandWith(s3.PutObjectCommand, {
+                Key: expect.stringContaining(destinationId),
+            });
+            expect(s3ClientMock).not.toHaveReceivedCommandWith(s3.PutObjectCommand, {
+                Key: expect.stringContaining(connectorId),
+            });
+        }));
+        it('should not set content type or encoding when missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            yield tdpClient.uploadFile({
+                content: '',
+                filepath: '/',
+            });
+            const uploadCallArguments = lib_storage_1.Upload.mock.calls[0][0];
+            expect(uploadCallArguments.params.ContentType).toBeUndefined();
+            expect(uploadCallArguments.params.ContentEncoding).toBeUndefined();
+            expect(mockUploadDone).toHaveBeenCalledTimes(1);
+        }));
+        it('should set part size for Upload', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            yield tdpClient.uploadFile({
+                content: '',
+                filepath: '/',
+                contentEncoding: 'gzip',
+                contentType: 'application/json',
+            });
+            const uploadCallArguments = lib_storage_1.Upload.mock.calls[0][0];
+            expect(uploadCallArguments.partSize).toEqual(tdpClient.calculatePartSize());
+            expect(mockUploadDone).toHaveBeenCalledTimes(1);
+        }));
+        it('should pass abortController from request to Upload', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            const abortController = new AbortController();
+            yield tdpClient.uploadFile({
+                content: '',
+                filepath: '/',
+                contentEncoding: 'gzip',
+                contentType: 'application/json',
+                abortController,
+            });
+            const uploadCallArguments = lib_storage_1.Upload.mock.calls[0][0];
+            expect(uploadCallArguments.abortController).toEqual(abortController);
+            expect(mockUploadDone).toHaveBeenCalledTimes(1);
+        }));
+        it('should validate against zod schema, throwing if strictMtlValidation is true', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            mockUploadFileRequestSchemaParse.mockImplementation(() => {
+                throw new Error('');
+            });
+            yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+                return yield tdpClient.uploadFile({
+                    content: '',
+                    filepath: '/',
+                }, true);
+            })).rejects.toThrow();
+        }));
+        it('should not validate against zod schema, logging a warning if strictMtlValidation is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            yield tdpClient.init();
+            jest.spyOn(tdpClient.logger, 'warn');
+            mockUploadFileRequestSchemaParse.mockImplementation(() => {
+                throw new Error('');
+            });
+            expect(() => __awaiter(void 0, void 0, void 0, function* () {
+                return yield tdpClient.uploadFile({
+                    content: '',
+                    filepath: '/',
+                }, false);
+            })).not.toThrow();
+            expect(tdpClient.logger.warn).toHaveBeenCalledWith('Invalid MTL on upload file request', expect.objectContaining({}));
+        }));
+    });
+    describe('transform-trace-metadata', () => {
+        it('returns metadata with the ts_ prefix', () => {
+            const metadata = {
+                'some-key': 'some-value',
+                'some-other-key': 'some-other-value',
+            };
+            const testClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+            });
+            const transformedMetadata = testClient.transformTraceMetadata(metadata);
+            expect(transformedMetadata).toEqual({
+                'ts_some-key': 'some-value',
+                'ts_some-other-key': 'some-other-value',
+            });
+        });
+    });
+    describe('createProxyAgentsForBaseUrl', () => {
+        afterAll(() => {
+            jest.clearAllMocks();
+        });
+        it('should call this.certificates getter if includeAdditionalCertificates===true', () => __awaiter(void 0, void 0, void 0, function* () {
+            const client = new src_1.TDPClient();
+            const spy = jest
+                .spyOn(client, 'certificates', 'get')
+                .mockImplementation(() => [{ name: 'foo', id: 'bar', certificate: 'baz' }]);
+            client.assertProxyInitialized = jest.fn(() => true);
+            client.logger = { debug: jest.fn(), info: jest.fn() };
+            client.createProxyAgentsForBaseUrl({
+                baseUrl: 'https://example.com',
+            });
+            expect(spy).toHaveBeenCalled();
+            expect(client.logger.info).toHaveBeenCalledWith('Using 1 organization certificates', {
+                certificates: [
+                    {
+                        id: 'bar',
+                        name: 'foo',
+                    },
+                ],
+            });
+        }));
+        it('should not call this.certificates getter if includeAdditionalCertificates is array', () => __awaiter(void 0, void 0, void 0, function* () {
+            const client = new src_1.TDPClient();
+            const spy = jest.spyOn(client, 'certificates', 'get').mockImplementation(() => []);
+            client.assertProxyInitialized = jest.fn(() => true);
+            client.logger = { debug: jest.fn(), info: jest.fn() };
+            client.createProxyAgentsForBaseUrl({
+                baseUrl: 'https://example.com',
+                includeAdditionalCertificates: [],
+            });
+            expect(spy).not.toHaveBeenCalled();
+            expect(client.logger.info).not.toHaveBeenCalledWith('Using 1 organization certificates', {
+                certificates: [
+                    {
+                        id: 'bar',
+                        name: 'foo',
+                    },
+                ],
+            });
+        }));
+    });
+    describe('sanitizeConfig', () => {
+        it("removes risky keys like headers, data, and auth from the config's axios config", () => {
+            const config = {
+                headers: {
+                    Authorization: 'some-token',
+                },
+                data: {
+                    some: 'data',
+                },
+                auth: {
+                    username: 'some-username',
+                    password: 'some-password',
+                },
+                url: 'some-url',
+                timeout: 1000,
+                method: 'GET',
+            };
+            const sanitizedConfig = (0, src_1.sanitizeConfig)(config);
+            expect(sanitizedConfig).toEqual({
+                url: 'some-url',
+                timeout: 1000,
+                method: 'GET',
+            });
+        });
+    });
+    describe('API commands', () => {
+        describe('API Request', () => {
+            it('should send requestId to the API', () => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, _b;
+                const tdpClient = new src_1.TDPClient({
+                    orgSlug: 'tetrascience',
+                    awsRegion: 'us-east-2',
+                    connectorId: 'some-target-id',
+                    authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                });
+                yield tdpClient.init();
+                tdpClient.api = {
+                    v1: {
+                        getConnectorById: jest.fn().mockResolvedValue({}),
+                    },
+                };
+                const requestId = (0, uuid_1.v4)();
+                yield tdpClient.getConnector({}, {
+                    requestId,
+                });
+                expect((_b = (_a = tdpClient === null || tdpClient === void 0 ? void 0 : tdpClient.api) === null || _a === void 0 ? void 0 : _a.v1) === null || _b === void 0 ? void 0 : _b.getConnectorById).toHaveBeenCalledWith('some-target-id', expect.anything(), {
+                    requestId,
+                });
+            }));
+            //getCertificates
+            describe('getCertificates', () => {
+                it('should call axios with correct parameters and return expected result', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    const axiosRequest = jest.fn().mockResolvedValue({});
+                    tdpClient.api.axios.request = axiosRequest;
+                    const requestId = (0, uuid_1.v4)();
+                    yield tdpClient.getCertificates({ requestId });
+                    expect(axiosRequest).toBeCalledTimes(1);
+                    expect(axiosRequest).toHaveBeenCalledWith({
+                        headers: { 'ts-request-id': requestId },
+                        url: '/v1/certificates?includeContent=true&includeDisabled=false',
+                        data: undefined,
+                        method: 'GET',
+                    });
+                }));
+            });
+            describe('getConfig', () => {
+                it('should call axios with correct parameters and return expected result', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    const axiosRequest = jest.fn().mockResolvedValue({});
+                    tdpClient.api.axios.request = axiosRequest;
+                    const requestId = (0, uuid_1.v4)();
+                    yield tdpClient.getConfig({ version: '123' }, { requestId });
+                    expect(axiosRequest).toBeCalledTimes(1);
+                }));
+            });
+            describe('getConnector', () => {
+                it('should generate requestId if missing', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    const axiosRequest = jest.fn().mockResolvedValue({});
+                    tdpClient.api.axios.request = axiosRequest;
+                    yield tdpClient.getConnector({}, {});
+                    expect(axiosRequest).toBeCalledTimes(1);
+                    const requestId = axiosRequest.mock.calls[0][0].headers['ts-request-id'];
+                    expect(requestId.length).toEqual(36);
+                    expect(axiosRequest).toHaveBeenCalledWith({
+                        headers: { 'ts-request-id': requestId },
+                        url: '/v1/data-acquisition/connectors/some-target-id',
+                        data: undefined,
+                        params: { resolveSecrets: undefined, include: undefined },
+                        method: 'GET',
+                    });
+                }));
+            });
+            describe('reloadConnector', () => {
+                it('should call axios with correct parameters and return expected result', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    const axiosRequest = jest.fn().mockResolvedValue({});
+                    tdpClient.api.axios.request = axiosRequest;
+                    const requestId = (0, uuid_1.v4)();
+                    yield tdpClient.reloadConnector({ requestId });
+                    // once for the connector details
+                    // once for get connector data for the user agent function
+                    expect(axiosRequest).toBeCalledTimes(2);
+                    expect(axiosRequest).toHaveBeenCalledWith({
+                        headers: { 'ts-request-id': requestId },
+                        url: '/v1/data-acquisition/connectors/some-target-id',
+                        data: undefined,
+                        params: {
+                            include: 'config,artifact',
+                            resolveSecrets: true,
+                        },
+                        method: 'GET',
+                    });
+                }));
+            });
+            describe('getValue', () => {
+                it('should call axios with correct parameters and return expected result', () => __awaiter(void 0, void 0, void 0, function* () {
+                    var _a, _b;
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    tdpClient.api = {
+                        v1: {
+                            getConnectorData: jest.fn((_, query) => __awaiter(void 0, void 0, void 0, function* () {
+                                return {
+                                    values: query.keys.map((key) => ({
+                                        key,
+                                        value: 'some-value',
+                                    })),
+                                };
+                            })),
+                        },
+                    };
+                    const requestId = (0, uuid_1.v4)();
+                    yield tdpClient.getValue('some-key', { requestId });
+                    expect((_b = (_a = tdpClient === null || tdpClient === void 0 ? void 0 : tdpClient.api) === null || _a === void 0 ? void 0 : _a.v1) === null || _b === void 0 ? void 0 : _b.getConnectorData).toHaveBeenCalledWith('some-target-id', {
+                        keys: ['some-key'],
+                    }, { requestId });
+                }));
+            });
+            describe('getValues', () => {
+                it('should work with legacy ...args route', () => __awaiter(void 0, void 0, void 0, function* () {
+                    var _a, _b;
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    tdpClient.api = {
+                        v1: {
+                            getConnectorData: jest.fn((_, query) => __awaiter(void 0, void 0, void 0, function* () {
+                                return {
+                                    values: query.keys.map((key) => ({
+                                        key,
+                                        value: 'some-value',
+                                    })),
+                                };
+                            })),
+                        },
+                    };
+                    yield tdpClient.getValues('some-key', 'another-key');
+                    expect((_b = (_a = tdpClient === null || tdpClient === void 0 ? void 0 : tdpClient.api) === null || _a === void 0 ? void 0 : _a.v1) === null || _b === void 0 ? void 0 : _b.getConnectorData).toHaveBeenCalledWith('some-target-id', {
+                        keys: ['some-key', 'another-key'],
+                    }, { requestId: undefined });
+                }));
+                it('should work with newer [args],options route and call the same way', () => __awaiter(void 0, void 0, void 0, function* () {
+                    var _a, _b;
+                    const tdpClient = new src_1.TDPClient({
+                        orgSlug: 'tetrascience',
+                        awsRegion: 'us-east-2',
+                        connectorId: 'some-target-id',
+                        authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+                    });
+                    yield tdpClient.init();
+                    tdpClient.api = {
+                        v1: {
+                            getConnectorData: jest.fn((_, query) => __awaiter(void 0, void 0, void 0, function* () {
+                                return {
+                                    values: query.keys.map((key) => ({
+                                        key,
+                                        value: 'some-value',
+                                    })),
+                                };
+                            })),
+                        },
+                    };
+                    const requestId = (0, uuid_1.v4)();
+                    yield tdpClient.getValues(['some-key', 'another-key'], { requestId });
+                    expect((_b = (_a = tdpClient === null || tdpClient === void 0 ? void 0 : tdpClient.api) === null || _a === void 0 ? void 0 : _a.v1) === null || _b === void 0 ? void 0 : _b.getConnectorData).toHaveBeenCalledWith('some-target-id', {
+                        keys: ['some-key', 'another-key'],
+                    }, { requestId });
+                }));
+            });
+        });
+    });
+    describe('create axios instances', () => {
+        let tdpClient;
+        let tdpEndpoint;
+        let orgSlug;
+        let jwt;
+        let certificates;
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            tdpEndpoint = 'https://example.com';
+            orgSlug = 'test-org';
+            jwt = 'test-jwt';
+            certificates = [];
+            yield tdpClient.init();
+            tdpClient.createProxyAgentsForBaseUrl = jest.fn().mockReturnValue({});
+        }));
+        describe('createAxiosInstance', () => {
+            it('should create an axios instance with the correct baseURL', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstance({ baseUrl: tdpEndpoint });
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ baseURL: tdpEndpoint }));
+            });
+            it('should set the timeout to the provided value', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                const timeout_ms = 1234;
+                tdpClient.createAxiosInstance({ baseUrl: 'https://example.com', timeout_ms });
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ timeout: timeout_ms }));
+            });
+            it('should set the timeout to the default value if not provided', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstance({ baseUrl: 'https://example.com' });
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ timeout: tdpClient.config.httpRequestTimeout }));
+            });
+            it('should set proxy to false', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstance({ baseUrl: 'https://example.com' });
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ proxy: false }));
+            });
+            it('should include additional config if provided', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                const additionalConfig = { headers: { 'Custom-Header': 'value' } };
+                tdpClient.createAxiosInstance({ baseUrl: 'https://example.com', config: additionalConfig });
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining(additionalConfig));
+            });
+            it('should log the creation of the axios instance', () => {
+                const loggerSpy = jest.spyOn(tdpClient.logger, 'info');
+                const baseUrl = 'https://example.com';
+                const config = { headers: { 'Custom-Header': 'value' } };
+                const rejectUnauthorized = false;
+                tdpClient.createAxiosInstance({ baseUrl, config, rejectUnauthorized });
+                expect(loggerSpy).toHaveBeenCalledWith('Creating axios instance', {
+                    baseUrl,
+                    config: (0, src_1.sanitizeConfig)(config),
+                    rejectUnauthorized,
+                });
+            });
+        });
+        describe('createAxiosInstanceWithCertificatesAndHeaders', () => {
+            it('should create an axios instance with the correct baseURL', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstanceWithCertificatesAndHeaders(tdpEndpoint, orgSlug, jwt, certificates);
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ baseURL: tdpEndpoint }));
+            });
+            it('should set the timeout to the provided value', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                const timeout_ms = 1234;
+                tdpClient.createAxiosInstanceWithCertificatesAndHeaders(tdpEndpoint, orgSlug, jwt, certificates, timeout_ms);
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ timeout: timeout_ms }));
+            });
+            it('should set the timeout to the default value if not provided', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstanceWithCertificatesAndHeaders(tdpEndpoint, orgSlug, jwt, certificates);
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ timeout: tdpClient.config.httpRequestTimeout }));
+            });
+            it('should set proxy to false', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstanceWithCertificatesAndHeaders(tdpEndpoint, orgSlug, jwt, certificates);
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({ proxy: false }));
+            });
+            it('should include additional certificates in the proxy agents', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                certificates = ['cert1', 'cert2'];
+                tdpClient.createAxiosInstanceWithCertificatesAndHeaders(tdpEndpoint, orgSlug, jwt, certificates);
+                expect(tdpClient.createProxyAgentsForBaseUrl).toHaveBeenCalledWith(expect.objectContaining({ includeAdditionalCertificates: certificates }));
+            });
+            it('should set the correct headers', () => {
+                const axiosCreateSpy = jest.spyOn(axios_1.default, 'create');
+                tdpClient.createAxiosInstanceWithCertificatesAndHeaders(tdpEndpoint, orgSlug, jwt, certificates);
+                expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({
+                    headers: {
+                        [ts_lib_shared_schema_1.HTTPAuthKeys.scopeToOrgHeaderKey]: orgSlug,
+                        [ts_lib_shared_schema_1.HTTPAuthKeys.jwtAuthTokenHeaderKey]: jwt,
+                        'user-agent': 'PluggableConnector TDPClient',
+                    },
+                }));
+            });
+        });
+    });
+    describe('User-Agent headers', () => {
+        let tdpClient;
+        let getManifestSpy = jest.spyOn(manifest, 'getConnectorManifest');
+        beforeEach(() => {
+            jest.clearAllMocks();
+            tdpClient = new src_1.TDPClient({
+                orgSlug: 'tetrascience',
+                awsRegion: 'us-east-2',
+                connectorId: 'some-target-id',
+                authTokenProvider: new src_1.PredefinedAuthTokenProvider('some-fake-token'),
+            });
+            getManifestSpy = jest.spyOn(manifest, 'getConnectorManifest');
+            getManifestSpy.mockResolvedValue({
+                slug: 'test-slug',
+                version: '1.0.0',
+            });
+            // Mock the manifest to ensure it's available
+            tdpClient._manifest = {
+                slug: 'test-slug',
+                version: '1.0.0',
+            };
+        });
+        it('should set default user agent when connector info is available', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Arrange
+            getManifestSpy.mockResolvedValueOnce(null);
+            yield tdpClient.init();
+            // Mock createProxyAgentsForBaseUrl to avoid actual proxy creation
+            tdpClient.createProxyAgentsForBaseUrl = jest.fn().mockReturnValue({});
+            // Directly set the user agent
+            // tdpClient.setUserAgent('test-slug v1.0.0');
+            // Act
+            tdpClient.createAxiosInstanceWithCertificatesAndHeaders('https://example.com', 'orgSlug', 'jwt', []);
+            // Assert
+            expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({
+                headers: expect.objectContaining({
+                    'user-agent': 'PluggableConnector TDPClient',
+                }),
+            }));
+        }));
+        it('should disable user agent when configured in connector values', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock hasUserAgentSetToDisabled to return true
+            jest.spyOn(tdpClient, 'hasUserAgentSetToDisabled').mockResolvedValue(true);
+            yield tdpClient.init();
+            tdpClient.createProxyAgentsForBaseUrl = jest.fn().mockReturnValue({});
+            // Act
+            tdpClient.createAxiosInstanceWithCertificatesAndHeaders('https://example.com', 'orgSlug', 'jwt', []);
+            // Assert
+            expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({
+                headers: expect.not.objectContaining({
+                    'User-Agent': expect.anything(),
+                }),
+            }));
+        }));
+        it('should set default user agent when connector info is available', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Arrange
+            yield tdpClient.init();
+            // Mock createProxyAgentsForBaseUrl to avoid actual proxy creation
+            tdpClient.createProxyAgentsForBaseUrl = jest.fn().mockReturnValue({});
+            // Act
+            tdpClient.createAxiosInstanceWithCertificatesAndHeaders('https://example.com', 'orgSlug', 'jwt', []);
+            // Assert
+            expect(axiosCreateSpy).toHaveBeenCalledWith(expect.objectContaining({
+                headers: expect.objectContaining({
+                    'user-agent': 'PluggableConnector test-slug v1.0.0',
+                }),
+            }));
+        }));
+    });
+});
+//# sourceMappingURL=tdp-client.test.js.map