@symbo.ls/sdk 2.33.26 → 2.33.27

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

@@ -0,0 +1,92 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('deletePlan 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.deletePlan(true)
+  t.equal(response, planDataStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('deletePlan should return an error - Plan ID required', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+  try {
+    await planServiceStub.deletePlan(false)
+    t.fail('deletePlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Plan ID is required',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('deletePlan 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.deletePlan(true)
+    t.fail('deletePlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to delete plan: Request failed: Failed to parse URL from null/core/admin/plans/true',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('deletePlan 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: deletePlan'))
+
+  try {
+    await planServiceStub.deletePlan()
+    t.fail('deletePlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Service not initialized for method: deletePlan',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,84 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getAdminPlans should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: sandbox.stub()
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+  const response = await planServiceStub.getAdminPlans()
+  t.equal(response, responseStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getAdminPlans should return an error', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: false,
+    data: sandbox.stub(),
+    message: 'Negative getAdminPlans Test'
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+  try {
+    await planServiceStub.getAdminPlans()
+  } catch (err) {
+    t.ok(
+      err
+        .toString()
+        .includes(`Failed to get admin plans: ${responseStub.message}`),
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('getAdminPlans should fail the requireReady', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: false,
+    data: sandbox.stub(),
+    message: 'Service not initialized for method: getAdminPlans'
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+  sandbox
+    .stub(planServiceStub, '_requireReady')
+    .throws(() => new Error(responseStub.message))
+
+  try {
+    await planServiceStub.getAdminPlans()
+    t.fail('getAdminPlans should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      `Error: ${responseStub.message}`,
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,50 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getPlan should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: sandbox.stub()
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+  const response = await planServiceStub.getPlan(true)
+  t.equal(response, responseStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlan should return an error', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: false,
+    data: sandbox.stub(),
+    message: 'Error: Plan ID is required'
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+
+  try {
+    await planServiceStub.getPlan()
+  } catch (err) {
+    t.equal(err.toString(), responseStub.message, 'Error correctly returned')
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,85 @@
+/* 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('getPlanWithValidation should return response data', async t => {
+  t.plan(1)
+  const responseStub = [sandbox.stub()]
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlan').resolves(responseStub)
+  const response = await planServiceStub.getPlanWithValidation(
+    'Plan ID Test String'
+  )
+  t.equal(response, responseStub, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlanWithValidation should return an error - null causes Invalid plan data received', async t => {
+  t.plan(1)
+  const responseStub = null
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlan').resolves(responseStub)
+
+  try {
+    await planServiceStub.getPlanWithValidation('Plan ID Test String')
+  } catch (err) {
+    t.ok(
+      err.toString().includes('Invalid plan data received'),
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlanWithValidation should return an error - string causes Invalid plan data received', async t => {
+  t.plan(1)
+  const responseStub = 'Not an object'
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlan').resolves(responseStub)
+
+  try {
+    await planServiceStub.getPlanWithValidation('Plan ID Test String')
+  } catch (err) {
+    t.ok(
+      err.toString().includes('Invalid plan data received'),
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlanWithValidation should return an error - Plan ID must be a valid string', async t => {
+  t.plan(1)
+  const responseStub = null
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlan').resolves(responseStub)
+
+  try {
+    await planServiceStub.getPlanWithValidation(undefined)
+  } catch (err) {
+    t.ok(
+      err.toString().includes('Plan ID must be a valid string'),
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,53 @@
+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 = {
+    success: true,
+    data: sandbox.stub()
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+  const response = await planServiceStub.getPlans()
+  t.equal(response, responseStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlans should return an error', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: false,
+    data: sandbox.stub(),
+    message: 'Negative getPlans Test'
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(responseStub)
+
+  try {
+    await planServiceStub.getPlans()
+  } catch (err) {
+    t.ok(
+      err.toString().includes(`Failed to get plans: ${responseStub.message}`),
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,48 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getPlansWithValidation should return response data', async t => {
+  t.plan(1)
+  const responseStub = [sandbox.stub()]
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').resolves(responseStub)
+  const response = await planServiceStub.getPlansWithValidation()
+  t.equal(response, responseStub, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getPlansWithValidation should return an error - plans should be an array', async t => {
+  t.plan(1)
+  const responseStub = null
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').resolves(responseStub)
+
+  try {
+    await planServiceStub.getPlansWithValidation()
+  } catch (err) {
+    t.ok(
+      err
+        .toString()
+        .includes('Invalid response format: plans should be an array'),
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,75 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('initializePlans 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.initializePlans()
+  t.equal(response, planDataStub, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('initializePlans 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.initializePlans()
+    t.fail('initializePlans should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to initialize plans: Request failed: Failed to parse URL from null/core/admin/plans/initialize',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('initializePlans 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: initializePlans')
+    )
+
+  try {
+    await planServiceStub.initializePlans()
+    t.fail('initializePlans should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Service not initialized for method: initializePlans',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,111 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('updatePlan 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.updatePlan(true, [])
+  t.equal(response, planDataStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('updatePlan should return an error - Plan data required', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+  try {
+    await planServiceStub.updatePlan(true, false)
+    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('updatePlan should return an error - Plan ID required', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+  try {
+    await planServiceStub.updatePlan(false, [])
+    t.fail('updatePlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Plan ID is required',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('updatePlan 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.updatePlan(true, [])
+    t.fail('updatePlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to update plan: Request failed: Failed to parse URL from null/core/admin/plans/true',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('updatePlan 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: updatePlan'))
+
+  try {
+    await planServiceStub.updatePlan()
+    t.fail('updatePlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Service not initialized for method: updatePlan',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion