@symbo.ls/sdk 2.34.34 → 3.1.1

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

@@ -1,123 +0,0 @@
-/* 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

@@ -1,84 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,109 +0,0 @@
-/* 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

@@ -1,85 +0,0 @@
-/* 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

@@ -1,53 +0,0 @@
-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

@@ -1,109 +0,0 @@
-/* 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

@@ -1,48 +0,0 @@
-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