@symbo.ls/sdk 3.2.3 → 3.2.6

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/FileService/uploadMultipleFiles.test.js

@@ -0,0 +1,111 @@
+/* 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('uploadMultipleFiles should return response data', async t => {
+  t.plan(3)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const firstMockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const secondMockFile = new File(['file contents'], 'filename1.txt', {
+    type: 'text/*'
+  })
+  const files = [firstMockFile, secondMockFile]
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadMultipleFiles(files)
+  t.equal(
+    response.length,
+    2,
+    'Actual number of uploaded files matches expected number of files'
+  )
+  t.ok(
+    response[0].success,
+    'response for first file uploaded successfully returned'
+  )
+  t.ok(
+    response[1].success,
+    'response for second file uploaded successfully returned'
+  )
+  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.uploadMultipleFiles()
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Files array is required and must not be empty',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+function checkFileTypeValidation () {
+  const badData = [
+    { name: 'Number value', value: 123 },
+    { name: 'False boolean value', value: false },
+    { name: 'True boolean value', value: true },
+    { name: 'Empty String value', value: '' },
+    { name: 'Object value', value: {} },
+    { name: 'Null value', value: null },
+    { name: 'Undefined value', value: undefined }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`file validation should throw an error when: ${badData[ii].name} 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.uploadMultipleFiles(badData[ii].value)
+        t.fail('file validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Files array is required and must not be empty',
+          `file validation successfully threw an error when: ${badData[ii].name} was uploaded.`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkFileTypeValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,63 @@
+import test from 'tape'
+import { FileService } from '../../FileService.js'
+
+// #region Tests
+test('validateFile should return a good file url', t => {
+  t.plan(1)
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile)
+  t.ok(response.length === 0, 'Empty array of errors is succesfully returned')
+  t.end()
+})
+
+test('file validation should return an error', t => {
+  t.plan(1)
+  const mockFile = false
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile)
+  t.equal(
+    response[0],
+    'File is required',
+    'File validation successfully threw an error'
+  )
+  t.end()
+})
+
+test('size validation should return an error', t => {
+  t.plan(1)
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const mockOptions = {
+    maxSize: 1
+  }
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile, mockOptions)
+  t.ok(
+    response[0].includes('File size (0.00MB) exceeds maximum allowed size of '),
+    'Size validation successfully threw an error'
+  )
+  t.end()
+})
+
+test('allowedTypes validation should return an error', t => {
+  t.plan(1)
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const mockOptions = {
+    allowedTypes: ['test123']
+  }
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile, mockOptions)
+  t.equal(
+    response[0],
+    "File type 'text/*' is not allowed. Allowed types: test123",
+    'allowedTypes validation should return an error'
+  )
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,104 @@
+/* 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('createPlan should return response data', async t => {
+  t.plan(1)
+
+  const planDataStub = {
+    success: true,
+    data: sandbox.stub()
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(planDataStub)
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+  const response = await planServiceStub.createPlan([])
+  t.equal(response, planDataStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+function planDataValidation () {
+  const badData = {
+    falseValue: false,
+    undefinedValue: undefined,
+    stringValue: 'testString'
+  }
+  Object.keys(badData).forEach(key => {
+    test(`createPlan should return an error for ${key} - Plan data is required`, async t => {
+      t.plan(1)
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+      try {
+        await planServiceStub.createPlan(badData[key])
+        t.fail('createPlan should have failed')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Plan data is required',
+          'Error correctly returned'
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  })
+}
+
+test('createPlan should return an error - Failed to parse URL', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+  try {
+    await planServiceStub.createPlan([])
+    t.fail('createPlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to create plan: Request failed: Failed to parse URL from null/core/admin/plans',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('createPlan should fail the requireReady', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox
+    .stub(planServiceStub, '_requireReady')
+    .throws(() => new Error('Service not initialized for method: createPlan'))
+
+  try {
+    await planServiceStub.createPlan()
+    t.fail('createPlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Service not initialized for method: createPlan',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+planDataValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion