@superblocksteam/sabs-client 0.152.0 → 0.154.0

package/src/sabs.test.ts

@@ -17,22 +17,57 @@ describe('sabs service', () => {
   });
 
   describe('build', () => {
-    test.each([
-      { accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } },
-      { accessToken: undefined, expectedHeaders: undefined }
-    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
-      const expectedBuildId = 'expectedBuildId';
-      const expectedCreated = new Date();
-      const expectedUpdated = new Date();
+    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 mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
+        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({
@@ -41,22 +76,14 @@ describe('sabs service', () => {
       });
 
       const sabs = new SabsClient('http://localhost:3000');
-      const result = await sabs.build({
-        directoryHash: anyDirectoryHash,
-        meta: anyApplicationMetadata,
-        buildKey: anyBuildKey,
-        accessToken
-      });
+      await expect(
+        sabs.build({ directoryHash: anyDirectoryHash, meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: anyAccessToken })
+      ).rejects.toThrow();
 
-      expect(result).toEqual({
-        buildId: expectedBuildId,
-        created: expectedCreated,
-        updated: expectedUpdated
-      });
       expect(mockAxios).toHaveBeenCalledWith({
         method: 'POST',
         url: 'http://localhost:3000/v1/builds',
-        headers: expectedHeaders,
+        headers: { Authorization: `Bearer ${anyAccessToken}` },
         data: {
           directoryHash: anyDirectoryHash,
           applicationMetadata: anyApplicationMetadata,
@@ -65,68 +92,109 @@ describe('sabs service', () => {
       });
     });
 
-    test('raises error when request fails', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockRejectedValue(new Error('any error'));
+    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();
+    });
 
-      const anyDirectoryHash = 'anyDirectoryHash';
+    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');
-      await expect(sabs.build({ directoryHash: anyDirectoryHash, meta: anyApplicationMetadata, buildKey: anyBuildKey })).rejects.toThrow();
+      const anyApplicationMetadata = new ApplicationMetadata({
+        id: '',
+        organizationId: 'anyOrganizationId'
+      });
+      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',
-        data: {
-          directoryHash: anyDirectoryHash,
-          applicationMetadata: anyApplicationMetadata,
-          buildKey: anyBuildKey
-        }
+    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' } },
-      { accessToken: undefined, expectedHeaders: undefined }
-    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
-      const expectedBuildId = 'expectedBuildId';
-      const expectedStatus = BuildStatus.SUCCESS;
-      const expectedCreated = new Date();
-      const expectedUpdated = new Date();
+    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 mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
+        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
-        }
-      });
-
-      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
-      });
-    });
+        });
+        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');
@@ -135,23 +203,70 @@ describe('sabs service', () => {
       const anyBuildId = 'anyBuildId';
 
       const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: anyBuildId })).rejects.toThrow();
+      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' } },
-      { accessToken: undefined, expectedHeaders: undefined }
-    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
+    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',
@@ -173,55 +288,19 @@ describe('sabs service', () => {
               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
           }
-        ]
-      });
-      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');
@@ -236,14 +315,15 @@ describe('sabs service', () => {
         sabs.list({
           organizationId: anyOrganizationId,
           applicationId: anyApplicationId,
-          directoryHash: anyDirectoryHash
+          directoryHash: anyDirectoryHash,
+          accessToken: anyAccessToken
         })
       ).rejects.toThrow();
 
       expect(mockAxios).toHaveBeenCalledWith({
         method: 'GET',
         url: `http://localhost:3000/v1/build`,
-        headers: undefined,
+        headers: { Authorization: `Bearer ${anyAccessToken}` },
         params: {
           organizationId: anyOrganizationId,
           applicationId: anyApplicationId,
@@ -251,48 +331,123 @@ describe('sabs service', () => {
         }
       });
     });
+
+    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' } },
-      { accessToken: undefined, expectedHeaders: undefined }
-    ])('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();
+    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 mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
+        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');
-      const result = await sabs.terminate({ buildId: anyBuildId, status: anyStatus, buildKey: anyBuildKey, error: anyError, accessToken });
+      await expect(
+        sabs.terminate({ buildId: anyBuildId, status: anyStatus, buildKey: anyBuildKey, error: anyError, accessToken: anyAccessToken })
+      ).rejects.toThrow();
 
-      expect(result).toEqual({
-        buildId: expectedBuildId,
-        status: expectedStatus,
-        error: expectedError,
-        created: expectedCreated,
-        updated: expectedUpdated
-      });
       expect(mockAxios).toHaveBeenCalledWith({
         method: 'POST',
+        headers: { Authorization: `Bearer ${anyAccessToken}` },
         url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
-        headers: expectedHeaders,
         data: {
           buildId: anyBuildId,
           status: anyStatus,
@@ -302,27 +457,56 @@ describe('sabs service', () => {
       });
     });
 
-    test('raises error when request fails', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockRejectedValue(new Error('any error'));
+    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();
+    });
 
-      const anyBuildId = 'anyBuildId';
-      const anyStatus = BuildStatus.TIMED_OUT;
-      const anyError = 'build timed out';
+    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: anyStatus, buildKey: anyBuildKey, error: anyError })).rejects.toThrow();
+      await expect(
+        sabs.terminate({
+          buildId: 'anyBuildId',
+          status: BuildStatus.TIMED_OUT,
+          buildKey: '',
+          error: 'build timed out',
+          accessToken: anyAccessToken
+        })
+      ).rejects.toThrow();
+    });
 
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
-        data: {
-          buildId: anyBuildId,
-          status: anyStatus,
-          error: anyError,
-          buildKey: anyBuildKey
-        }
-      });
+    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();
     });
   });
 
@@ -356,7 +540,8 @@ describe('sabs service', () => {
       const result = await sabs.bulkStatus({
         organizationId: anyOrganizationId,
         applicationId: anyApplicationId,
-        directoryHashes: anyDirectoryHashes
+        directoryHashes: anyDirectoryHashes,
+        accessToken: anyAccessToken
       });
 
       expect(result).toEqual({
@@ -377,6 +562,7 @@ describe('sabs service', () => {
       });
       expect(mockAxios).toHaveBeenCalledWith({
         method: 'POST',
+        headers: { Authorization: `Bearer ${anyAccessToken}` },
         url: `http://localhost:3000/v1/builds/${anyOrganizationId}/${anyApplicationId}/bulk-status`,
         data: {
           organizationId: anyOrganizationId,
@@ -385,6 +571,54 @@ describe('sabs service', () => {
         }
       });
     });
+
+    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', () => {
@@ -392,6 +626,58 @@ describe('sabs service', () => {
     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;
@@ -472,6 +758,16 @@ describe('sabs service', () => {
       });
     });
 
+    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'));
@@ -514,7 +810,7 @@ describe('sabs service', () => {
       const expectedError = 'sabs service request failed: request failed\n[500] internal server error: "failed to process request"';
 
       const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: anyBuildId })).rejects.toThrow(expectedError);
+      await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow(expectedError);
     });
 
     test('re-raises error when error is not axios error', async () => {
@@ -526,7 +822,7 @@ describe('sabs service', () => {
       const expectedError = 'sabs service request failed: unexpected error';
 
       const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: anyBuildId })).rejects.toThrow(expectedError);
+      await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow(expectedError);
     });
   });
 });