@symbo.ls/sdk 3.1.2 → 3.2.6

package/src/services/tests/BranchService/resetBranch.test.js

@@ -0,0 +1,152 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { BranchService } from '../../BranchService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('resetBranch should return response data', async (t) => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchDataMock = {
+    name: 'Test_Branch_Name',
+    branchName: 'main'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  const response = await branchServiceStub.resetBranch(
+    testProjectId,
+    branchDataMock.branchName
+  )
+  t.equal(
+    response,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+function checkProjectIdValidation () {
+  const badData = [
+    {
+      testName: 'No Project ID'
+    },
+    {
+      testName: 'Empty string',
+      projectId: ''
+    },
+    {
+      testName: 'False boolean value',
+      projectId: false
+    },
+    {
+      testName: 'Undefined value',
+      projectId: undefined
+    },
+    {
+      testName: 'Null value',
+      projectId: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Project ID validation should throw an error when: ${badData[ii].testName} is passed in`, async (t) => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const branchDataMock = {
+        name: 'Test_Branch_Name',
+        branchName: 'main'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.resetBranch(testProjectId, branchDataMock)
+        t.fail('Project ID validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Project ID is required',
+          `Project ID validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function checkBranchDataNameValidation () {
+  const badData = [
+    {
+      testName: 'No name'
+    },
+    {
+      testName: 'Empty string',
+      branchName: ''
+    },
+    {
+      testName: 'False boolean value',
+      branchName: false
+    },
+    {
+      testName: 'Undefined value',
+      branchName: undefined
+    },
+    {
+      testName: 'Null value',
+      branchName: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Branch name validation should throw an error when: ${badData[ii].testName} is passed in`, async (t) => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const testProjectId = 'Test Project ID'
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.resetBranch(
+          testProjectId,
+          badData[ii].branchName
+        )
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkBranchDataNameValidation()
+checkProjectIdValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', (t) => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/FeatureFlagService/adminFeatureFlags.test.js

@@ -0,0 +1,67 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FeatureFlagService } from '../../FeatureFlagService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getAdminFeatureFlags should pass includeArchived=false', async t => {
+  t.plan(1)
+  const responseStub = { success: true, data: [] }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  const requestStub = sandbox.stub(service, '_request').resolves(responseStub)
+
+  await service.getAdminFeatureFlags({ includeArchived: false })
+  t.equal(
+    requestStub.firstCall.args[0],
+    '/admin/feature-flags?includeArchived=false',
+    'includeArchived=false included'
+  )
+
+  sandbox.restore()
+  t.end()
+})
+
+test('createFeatureFlag should require key', async t => {
+  t.plan(1)
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+
+  try {
+    await service.createFeatureFlag({ enabled: true })
+    t.fail('Expected createFeatureFlag to throw without key')
+  } catch (err) {
+    t.equal(err.toString(), 'Error: Feature flag key is required', 'Key validation works')
+  }
+
+  sandbox.restore()
+  t.end()
+})
+
+test('updateFeatureFlag should require id', async t => {
+  t.plan(1)
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+
+  try {
+    await service.updateFeatureFlag(null, { enabled: false })
+    t.fail('Expected updateFeatureFlag to throw without id')
+  } catch (err) {
+    t.equal(err.toString(), 'Error: Feature flag id is required', 'Id validation works')
+  }
+
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+

package/src/services/tests/FeatureFlagService/getFeatureFlags.test.js

@@ -0,0 +1,75 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FeatureFlagService } from '../../FeatureFlagService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getFeatureFlags should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: { flags: { new_ui: { enabled: true, variant: null, payload: null } } }
+  }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  sandbox.stub(service, '_request').resolves(responseStub)
+
+  const response = await service.getFeatureFlags()
+  t.equal(response, responseStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getFeatureFlags should pass keys query param', async t => {
+  t.plan(1)
+  const responseStub = { success: true, data: { flags: {} } }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  const requestStub = sandbox.stub(service, '_request').resolves(responseStub)
+
+  await service.getFeatureFlags({ keys: ['new_ui', 'checkout_experiment'] })
+  t.ok(
+    requestStub.firstCall.args[0].includes('/feature-flags?keys=new_ui%2Ccheckout_experiment'),
+    'Keys query param included'
+  )
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getFeatureFlags should return an error', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: false,
+    data: {},
+    message: 'Negative getFeatureFlags Test'
+  }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  sandbox.stub(service, '_request').resolves(responseStub)
+
+  try {
+    await service.getFeatureFlags()
+  } catch (err) {
+    t.ok(
+      err.toString().includes(`Failed to get feature flags: ${responseStub.message}`),
+      'Error correctly returned'
+    )
+  }
+
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+

package/src/services/tests/FileService/createFileFormData.test.js

@@ -0,0 +1,74 @@
+import test from 'tape'
+import { FileService } from '../../FileService.js'
+
+// #region Tests
+test('createFileFormData should return a basic formData object', t => {
+  t.plan(3)
+  const mockFileData = {
+    size: 13,
+    type: 'text/*',
+    name: 'filename.txt'
+  }
+  const mockFile = new File(['file contents'], mockFileData.name, {
+    type: mockFileData.type
+  })
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.createFileFormData(mockFile)
+  t.equal(
+    Array.from(response)[0][1].size,
+    mockFileData.size,
+    'Actual file size matches expected file size'
+  )
+  t.equal(
+    Array.from(response)[0][1].type,
+    mockFileData.type,
+    'Actual file type matches expected file type'
+  )
+  t.equal(
+    Array.from(response)[0][1].name,
+    mockFileData.name,
+    'Actual file name matches expected file name'
+  )
+  t.end()
+})
+
+test('createFileFormData should return a formData object with metadata', t => {
+  t.plan(4)
+  const mockFileData = {
+    size: 13,
+    type: 'text/*',
+    name: 'filename.txt'
+  }
+  const mockFile = new File(['file contents'], mockFileData.name, {
+    type: mockFileData.type
+  })
+  const mockMetaData = {
+    name: 'Test Name',
+    description: 'Test Description',
+    key: 'Test Key'
+  }
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.createFileFormData(mockFile, mockMetaData)
+  t.equal(
+    Array.from(response)[0][1].size,
+    mockFileData.size,
+    'Actual file size matches expected file size'
+  )
+  t.equal(
+    Array.from(response)[0][1].type,
+    mockFileData.type,
+    'Actual file type matches expected file type'
+  )
+  t.equal(
+    Array.from(response)[0][1].name,
+    mockFileData.name,
+    'Actual file name matches expected file name'
+  )
+  t.equal(
+    Array.from(response)[1][1],
+    JSON.stringify(mockMetaData),
+    'Actual metadata matches expected metadata'
+  )
+  t.end()
+})
+// #endregion

package/src/services/tests/FileService/getFileUrl.test.js

@@ -0,0 +1,69 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import { FileService } from '../../FileService.js'
+import { BaseService } from '../../BaseService.js'
+
+// #region Tests
+test('getFileUrl should return a good file url', t => {
+  t.plan(1)
+  const mockFileId = 'testFileId'
+  const fileServiceStub = new FileService()
+  const baseServiceStub = new BaseService()
+  const response = fileServiceStub.getFileUrl(mockFileId)
+  t.equal(
+    response,
+    `${baseServiceStub._apiUrl}/core/files/public/${mockFileId}/download`,
+    'Actual file url matches expected file url'
+  )
+  t.end()
+})
+
+function testFileIdValidation () {
+  const badData = [
+    {
+      name: 'Empty String',
+      fileId: ''
+    },
+    {
+      name: 'Undefined',
+      fileId: undefined
+    },
+    {
+      name: 'Null',
+      fileId: null
+    },
+    {
+      name: 'False boolean value',
+      fileId: false
+    },
+    {
+      name: 'True boolean value',
+      fileId: true
+    },
+    {
+      name: 'Object',
+      fileId: {}
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`fileId validation should throw an error when fileId value is: ${badData[ii].name}`, t => {
+      t.plan(1)
+      const mockFileId = null
+      const fileServiceStub = new FileService()
+      try {
+        fileServiceStub.getFileUrl(mockFileId)
+        t.fail('file ID successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: File ID is required',
+          `file ID validation successfully threw an error when fileId is: ${badData[ii].name}`
+        )
+      }
+      t.end()
+    })
+  }
+}
+
+testFileIdValidation()
+// #endregion

package/src/services/tests/FileService/updateProjectIcon.test.js

@@ -0,0 +1,109 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('updateProjectIcon should return response data', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const projectIdStub = sandbox.stub()
+  const iconStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  const response = await fileServiceStub.updateProjectIcon(
+    projectIdStub,
+    iconStub
+  )
+  t.equal(
+    response,
+    uploadFileResponseStub.data,
+    'Response data matches stubbed data'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('projectId validation should throw an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const iconStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  try {
+    await fileServiceStub.updateProjectIcon(undefined, iconStub)
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Project ID and icon file are required',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('iconFile validation should throw an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const projectIdStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  try {
+    await fileServiceStub.updateProjectIcon(projectIdStub)
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Project ID and icon file are required',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('updateProjectIcon error handling catches and returns an error', async t => {
+  t.plan(1)
+  const projectIdStub = sandbox.stub()
+  const iconStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  sandbox.stub(fileServiceStub, '_request').throws('Test Error')
+  try {
+    await fileServiceStub.updateProjectIcon(projectIdStub, iconStub)
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to update project icon: Sinon-provided Test Error',
+      'Error handling caught and returned the correct error.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/FileService/uploadDocument.test.js

@@ -0,0 +1,36 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadDocument should return response data', async t => {
+  t.plan(2)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'application/pdf'
+  })
+  const fileServiceStub = new FileService()
+  const uploadFileStub = sandbox
+    .stub(fileServiceStub, 'uploadFileWithValidation')
+    .resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadImage(mockFile)
+  t.ok(response.success, 'response successfully returned')
+  t.ok(uploadFileStub.calledOnce, 'uploadFileStub called once')
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/FileService/uploadFile.test.js

@@ -0,0 +1,78 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadFile should return response data', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const file = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  const response = await fileServiceStub.uploadFile(file)
+  t.equal(
+    response,
+    uploadFileResponseStub.data,
+    'Response data matches stubbed data'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('file validation should throw an error when no file is uploaded', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  try {
+    await fileServiceStub.uploadFile()
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: File is required for upload',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('uploadFile error handling catches and returns an error', async t => {
+  t.plan(1)
+  const file = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  sandbox.stub(fileServiceStub, '_request').throws('Test Error')
+  try {
+    await fileServiceStub.uploadFile(file)
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: File upload failed: Sinon-provided Test Error',
+      'Error handling caught and returned the correct error.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion