@symbo.ls/sdk 3.1.2 → 3.2.6

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

@@ -0,0 +1,123 @@
+/* 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('getActivePlans should return active plans', async t => {
+  t.plan(3)
+  const numActivePlans = 2
+  const plansStub = [
+    {
+      plan: 'plan1',
+      status: 'active',
+      isVisible: true
+    },
+    {
+      plan: 'plan2',
+      status: 'inactive',
+      isVisible: false
+    },
+    {
+      plan: 'plan3',
+      status: 'active',
+      isVisible: true
+    }
+  ]
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').resolves(plansStub)
+  const response = await planServiceStub.getActivePlans()
+
+  t.equal(
+    response.length,
+    numActivePlans,
+    'Correct number of active plans returned'
+  )
+  t.equal(
+    response[0].plan,
+    plansStub[0].plan,
+    'First plan successfully returned'
+  )
+  t.equal(
+    response[1].plan,
+    plansStub[2].plan,
+    'Third plan successfully returned'
+  )
+})
+
+function planFilter () {
+  const badPlans = [
+    {
+      plan: 'status is inactive and isVisible is false',
+      status: 'inactive',
+      isVisible: false
+    },
+    {
+      plan: 'status is active and isVisible is false',
+      status: 'active',
+      isVisible: false
+    },
+    {
+      plan: 'status is undefined and isVisible is true',
+      status: undefined,
+      isVisible: true
+    },
+    {
+      plan: 'status is undefined and isVisible is false',
+      status: undefined,
+      isVisible: false
+    },
+    {
+      plan: 'status is null and isVisible is true',
+      status: null,
+      isVisible: true
+    },
+    {
+      plan: 'status is null and isVisible is false',
+      status: null,
+      isVisible: false
+    },
+    {
+      plan: 'status is active and isVisible is undefined',
+      status: 'active',
+      isVisible: undefined
+    },
+    {
+      plan: 'status is active and isVisible is null',
+      status: 'active',
+      isVisible: null
+    },
+    {
+      plan: 'status is a number and isVisible is true',
+      status: 123,
+      isVisible: true
+    }
+  ]
+  for (let ii = 0; ii < badPlans.length; ii++) {
+    test(`getActivePlans should return no plans using ${badPlans[ii].plan}`, async t => {
+      t.plan(1)
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'getPlans').resolves([badPlans[ii]])
+      const response = await planServiceStub.getActivePlans()
+      t.equal(
+        response.length,
+        0,
+        `No active plans returned when ${badPlans[ii].plan}`
+      )
+    })
+  }
+}
+
+planFilter()
+// #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/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/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/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

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