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

package/src/sabs.test.ts

@@ -0,0 +1,1107 @@
+import { ApplicationMetadata, BuildStatus, CreateLiveEditResponse, LiveEditStatus } from '@superblocksteam/sabs-types';
+import axios, { AxiosError, AxiosHeaders } from 'axios';
+
+import { SabsClient } from './sabs';
+
+describe('sabs service', () => {
+  let anyBuildKey: string;
+  let anyAccessToken: string;
+
+  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, 'request');
+        mockAxios.mockResolvedValue({
+          data: {
+            buildId: expectedBuildId,
+            created: expectedCreated,
+            updated: expectedUpdated
+          }
+        });
+
+        const anyDirectoryHash = 'anyDirectoryHash';
+        const anyApplicationMetadata = new ApplicationMetadata({
+          id: 'anyApplicationId',
+          organizationId: 'anyOrganizationId'
+        });
+
+        const sabs = new 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, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyDirectoryHash = 'anyDirectoryHash';
+      const anyApplicationMetadata = new ApplicationMetadata({
+        id: 'anyApplicationId',
+        organizationId: 'anyOrganizationId'
+      });
+
+      const sabs = new 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 SabsClient('http://localhost:3000');
+      const anyApplicationMetadata = new 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 SabsClient('http://localhost:3000');
+      await expect(
+        sabs.build({
+          directoryHash: '',
+          meta: undefined as unknown as ApplicationMetadata,
+          buildKey: anyBuildKey,
+          accessToken: anyAccessToken
+        })
+      ).rejects.toThrow();
+    });
+
+    test('raises error when build key is empty', async () => {
+      const sabs = new SabsClient('http://localhost:3000');
+      const anyApplicationMetadata = new 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 SabsClient('http://localhost:3000');
+      const anyApplicationMetadata = new 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 SabsClient('http://localhost:3000');
+      const anyApplicationMetadata = new 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 SabsClient('http://localhost:3000');
+      const anyApplicationMetadata = new 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 = BuildStatus.SUCCESS;
+        const expectedCreated = new Date();
+        const expectedUpdated = new Date();
+
+        const mockAxios = jest.spyOn(axios, 'request');
+        mockAxios.mockResolvedValue({
+          data: {
+            buildId: expectedBuildId,
+            status: expectedStatus,
+            created: expectedCreated,
+            updated: expectedUpdated
+          }
+        });
+
+        const anyBuildId = 'anyBuildId';
+
+        const sabs = new 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, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyBuildId = 'anyBuildId';
+
+      const sabs = new 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 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 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, 'request');
+        mockAxios.mockResolvedValue({
+          data: {
+            builds: [
+              {
+                buildId: 'id1',
+                status: BuildStatus.SUCCESS,
+                created: new Date('2023-01-01'),
+                updated: new Date('2023-01-02')
+              },
+              {
+                buildId: 'id2',
+                status: BuildStatus.RUNNING,
+                created: new Date('2023-01-03'),
+                updated: new Date('2023-01-04')
+              },
+              {
+                buildId: 'id3',
+                status: 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 SabsClient('http://localhost:3000');
+        const result = await sabs.list({
+          organizationId: anyOrganizationId,
+          applicationId: anyApplicationId,
+          directoryHash: anyDirectoryHash,
+          accessToken
+        });
+
+        expect(result).toEqual({
+          builds: [
+            {
+              buildId: 'id1',
+              status: BuildStatus.SUCCESS,
+              created: new Date('2023-01-01'),
+              updated: new Date('2023-01-02')
+            },
+            {
+              buildId: 'id2',
+              status: BuildStatus.RUNNING,
+              created: new Date('2023-01-03'),
+              updated: new Date('2023-01-04')
+            },
+            {
+              buildId: 'id3',
+              status: 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, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyOrganizationId = 'anyOrganizationId';
+      const anyApplicationId = 'anyApplicationId';
+      const anyDirectoryHash = 'anyDirectoryHash';
+
+      const sabs = new 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 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 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 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 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 = BuildStatus.TIMED_OUT;
+        const expectedError = 'build timed out';
+        const expectedCreated = new Date();
+        const expectedUpdated = new Date();
+
+        const mockAxios = jest.spyOn(axios, 'request');
+        mockAxios.mockResolvedValue({
+          data: {
+            buildId: expectedBuildId,
+            status: expectedStatus,
+            error: expectedError,
+            created: expectedCreated,
+            updated: expectedUpdated
+          }
+        });
+
+        const anyBuildId = 'anyBuildId';
+        const anyStatus = BuildStatus.TIMED_OUT;
+        const anyError = 'build timed out';
+
+        const sabs = new 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, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyBuildId = 'anyBuildId';
+      const anyStatus = BuildStatus.TIMED_OUT;
+      const anyError = 'build timed out';
+
+      const sabs = new 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 SabsClient('http://localhost:3000');
+      await expect(
+        sabs.terminate({
+          buildId: '',
+          status: BuildStatus.TIMED_OUT,
+          buildKey: anyBuildKey,
+          error: 'build timed out',
+          accessToken: anyAccessToken
+        })
+      ).rejects.toThrow();
+    });
+
+    test('raises error when status is empty', async () => {
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(
+        sabs.terminate({
+          buildId: 'anyBuildId',
+          status: undefined as unknown as BuildStatus,
+          buildKey: anyBuildKey,
+          error: 'build timed out',
+          accessToken: anyAccessToken
+        })
+      ).rejects.toThrow();
+    });
+
+    test('raises error when build key is empty', async () => {
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(
+        sabs.terminate({
+          buildId: 'anyBuildId',
+          status: BuildStatus.TIMED_OUT,
+          buildKey: '',
+          error: 'build timed out',
+          accessToken: anyAccessToken
+        })
+      ).rejects.toThrow();
+    });
+
+    test('raises error when access token is empty', async () => {
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(
+        sabs.terminate({
+          buildId: 'anyBuildId',
+          status: BuildStatus.TIMED_OUT,
+          buildKey: anyBuildKey,
+          error: 'build timed out',
+          accessToken: ''
+        })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('bulkStatus', () => {
+    test('returns expected response', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockResolvedValue({
+        data: {
+          builds: [
+            {
+              buildId: 'build1',
+              status: BuildStatus.SUCCESS,
+              created: new Date('2023-01-01'),
+              updated: new Date('2023-01-02')
+            },
+            {
+              buildId: 'build2',
+              status: 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 SabsClient('http://localhost:3000');
+      const result = await sabs.bulkStatus({
+        organizationId: anyOrganizationId,
+        applicationId: anyApplicationId,
+        directoryHashes: anyDirectoryHashes,
+        accessToken: anyAccessToken
+      });
+
+      expect(result).toEqual({
+        builds: [
+          {
+            buildId: 'build1',
+            status: BuildStatus.SUCCESS,
+            created: new Date('2023-01-01'),
+            updated: new Date('2023-01-02')
+          },
+          {
+            buildId: 'build2',
+            status: 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 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 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 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 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 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 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 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 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, 'request');
+      const expiresInSeconds = 1000;
+      const now = Date.now();
+      const expectedRequest = {
+        application: {
+          applicationId,
+          organizationId,
+          branch
+        },
+        expiresIn: BigInt(expiresInSeconds),
+        sessionJwt: anyAccessToken
+      };
+      const newLiveEditResponse = new 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 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, 'request');
+      const liveEditId = 'liveEditId';
+      const expectedRequest = { liveEditId };
+      const expectedCreated = new Date();
+      const expectedUpdated = new Date();
+      const expectedResponse = {
+        liveEditId,
+        status: LiveEditStatus.TERMINATED,
+        application: {
+          applicationId,
+          organizationId,
+          branch
+        },
+        created: expectedCreated,
+        updated: expectedUpdated
+      };
+
+      mockAxios.mockResolvedValue({ data: expectedResponse });
+
+      const sabs = new 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 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 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, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const liveEditId = 'liveEditId';
+
+      const sabs = new 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, 'request');
+      mockAxios.mockRejectedValue(
+        new AxiosError('request failed', 'internal', undefined, undefined, {
+          headers: {},
+          config: {
+            headers: new AxiosHeaders()
+          },
+          status: 500,
+          statusText: 'internal server error',
+          data: 'failed to process request'
+        })
+      );
+
+      const anyBuildId = 'anyBuildId';
+
+      const sabs = new 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, 'request');
+      mockAxios.mockRejectedValue(new Error('unexpected error'));
+
+      const anyBuildId = 'anyBuildId';
+
+      const sabs = new 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, 'request');
+      mockAxios.mockRejectedValue(
+        new AxiosError('Service unavailable', 'ECONNREFUSED', undefined, undefined, {
+          headers: {},
+          config: {
+            headers: new AxiosHeaders()
+          },
+          status: 503,
+          statusText: 'Service Unavailable',
+          data: { message: 'Server temporarily unavailable' }
+        })
+      );
+
+      const sabs = new 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 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, 'request');
+      mockAxios.mockRejectedValue(
+        new AxiosError('Unauthorized', 'UNAUTHORIZED', undefined, undefined, {
+          headers: {},
+          config: {
+            headers: new AxiosHeaders()
+          },
+          status: 401,
+          statusText: 'Unauthorized',
+          data: { message: 'Invalid token' }
+        })
+      );
+
+      const sabs = new 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 import('./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, 'request');
+        mockAxios.mockRejectedValue(
+          new AxiosError('Bad Request', 'BAD_REQUEST', undefined, undefined, {
+            headers: {},
+            config: {
+              headers: new AxiosHeaders()
+            },
+            status: 400,
+            statusText: 'Bad Request',
+            data: { message: 'Directory hash is required' }
+          })
+        );
+
+        const sabs = new SabsClient('http://localhost:3000');
+
+        try {
+          await sabs.build({
+            directoryHash: 'test', // Use non-empty value to avoid client-side validation
+            meta: new 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, 'request');
+        mockAxios.mockRejectedValue(
+          new AxiosError('Internal Server Error', 'INTERNAL_SERVER_ERROR', undefined, undefined, {
+            headers: {},
+            config: {
+              headers: new AxiosHeaders()
+            },
+            status: 500,
+            statusText: 'Internal Server Error',
+            data: 'Database connection failed'
+          })
+        );
+
+        const sabs = new SabsClient('http://localhost:3000');
+
+        try {
+          await sabs.build({
+            directoryHash: 'test',
+            meta: new 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, 'request');
+        mockAxios.mockRejectedValue(
+          new AxiosError('Service Unavailable', 'SERVICE_UNAVAILABLE', undefined, undefined, {
+            headers: {},
+            config: {
+              headers: new AxiosHeaders()
+            },
+            status: 503,
+            statusText: 'Service Unavailable',
+            data: null
+          })
+        );
+
+        const sabs = new SabsClient('http://localhost:3000');
+
+        try {
+          await sabs.build({
+            directoryHash: 'test',
+            meta: new 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, 'request');
+        mockAxios.mockRejectedValue(
+          new AxiosError('Gateway Timeout', 'GATEWAY_TIMEOUT', undefined, undefined, {
+            headers: {},
+            config: {
+              headers: new AxiosHeaders()
+            },
+            status: 504,
+            statusText: 'Gateway Timeout',
+            data: undefined
+          })
+        );
+
+        const sabs = new SabsClient('http://localhost:3000');
+
+        try {
+          await sabs.build({
+            directoryHash: 'test',
+            meta: new 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, 'request');
+        mockAxios.mockRejectedValue(
+          new AxiosError('Bad Request', 'BAD_REQUEST', undefined, undefined, {
+            headers: {},
+            config: {
+              headers: new AxiosHeaders()
+            },
+            status: 400,
+            statusText: 'Bad Request',
+            data: { error: 'validation_failed', details: ['field is required'] }
+          })
+        );
+
+        const sabs = new SabsClient('http://localhost:3000');
+
+        try {
+          await sabs.build({
+            directoryHash: 'test',
+            meta: new 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, 'request');
+        mockAxios.mockRejectedValue(
+          new AxiosError('Request timeout', 'TIMEOUT', undefined, undefined, {
+            headers: {},
+            config: {
+              headers: new AxiosHeaders()
+            },
+            status: 500,
+            statusText: 'Internal Server Error',
+            data: responseData
+          })
+        );
+
+        const sabs = new SabsClient('http://localhost:3000');
+
+        try {
+          await sabs.build({
+            directoryHash: 'test',
+            meta: new 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');
+          }
+        }
+      });
+    });
+  });
+});