@symbo.ls/sdk 2.34.4 → 2.34.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.34.4",
+  "version": "2.34.6",
   "type": "module",
   "main": "dist/esm/index.js",
   "module": "dist/esm/index.js",
@@ -46,12 +46,12 @@
     "test:user": "cross-env NODE_ENV=$NODE_ENV npx tape integration-tests/index.js integration-tests/user/*.test.js | tap-spec"
   },
   "dependencies": {
-    "@domql/element": "^2.34.4",
-    "@domql/utils": "^2.34.4",
+    "@domql/element": "^2.34.6",
+    "@domql/utils": "^2.34.6",
     "@grafana/faro-web-sdk": "^1.19.0",
     "@grafana/faro-web-tracing": "^1.19.0",
-    "@symbo.ls/router": "^2.34.4",
-    "@symbo.ls/socket": "^2.34.4",
+    "@symbo.ls/router": "^2.34.6",
+    "@symbo.ls/socket": "^2.34.6",
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
     "dexie": "^4.0.11",
@@ -74,5 +74,5 @@
     "tap-spec": "^5.0.0",
     "tape": "^5.9.0"
   },
-  "gitHead": "24af4cb709642223c3fa555fa6fb954570c31b6b"
+  "gitHead": "d0ceab62f9a7fd775f741821b28efb4facf3b4fb"
 }

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

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

@@ -0,0 +1,114 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadFileWithValidation 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: 'text/*'
+  })
+  const fileServiceStub = new FileService()
+  const uploadFileStub = sandbox
+    .stub(fileServiceStub, 'uploadFile')
+    .resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadFileWithValidation(mockFile)
+  t.ok(response.success, 'response successfully returned')
+  t.ok(uploadFileStub.calledOnce, 'uploadFileStub called once')
+  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, 'uploadFile').resolves(uploadFileResponseStub)
+  try {
+    await fileServiceStub.uploadFileWithValidation()
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: File is required',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('file size validation throws an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const options = {
+    maxSize: 1
+  }
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  try {
+    await fileServiceStub.uploadFileWithValidation(mockFile, options)
+    t.fail('file size validation successfully threw an error')
+  } catch (err) {
+    t.ok(
+      err
+        .toString()
+        .includes('Error: File size exceeds maximum allowed size of ')
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('isValid type check throws an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const options = {
+    allowedTypes: ['test type']
+  }
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  try {
+    await fileServiceStub.uploadFileWithValidation(mockFile, options)
+    t.fail('isValid check successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      "Error: File type 'text/*' is not allowed. Allowed types: test type",
+      'isValid check succeeded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/FileService/uploadImage.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('uploadImage 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: 'image/*'
+  })
+  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/PlanService/getPlanByKey.test.js

@@ -0,0 +1,109 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getPlanByKey should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    key: 'test123'
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').resolves([responseStub])
+  const response = await planServiceStub.getPlanByKey('test123')
+  t.equal(response.key, responseStub.key, 'Response data matches stubbed data')
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlanByKey should return a key not found error', async t => {
+  t.plan(1)
+  const responseStub = {
+    key: 'test123'
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').resolves([responseStub])
+  try {
+    await planServiceStub.getPlanByKey('wrongKey123')
+    t.fail('getPlanByKey key validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      "Error: Failed to get plan by key: Plan with key 'wrongKey123' not found",
+      'Plan key not found validation successfully threw an error for a wrong key entered.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlanByKey error handling catches and returns an error', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').throws('Test Error')
+  try {
+    await planServiceStub.getPlanByKey('test123')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to get plan by key: Sinon-provided Test Error',
+      'Error handling caught and returned the correct error.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+function checkPlanKeyIsRequired () {
+  const badPlanKeys = [
+    {
+      name: 'an undefined value',
+      key: undefined
+    },
+    {
+      name: 'a null',
+      key: null
+    },
+    {
+      name: 'an empty string',
+      key: ''
+    }
+  ]
+  for (let ii = 0; ii < badPlanKeys.length; ii++) {
+    test(`getPlanByKey should demand a Plan key when the key entered is ${badPlanKeys[ii].name}`, async t => {
+      t.plan(1)
+      const responseStub = {
+        key: 'test123'
+      }
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'getPlans').resolves([responseStub])
+      try {
+        await planServiceStub.getPlanByKey(badPlanKeys[ii].key)
+        t.fail('getPlanByKey key validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Plan key is required',
+          `Key requirement validation successfully threw an error when ${badPlanKeys[ii].name} key is entered.`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkPlanKeyIsRequired()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/PlanService/getPlansByPriceRange.test.js

@@ -0,0 +1,109 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getPlans should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    pricing: {
+      bestPrice: {
+        amount: 1
+      }
+    }
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlansWithPricing').resolves([responseStub])
+  const response = await planServiceStub.getPlansByPriceRange()
+  t.equal(
+    response[0].pricing.bestPrice.amount,
+    responseStub.pricing.bestPrice.amount,
+    'Response data matches stubbed data'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+function noPricingAmount () {
+  const noPriceAmounts = [
+    {
+      name: 'undefined',
+      amount: undefined
+    },
+    {
+      name: 'null',
+      amount: null
+    },
+    {
+      name: 'less than the minimum',
+      amount: 1
+    },
+    {
+      name: 'more than the maximum',
+      amount: 20
+    },
+    {
+      name: 'a string',
+      amount: 'test string'
+    },
+    {
+      name: 'an object',
+      amount: {}
+    }
+  ]
+  for (let ii = 0; ii < noPriceAmounts.length; ii++) {
+    test(`getPlansWithPricing should return an empty response when the amount entered is ${noPriceAmounts[ii].name}`, async t => {
+      t.plan(1)
+      const responseStub = {
+        pricing: {
+          bestPrice: {}
+        }
+      }
+      responseStub.pricing.bestPrice.amount = noPriceAmounts[ii].amount
+      const planServiceStub = new PlanService()
+      sandbox
+        .stub(planServiceStub, 'getPlansWithPricing')
+        .resolves([responseStub])
+      const response = await planServiceStub.getPlansByPriceRange(5, 10)
+      t.equal(
+        response.length,
+        0,
+        `Response is an empty array when entered amount is: ${responseStub.pricing.bestPrice.amount}`
+      )
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+test('getPlans should return an error', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlansWithPricing').throws('Test Error')
+  try {
+    await planServiceStub.getPlansByPriceRange()
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to get plans by price range: Sinon-provided Test Error',
+      'Error caught and correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+noPricingAmount()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion