@symbo.ls/sdk 3.2.3 → 3.2.7

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

@@ -0,0 +1,87 @@
+/* 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('listBranches should return response data', 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)
+  const response = await branchServiceStub.listBranches(testProjectId)
+  t.equal(
+    response,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+function checkProjectIdValidation () {
+  const badData = [
+    {
+      name: 'No Project ID'
+    },
+    {
+      name: 'Empty string',
+      value: ''
+    },
+    {
+      name: 'False boolean value',
+      value: false
+    },
+    {
+      name: 'Undefined value',
+      value: undefined
+    },
+    {
+      name: 'Null value',
+      value: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Project ID validation should throw an error when: ${badData[ii].name} is passed in`, async t => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const testProjectId = badData[ii].value
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.listBranches(testProjectId)
+        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].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+checkProjectIdValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,210 @@
+/* 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('mergeBranch should return response data', async (t) => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchDataMock = {
+    name: 'Test_Branch_Name'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  const response = await branchServiceStub.mergeBranch(
+    testProjectId,
+    branchDataMock.name
+  )
+  t.equal(
+    response,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('mergeBranch should handle error', async (t) => {
+  t.plan(1)
+  const branchDataMock = {
+    name: 'Test_Branch_Name'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').throws('Test Error')
+  try {
+    await branchServiceStub.mergeBranch(testProjectId, branchDataMock.name)
+    t.fail('mergeBranch successfully failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to merge branch: Sinon-provided Test Error',
+      'Actual error matches expected error'
+    )
+  }
+  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'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.mergeBranch(testProjectId, branchDataMock.name)
+        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',
+      name: ''
+    },
+    {
+      testName: 'False boolean value',
+      name: false
+    },
+    {
+      testName: 'Undefined value',
+      name: undefined
+    },
+    {
+      testName: 'Null value',
+      name: 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.mergeBranch(testProjectId, badData[ii].name)
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Source branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function checkMergeConflictErrorHandling () {
+  const mergeError = [
+    {
+      name: 'merge conflict error',
+      value: 'conflicts',
+      expectedError: 'Error: Merge conflicts detected: Sinon-provided conflicts'
+    },
+    {
+      name: '409 Conflict client error',
+      value: '409',
+      expectedError: 'Error: Merge conflicts detected: Sinon-provided 409'
+    }
+  ]
+  for (let ii = 0; ii < mergeError.length; ii++) {
+    test(`mergeBranch should handle ${mergeError[ii].name}`, async (t) => {
+      t.plan(1)
+      const branchDataMock = {
+        name: 'Test_Branch_Name'
+      }
+      const testProjectId = 'Test Project ID'
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').throws(mergeError[ii].value)
+      try {
+        await branchServiceStub.mergeBranch(testProjectId, branchDataMock.name)
+        t.fail('mergeBranch successfully failed')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          mergeError[ii].expectedError,
+          'Actual error matches expected error'
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkBranchDataNameValidation()
+checkProjectIdValidation()
+checkMergeConflictErrorHandling()
+// #endregion
+
+// #region Cleanup
+test('teardown', (t) => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,183 @@
+/* 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('publishVersion should return response data', async (t) => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const publishVersionMock = {
+    name: 'Test_Branch_Name',
+    version: '1.0.0',
+    branch: '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.publishVersion(
+    testProjectId,
+    publishVersionMock
+  )
+  t.equal(
+    response,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('publishVersion should return response data', async (t) => {
+  t.plan(1)
+  const publishVersionMock = {
+    name: 'Test_Branch_Name',
+    version: '1.0.0',
+    branch: 'main'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').throws('Test Error')
+  try {
+    await branchServiceStub.publishVersion(testProjectId, publishVersionMock)
+    t.fail('publish version threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to publish version: Sinon-provided Test Error',
+      'Actual error matches expected error'
+    )
+  }
+  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 publishVersionMock = {
+        name: 'Test_Branch_Name',
+        version: '1.0.0',
+        branch: 'main'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.publishVersion(
+          testProjectId,
+          publishVersionMock
+        )
+        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',
+      branch: 'main'
+    },
+    {
+      testName: 'Empty string',
+      version: '',
+      branch: 'main'
+    },
+    {
+      testName: 'False boolean value',
+      version: false,
+      branch: 'main'
+    },
+    {
+      testName: 'Undefined value',
+      version: undefined,
+      branch: 'main'
+    },
+    {
+      testName: 'Null value',
+      version: null,
+      branch: 'main'
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`publishData version 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.publishVersion(testProjectId, badData[ii])
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Version is required',
+          `publishData version 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/BranchService/renameBranch.test.js

@@ -0,0 +1,240 @@
+/* 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('renameBranch should return response data', async t => {
+  t.plan(2)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchDataMock = {
+    name: 'Test_Branch_Name',
+    branch: 'not_main'
+  }
+  const testProjectId = 'Test Project ID'
+  const testNewBranchName = 'Test_New_Branch_Name'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  const response = await branchServiceStub.renameBranch(
+    testProjectId,
+    branchDataMock.branch,
+    testNewBranchName
+  )
+  t.ok(response.success, 'Response successfully returned')
+  t.equal(
+    response.data,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('Branch name validation should throw an error when the branch is main', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  try {
+    await branchServiceStub.renameBranch(
+      'Test Project ID',
+      'main',
+      'Test_New_Branch_Name'
+    )
+    t.fail('Branch name validation threw an error with an invalid value')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Cannot rename main branch',
+      'renameBranch successfully threw an error when the main branch is deleted'
+    )
+  }
+  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',
+        branch: 'not_main'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.renameBranch(
+          testProjectId,
+          branchDataMock.branch,
+          'Test_New_Branch_Name'
+        )
+        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',
+      name: ''
+    },
+    {
+      testName: 'False boolean value',
+      name: false
+    },
+    {
+      testName: 'Undefined value',
+      name: undefined
+    },
+    {
+      testName: 'Null value',
+      name: 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.renameBranch(
+          testProjectId,
+          badData[ii].name,
+          'Test_New_Branch_Name'
+        )
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Current branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function checkNewBranchNameValidation () {
+  const badData = [
+    {
+      testName: 'No name'
+    },
+    {
+      testName: 'Empty string',
+      name: ''
+    },
+    {
+      testName: 'False boolean value',
+      name: false
+    },
+    {
+      testName: 'Undefined value',
+      name: undefined
+    },
+    {
+      testName: 'Null value',
+      name: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`New 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 branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.renameBranch(
+          'Test Project ID',
+          'Test_Branch_Name',
+          badData[ii].name
+        )
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: New branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkBranchDataNameValidation()
+checkNewBranchNameValidation()
+checkProjectIdValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion