@superblocksteam/sabs-client 0.0.1-demo-databricks-deploy

package/dist/sabs.test.js

@@ -0,0 +1,953 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const sabs_types_1 = require("@superblocksteam/sabs-types");
+const axios_1 = __importStar(require("axios"));
+const sabs_1 = require("./sabs");
+describe('sabs service', () => {
+    let anyBuildKey;
+    let anyAccessToken;
+    beforeEach(() => {
+        anyBuildKey = 'any-secret-build-key';
+        anyAccessToken = 'any-access-token';
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('build', () => {
+        test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+            const expectedBuildId = 'expectedBuildId';
+            const expectedCreated = new Date();
+            const expectedUpdated = new Date();
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockResolvedValue({
+                data: {
+                    buildId: expectedBuildId,
+                    created: expectedCreated,
+                    updated: expectedUpdated
+                }
+            });
+            const anyDirectoryHash = 'anyDirectoryHash';
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: 'anyApplicationId',
+                organizationId: 'anyOrganizationId'
+            });
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.build({
+                directoryHash: anyDirectoryHash,
+                meta: anyApplicationMetadata,
+                buildKey: anyBuildKey,
+                accessToken
+            });
+            expect(result).toEqual({
+                buildId: expectedBuildId,
+                created: expectedCreated,
+                updated: expectedUpdated
+            });
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                url: 'http://localhost:3000/v1/builds',
+                headers: expectedHeaders,
+                data: {
+                    directoryHash: anyDirectoryHash,
+                    applicationMetadata: anyApplicationMetadata,
+                    buildKey: anyBuildKey
+                }
+            });
+        });
+        test('raises error when request fails', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new Error('any error'));
+            const anyDirectoryHash = 'anyDirectoryHash';
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: 'anyApplicationId',
+                organizationId: 'anyOrganizationId'
+            });
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.build({ directoryHash: anyDirectoryHash, meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: anyAccessToken })).rejects.toThrow();
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                url: 'http://localhost:3000/v1/builds',
+                headers: { Authorization: `Bearer ${anyAccessToken}` },
+                data: {
+                    directoryHash: anyDirectoryHash,
+                    applicationMetadata: anyApplicationMetadata,
+                    buildKey: anyBuildKey
+                }
+            });
+        });
+        test('raises error when directory hash is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: 'anyApplicationId',
+                organizationId: 'anyOrganizationId'
+            });
+            await expect(sabs.build({ directoryHash: '', meta: anyApplicationMetadata, buildKey: anyBuildKey })).rejects.toThrow();
+        });
+        test('raises error when application metadata is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.build({
+                directoryHash: '',
+                meta: undefined,
+                buildKey: anyBuildKey,
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when build key is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: 'anyApplicationId',
+                organizationId: 'anyOrganizationId'
+            });
+            await expect(sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: '', accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('raises error when application id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: '',
+                organizationId: 'anyOrganizationId'
+            });
+            await expect(sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('raises error when organization id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: 'anyApplicationId',
+                organizationId: ''
+            });
+            await expect(sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const anyApplicationMetadata = new sabs_types_1.ApplicationMetadata({
+                id: 'anyApplicationId',
+                organizationId: 'anyOrganizationId'
+            });
+            await expect(sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: '' })).rejects.toThrow();
+        });
+    });
+    describe('status', () => {
+        test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+            const expectedBuildId = 'expectedBuildId';
+            const expectedStatus = sabs_types_1.BuildStatus.SUCCESS;
+            const expectedCreated = new Date();
+            const expectedUpdated = new Date();
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockResolvedValue({
+                data: {
+                    buildId: expectedBuildId,
+                    status: expectedStatus,
+                    created: expectedCreated,
+                    updated: expectedUpdated
+                }
+            });
+            const anyBuildId = 'anyBuildId';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.status({ buildId: anyBuildId, accessToken });
+            expect(result).toEqual({
+                buildId: expectedBuildId,
+                status: expectedStatus,
+                created: expectedCreated,
+                updated: expectedUpdated
+            });
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'GET',
+                url: `http://localhost:3000/v1/builds/${anyBuildId}`,
+                headers: expectedHeaders
+            });
+        });
+        test('raises error when request fails', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new Error('any error'));
+            const anyBuildId = 'anyBuildId';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow();
+            expect(mockAxios).toHaveBeenCalledWith({
+                headers: { Authorization: `Bearer ${anyAccessToken}` },
+                method: 'GET',
+                url: `http://localhost:3000/v1/builds/${anyBuildId}`
+            });
+        });
+        test('raises error when build id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.status({ buildId: '', accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.status({ buildId: 'anyBuildId', accessToken: '' })).rejects.toThrow();
+        });
+    });
+    describe('list', () => {
+        test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockResolvedValue({
+                data: {
+                    builds: [
+                        {
+                            buildId: 'id1',
+                            status: sabs_types_1.BuildStatus.SUCCESS,
+                            created: new Date('2023-01-01'),
+                            updated: new Date('2023-01-02')
+                        },
+                        {
+                            buildId: 'id2',
+                            status: sabs_types_1.BuildStatus.RUNNING,
+                            created: new Date('2023-01-03'),
+                            updated: new Date('2023-01-04')
+                        },
+                        {
+                            buildId: 'id3',
+                            status: sabs_types_1.BuildStatus.FAILED,
+                            error: 'Build failed',
+                            created: new Date('2023-01-05'),
+                            updated: new Date('2023-01-06')
+                        }
+                    ]
+                }
+            });
+            const anyOrganizationId = 'anyOrganizationId';
+            const anyApplicationId = 'anyApplicationId';
+            const anyDirectoryHash = 'anyDirectoryHash';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.list({
+                organizationId: anyOrganizationId,
+                applicationId: anyApplicationId,
+                directoryHash: anyDirectoryHash,
+                accessToken
+            });
+            expect(result).toEqual({
+                builds: [
+                    {
+                        buildId: 'id1',
+                        status: sabs_types_1.BuildStatus.SUCCESS,
+                        created: new Date('2023-01-01'),
+                        updated: new Date('2023-01-02')
+                    },
+                    {
+                        buildId: 'id2',
+                        status: sabs_types_1.BuildStatus.RUNNING,
+                        created: new Date('2023-01-03'),
+                        updated: new Date('2023-01-04')
+                    },
+                    {
+                        buildId: 'id3',
+                        status: sabs_types_1.BuildStatus.FAILED,
+                        error: 'Build failed',
+                        created: new Date('2023-01-05'),
+                        updated: new Date('2023-01-06')
+                    }
+                ]
+            });
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'GET',
+                url: `http://localhost:3000/v1/build`,
+                headers: expectedHeaders,
+                params: {
+                    organizationId: anyOrganizationId,
+                    applicationId: anyApplicationId,
+                    directoryHash: anyDirectoryHash
+                }
+            });
+        });
+        test('raises error when request fails', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new Error('any error'));
+            const anyOrganizationId = 'anyOrganizationId';
+            const anyApplicationId = 'anyApplicationId';
+            const anyDirectoryHash = 'anyDirectoryHash';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.list({
+                organizationId: anyOrganizationId,
+                applicationId: anyApplicationId,
+                directoryHash: anyDirectoryHash,
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'GET',
+                url: `http://localhost:3000/v1/build`,
+                headers: { Authorization: `Bearer ${anyAccessToken}` },
+                params: {
+                    organizationId: anyOrganizationId,
+                    applicationId: anyApplicationId,
+                    directoryHash: anyDirectoryHash
+                }
+            });
+        });
+        test('raises error when organization id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.list({ organizationId: '', applicationId: 'anyApplicationId', directoryHash: 'anyDirectoryHash', accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('raises error when application id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.list({
+                organizationId: 'anyOrganizationId',
+                applicationId: '',
+                directoryHash: 'anyDirectoryHash',
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when directory hash is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.list({
+                organizationId: 'anyOrganizationId',
+                applicationId: 'anyApplicationId',
+                directoryHash: '',
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.list({
+                organizationId: 'anyOrganizationId',
+                applicationId: 'anyApplicationId',
+                directoryHash: 'anyDirectoryHash',
+                accessToken: ''
+            })).rejects.toThrow();
+        });
+    });
+    describe('terminate', () => {
+        test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+            const expectedBuildId = 'expectedBuildId';
+            const expectedStatus = sabs_types_1.BuildStatus.TIMED_OUT;
+            const expectedError = 'build timed out';
+            const expectedCreated = new Date();
+            const expectedUpdated = new Date();
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockResolvedValue({
+                data: {
+                    buildId: expectedBuildId,
+                    status: expectedStatus,
+                    error: expectedError,
+                    created: expectedCreated,
+                    updated: expectedUpdated
+                }
+            });
+            const anyBuildId = 'anyBuildId';
+            const anyStatus = sabs_types_1.BuildStatus.TIMED_OUT;
+            const anyError = 'build timed out';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.terminate({
+                buildId: anyBuildId,
+                status: anyStatus,
+                buildKey: anyBuildKey,
+                error: anyError,
+                accessToken
+            });
+            expect(result).toEqual({
+                buildId: expectedBuildId,
+                status: expectedStatus,
+                error: expectedError,
+                created: expectedCreated,
+                updated: expectedUpdated
+            });
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
+                headers: expectedHeaders,
+                data: {
+                    buildId: anyBuildId,
+                    status: anyStatus,
+                    error: anyError,
+                    buildKey: anyBuildKey
+                }
+            });
+        });
+        test('raises error when request fails', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new Error('any error'));
+            const anyBuildId = 'anyBuildId';
+            const anyStatus = sabs_types_1.BuildStatus.TIMED_OUT;
+            const anyError = 'build timed out';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminate({ buildId: anyBuildId, status: anyStatus, buildKey: anyBuildKey, error: anyError, accessToken: anyAccessToken })).rejects.toThrow();
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                headers: { Authorization: `Bearer ${anyAccessToken}` },
+                url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
+                data: {
+                    buildId: anyBuildId,
+                    status: anyStatus,
+                    error: anyError,
+                    buildKey: anyBuildKey
+                }
+            });
+        });
+        test('raises error when build id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminate({
+                buildId: '',
+                status: sabs_types_1.BuildStatus.TIMED_OUT,
+                buildKey: anyBuildKey,
+                error: 'build timed out',
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when status is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminate({
+                buildId: 'anyBuildId',
+                status: undefined,
+                buildKey: anyBuildKey,
+                error: 'build timed out',
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when build key is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminate({
+                buildId: 'anyBuildId',
+                status: sabs_types_1.BuildStatus.TIMED_OUT,
+                buildKey: '',
+                error: 'build timed out',
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminate({
+                buildId: 'anyBuildId',
+                status: sabs_types_1.BuildStatus.TIMED_OUT,
+                buildKey: anyBuildKey,
+                error: 'build timed out',
+                accessToken: ''
+            })).rejects.toThrow();
+        });
+    });
+    describe('bulkStatus', () => {
+        test('returns expected response', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockResolvedValue({
+                data: {
+                    builds: [
+                        {
+                            buildId: 'build1',
+                            status: sabs_types_1.BuildStatus.SUCCESS,
+                            created: new Date('2023-01-01'),
+                            updated: new Date('2023-01-02')
+                        },
+                        {
+                            buildId: 'build2',
+                            status: sabs_types_1.BuildStatus.RUNNING,
+                            created: new Date('2023-01-03'),
+                            updated: new Date('2023-01-04')
+                        }
+                    ]
+                }
+            });
+            const anyOrganizationId = 'anyOrganizationId';
+            const anyApplicationId = 'anyApplicationId';
+            const anyDirectoryHashes = ['hash1', 'hash2'];
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.bulkStatus({
+                organizationId: anyOrganizationId,
+                applicationId: anyApplicationId,
+                directoryHashes: anyDirectoryHashes,
+                accessToken: anyAccessToken
+            });
+            expect(result).toEqual({
+                builds: [
+                    {
+                        buildId: 'build1',
+                        status: sabs_types_1.BuildStatus.SUCCESS,
+                        created: new Date('2023-01-01'),
+                        updated: new Date('2023-01-02')
+                    },
+                    {
+                        buildId: 'build2',
+                        status: sabs_types_1.BuildStatus.RUNNING,
+                        created: new Date('2023-01-03'),
+                        updated: new Date('2023-01-04')
+                    }
+                ]
+            });
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                headers: { Authorization: `Bearer ${anyAccessToken}` },
+                url: `http://localhost:3000/v1/builds/${anyOrganizationId}/${anyApplicationId}/bulk-status`,
+                data: {
+                    organizationId: anyOrganizationId,
+                    applicationId: anyApplicationId,
+                    directoryHashes: anyDirectoryHashes
+                }
+            });
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.bulkStatus({
+                organizationId: 'anyOrganizationId',
+                applicationId: 'anyApplicationId',
+                directoryHashes: ['anyDirectoryHash'],
+                accessToken: ''
+            })).rejects.toThrow();
+        });
+        test('raises error when organization id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.bulkStatus({
+                organizationId: '',
+                applicationId: 'anyApplicationId',
+                directoryHashes: ['anyDirectoryHash'],
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when application id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.bulkStatus({
+                organizationId: 'anyOrganizationId',
+                applicationId: '',
+                directoryHashes: ['anyDirectoryHash'],
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when directory hashes is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.bulkStatus({
+                organizationId: 'anyOrganizationId',
+                applicationId: 'anyApplicationId',
+                directoryHashes: [],
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+    });
+    describe('liveEdit', () => {
+        const applicationId = 'anyApplicationId';
+        const organizationId = 'anyOrganizationId';
+        const branch = 'anyBranch';
+        test('raises error when application id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.createLiveEdit({
+                applicationId: '',
+                organizationId: 'anyOrganizationId',
+                branch: 'anyBranch',
+                expiresIn: 1000,
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when organization id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.createLiveEdit({
+                applicationId: 'anyApplicationId',
+                organizationId: '',
+                branch: 'anyBranch',
+                expiresIn: 1000,
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when branch is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.createLiveEdit({
+                applicationId: 'anyApplicationId',
+                organizationId: 'anyOrganizationId',
+                branch: '',
+                expiresIn: 1000,
+                accessToken: anyAccessToken
+            })).rejects.toThrow();
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.createLiveEdit({
+                applicationId: 'anyApplicationId',
+                organizationId: 'anyOrganizationId',
+                branch: 'anyBranch',
+                expiresIn: 1000,
+                accessToken: ''
+            })).rejects.toThrow();
+        });
+        test('createLiveEdit', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            const expiresInSeconds = 1000;
+            const now = Date.now();
+            const expectedRequest = {
+                application: {
+                    applicationId,
+                    organizationId,
+                    branch
+                },
+                expiresIn: BigInt(expiresInSeconds),
+                sessionJwt: anyAccessToken
+            };
+            const newLiveEditResponse = new sabs_types_1.CreateLiveEditResponse({
+                liveEditId: 'liveEditId',
+                liveEditUrl: 'http://localhost:3000/live-edit/liveEditId',
+                application: {
+                    applicationId,
+                    organizationId,
+                    branch
+                },
+                expiresAt: BigInt(now + expiresInSeconds * 1000)
+            });
+            mockAxios.mockResolvedValue({ data: newLiveEditResponse });
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.createLiveEdit({
+                applicationId,
+                organizationId,
+                branch,
+                expiresIn: expiresInSeconds,
+                accessToken: anyAccessToken
+            });
+            expect(result).toEqual(newLiveEditResponse);
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                url: 'http://localhost:3000/v1/live-edit',
+                data: expectedRequest,
+                headers: {
+                    Authorization: `Bearer ${anyAccessToken}`
+                }
+            });
+        });
+        test('terminateLiveEdit', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            const liveEditId = 'liveEditId';
+            const expectedRequest = { liveEditId };
+            const expectedCreated = new Date();
+            const expectedUpdated = new Date();
+            const expectedResponse = {
+                liveEditId,
+                status: sabs_types_1.LiveEditStatus.TERMINATED,
+                application: {
+                    applicationId,
+                    organizationId,
+                    branch
+                },
+                created: expectedCreated,
+                updated: expectedUpdated
+            };
+            mockAxios.mockResolvedValue({ data: expectedResponse });
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const result = await sabs.terminateLiveEdit({ liveEditId, accessToken: anyAccessToken });
+            expect(result).toEqual(expectedResponse);
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                url: `http://localhost:3000/v1/live-edit/${liveEditId}/terminate`,
+                data: expectedRequest,
+                headers: {
+                    Authorization: `Bearer ${anyAccessToken}`
+                }
+            });
+        });
+        test('raises error when live edit id is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminateLiveEdit({ liveEditId: '', accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('raises error when access token is empty', async () => {
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminateLiveEdit({ liveEditId: 'liveEditId', accessToken: '' })).rejects.toThrow();
+        });
+        test('terminateLiveEdit raises error when request fails', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new Error('any error'));
+            const liveEditId = 'liveEditId';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.terminateLiveEdit({ liveEditId, accessToken: anyAccessToken })).rejects.toThrow();
+            expect(mockAxios).toHaveBeenCalledWith({
+                method: 'POST',
+                url: `http://localhost:3000/v1/live-edit/${liveEditId}/terminate`,
+                data: {
+                    liveEditId
+                },
+                headers: {
+                    Authorization: `Bearer ${anyAccessToken}`
+                }
+            });
+        });
+    });
+    describe('executeRequest', () => {
+        test('raies expected error when error is axios error', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new axios_1.AxiosError('request failed', 'internal', undefined, undefined, {
+                headers: {},
+                config: {
+                    headers: new axios_1.AxiosHeaders()
+                },
+                status: 500,
+                statusText: 'internal server error',
+                data: 'failed to process request'
+            }));
+            const anyBuildId = 'anyBuildId';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow();
+        });
+        test('re-raises error when error is not axios error', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new Error('unexpected error'));
+            const anyBuildId = 'anyBuildId';
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow();
+        });
+    });
+    describe('backward compatibility', () => {
+        test('errors can be caught as generic Error instances (backward compatibility)', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new axios_1.AxiosError('Service unavailable', 'ECONNREFUSED', undefined, undefined, {
+                headers: {},
+                config: {
+                    headers: new axios_1.AxiosHeaders()
+                },
+                status: 503,
+                statusText: 'Service Unavailable',
+                data: { message: 'Server temporarily unavailable' }
+            }));
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            const applicationId = 'test-app';
+            const organizationId = 'test-org';
+            const directoryHash = 'abc123';
+            // This simulates how existing applications might handle errors
+            try {
+                const result = await sabs.build({
+                    directoryHash,
+                    meta: new sabs_types_1.ApplicationMetadata({
+                        id: applicationId,
+                        organizationId
+                    }),
+                    buildKey: anyBuildKey,
+                    accessToken: anyAccessToken
+                });
+                // Should not reach here
+                expect(result).toBeUndefined();
+            }
+            catch (error) {
+                // Legacy error handling - should still work with new error types
+                expect(error).toBeInstanceOf(Error);
+                expect(error.message).toContain('SABS API Error (503)');
+                // Verify we can still access basic Error properties
+                expect(typeof error.message).toBe('string');
+                expect(error.name).toBeDefined();
+                // This is how existing code might log and re-throw
+                const loggedError = {
+                    error,
+                    applicationId,
+                    organizationId,
+                    directoryHash,
+                    message: error.message
+                };
+                expect(loggedError.error).toBe(error);
+                expect(loggedError.message).toBe(error.message);
+                // Re-throwing as generic Error should work
+                expect(() => {
+                    throw new Error('Unable to launch build');
+                }).toThrow('Unable to launch build');
+            }
+        });
+        test('new error types provide additional functionality when accessed', async () => {
+            const mockAxios = jest.spyOn(axios_1.default, 'request');
+            mockAxios.mockRejectedValue(new axios_1.AxiosError('Unauthorized', 'UNAUTHORIZED', undefined, undefined, {
+                headers: {},
+                config: {
+                    headers: new axios_1.AxiosHeaders()
+                },
+                status: 401,
+                statusText: 'Unauthorized',
+                data: { message: 'Invalid token' }
+            }));
+            const sabs = new sabs_1.SabsClient('http://localhost:3000');
+            try {
+                await sabs.status({ buildId: 'test-build', accessToken: 'invalid-token' });
+            }
+            catch (error) {
+                // Backward compatible - can still catch as Error
+                expect(error).toBeInstanceOf(Error);
+                // But applications can now also check for specific error types
+                const { UnauthorizedError } = await Promise.resolve().then(() => __importStar(require('./errors')));
+                expect(error).toBeInstanceOf(UnauthorizedError);
+                // And access the status code if needed
+                if ('status' in error) {
+                    expect(error.status).toBe(401);
+                }
+            }
+        });
+        describe('response data handling', () => {
+            test('handles responseData with message property', async () => {
+                const mockAxios = jest.spyOn(axios_1.default, 'request');
+                mockAxios.mockRejectedValue(new axios_1.AxiosError('Bad Request', 'BAD_REQUEST', undefined, undefined, {
+                    headers: {},
+                    config: {
+                        headers: new axios_1.AxiosHeaders()
+                    },
+                    status: 400,
+                    statusText: 'Bad Request',
+                    data: { message: 'Directory hash is required' }
+                }));
+                const sabs = new sabs_1.SabsClient('http://localhost:3000');
+                try {
+                    await sabs.build({
+                        directoryHash: 'test', // Use non-empty value to avoid client-side validation
+                        meta: new sabs_types_1.ApplicationMetadata({ id: 'test', organizationId: 'test' }),
+                        buildKey: 'test',
+                        accessToken: 'test'
+                    });
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('SABS API Error (400): Directory hash is required');
+                }
+            });
+            test('handles responseData as string', async () => {
+                const mockAxios = jest.spyOn(axios_1.default, 'request');
+                mockAxios.mockRejectedValue(new axios_1.AxiosError('Internal Server Error', 'INTERNAL_SERVER_ERROR', undefined, undefined, {
+                    headers: {},
+                    config: {
+                        headers: new axios_1.AxiosHeaders()
+                    },
+                    status: 500,
+                    statusText: 'Internal Server Error',
+                    data: 'Database connection failed'
+                }));
+                const sabs = new sabs_1.SabsClient('http://localhost:3000');
+                try {
+                    await sabs.build({
+                        directoryHash: 'test',
+                        meta: new sabs_types_1.ApplicationMetadata({ id: 'test', organizationId: 'test' }),
+                        buildKey: 'test',
+                        accessToken: 'test'
+                    });
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('SABS API Error (500): Database connection failed');
+                }
+            });
+            test('handles null responseData', async () => {
+                const mockAxios = jest.spyOn(axios_1.default, 'request');
+                mockAxios.mockRejectedValue(new axios_1.AxiosError('Service Unavailable', 'SERVICE_UNAVAILABLE', undefined, undefined, {
+                    headers: {},
+                    config: {
+                        headers: new axios_1.AxiosHeaders()
+                    },
+                    status: 503,
+                    statusText: 'Service Unavailable',
+                    data: null
+                }));
+                const sabs = new sabs_1.SabsClient('http://localhost:3000');
+                try {
+                    await sabs.build({
+                        directoryHash: 'test',
+                        meta: new sabs_types_1.ApplicationMetadata({ id: 'test', organizationId: 'test' }),
+                        buildKey: 'test',
+                        accessToken: 'test'
+                    });
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('SABS API Error (503): Service Unavailable (503)');
+                }
+            });
+            test('handles undefined responseData', async () => {
+                const mockAxios = jest.spyOn(axios_1.default, 'request');
+                mockAxios.mockRejectedValue(new axios_1.AxiosError('Gateway Timeout', 'GATEWAY_TIMEOUT', undefined, undefined, {
+                    headers: {},
+                    config: {
+                        headers: new axios_1.AxiosHeaders()
+                    },
+                    status: 504,
+                    statusText: 'Gateway Timeout',
+                    data: undefined
+                }));
+                const sabs = new sabs_1.SabsClient('http://localhost:3000');
+                try {
+                    await sabs.build({
+                        directoryHash: 'test',
+                        meta: new sabs_types_1.ApplicationMetadata({ id: 'test', organizationId: 'test' }),
+                        buildKey: 'test',
+                        accessToken: 'test'
+                    });
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('SABS API Error (504): Gateway Timeout (504)');
+                }
+            });
+            test('handles responseData object without message property', async () => {
+                const mockAxios = jest.spyOn(axios_1.default, 'request');
+                mockAxios.mockRejectedValue(new axios_1.AxiosError('Bad Request', 'BAD_REQUEST', undefined, undefined, {
+                    headers: {},
+                    config: {
+                        headers: new axios_1.AxiosHeaders()
+                    },
+                    status: 400,
+                    statusText: 'Bad Request',
+                    data: { error: 'validation_failed', details: ['field is required'] }
+                }));
+                const sabs = new sabs_1.SabsClient('http://localhost:3000');
+                try {
+                    await sabs.build({
+                        directoryHash: 'test',
+                        meta: new sabs_types_1.ApplicationMetadata({ id: 'test', organizationId: 'test' }),
+                        buildKey: 'test',
+                        accessToken: 'test'
+                    });
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('SABS API Error (400): Bad Request (400)');
+                }
+            });
+            test('all errors have consistent HttpError interface', async () => {
+                const responseData = { code: 'TIMEOUT', retryAfter: 30 };
+                const mockAxios = jest.spyOn(axios_1.default, 'request');
+                mockAxios.mockRejectedValue(new axios_1.AxiosError('Request timeout', 'TIMEOUT', undefined, undefined, {
+                    headers: {},
+                    config: {
+                        headers: new axios_1.AxiosHeaders()
+                    },
+                    status: 500,
+                    statusText: 'Internal Server Error',
+                    data: responseData
+                }));
+                const sabs = new sabs_1.SabsClient('http://localhost:3000');
+                try {
+                    await sabs.build({
+                        directoryHash: 'test',
+                        meta: new sabs_types_1.ApplicationMetadata({ id: 'test', organizationId: 'test' }),
+                        buildKey: 'test',
+                        accessToken: 'test'
+                    });
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('SABS API Error (500): Internal Server Error (500)');
+                    // All error types now have consistent HttpError interface
+                    expect('status' in error).toBe(true);
+                    expect('title' in error).toBe(true);
+                    if ('status' in error) {
+                        expect(error.status).toBe(500);
+                    }
+                    if ('title' in error) {
+                        expect(error.title).toBe('Internal server error');
+                    }
+                }
+            });
+        });
+    });
+});
+//# sourceMappingURL=sabs.test.js.map