@symbo.ls/sdk 2.34.35 → 3.1.1

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

@@ -1,152 +0,0 @@
-/* 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

@@ -1,67 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,69 +0,0 @@
-/* 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

@@ -1,109 +0,0 @@
-/* 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

@@ -1,36 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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