@symbo.ls/sdk 2.33.40 → 2.34.0

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-useless-escape */
 /* eslint-disable no-undefined */
 import test from 'tape'
 import sinon from 'sinon'
@@ -15,8 +16,7 @@ test('updatePlanWithValidation should return response data', async t => {
     planId: 'testString',
     planData: {
       name: 'testName',
-      key: 'testkey',
-      price: 1.0
+      key: 'testkey'
     }
   }
   const planServiceStub = new PlanService()
@@ -42,9 +42,13 @@ function planIdEmptyOrNotAString () {
       name: 'planId is null',
       testValue: null
     },
-    planIdNotAString: {
-      name: 'planId is not a string',
+    planIdIsAnObject: {
+      name: 'planId is an object',
       testValue: {}
+    },
+    planIdIsANumber: {
+      name: 'planId is number',
+      testValue: 123
     }
   }
 
@@ -53,8 +57,7 @@ function planIdEmptyOrNotAString () {
       t.plan(1)
       const planData = {
         name: 'testName',
-        key: 'testkey',
-        price: 1.0
+        key: 'testkey'
       }
       const planId = badData[key].testValue
       const planServiceStub = new PlanService()
@@ -81,9 +84,17 @@ function planDataEmptyOrNotAnObject () {
       name: 'planData is undefined',
       testValue: undefined
     },
-    planDataNotAnObject: {
-      name: 'planData is not an object',
-      testValue: 'Not An Object'
+    planDataIsNull: {
+      name: 'planData is null',
+      testValue: null
+    },
+    planDataIsAString: {
+      name: 'planData is a string',
+      testValue: 'test string'
+    },
+    planDataIsANumber: {
+      name: 'planData is a string',
+      testValue: 123
     }
   }
 
@@ -109,28 +120,134 @@ function planDataEmptyOrNotAnObject () {
   })
 }
 
-function priceValidation () {
-  const badPriceData = ['A string', -10, {}]
-  for (let ii = 0; ii < badPriceData.length; ii++) {
-    test(`Price validation should throw an error checking for: ${badPriceData[ii]}`, async t => {
+test('Price validation should throw an error when price field is present', async t => {
+  t.plan(1)
+  const planId = 'testString'
+  const planData = {
+    name: 'testName',
+    description: 'test description',
+    price: 1.0
+  }
+  const planServiceStub = new PlanService()
+  try {
+    await planServiceStub.updatePlanWithValidation(planId, planData)
+    t.fail('Price validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.',
+      'Price validation detected unsupported price field'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+function pricingOptionsValidation () {
+  // Data test object
+  const planData = {
+    name: 'testName',
+    description: 'test description'
+  }
+
+  const badPricingOptions = {
+    stringValue: 'test string',
+    numberValue: 123,
+    falseBooleanValue: false,
+    trueBooleanValue: true,
+    emptyArray: []
+  }
+  Object.keys(badPricingOptions).forEach(field => {
+    test(`pricingOptions validation throws error for ${field}`, async t => {
       t.plan(1)
+      const planId = 'testString'
+      const { ...testData } = planData
+      testData.pricingOptions = badPricingOptions[field]
+      const planServiceStub = new PlanService()
+      try {
+        await planServiceStub.updatePlanWithValidation(planId, testData)
+        t.fail('updatePlanWithValidation failed - bad pricingOptions detected')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: pricingOptions must be a non-empty array when provided',
+          `pricingOptions validation failed successfully on bad pricingOptions data: ${field}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  })
+}
+
+function keyTypeValidation () {
+  const badKeyData = [
+    { name: 'array value', key: [] },
+    { name: 'number value', key: 123 },
+    { name: 'null value', key: null },
+    { name: 'undefined value', key: undefined },
+    { name: 'false boolean value', key: false }
+  ]
+  for (let ii = 0; ii < badKeyData.length; ii++) {
+    test(`Key type validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
+      t.plan(1)
+      const planId = 'testString'
       const planData = {
         name: 'testName',
-        key: 'test-key'
+        description: 'test description',
+        pricingOptions: []
       }
+      planData.pricingOptions.push(badKeyData[ii])
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
+      try {
+        await planServiceStub.updatePlanWithValidation(planId, planData)
+        t.fail('Key type validation successfully threw an error')
+      } catch (err) {
+        t.ok(
+          err
+            .toString()
+            .includes(
+              "Error: Pricing option at index 0 is missing required field 'key'"
+            ),
+          `Key type validation detected bad data: ${badKeyData[ii].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function keyFormatValidation () {
+  const badKeyData = [
+    { name: 'capital letters', key: 'CAPITALLETTERS' },
+    { name: 'special character', key: 'Special @ Character' },
+    { name: 'under score', key: 'under_score' },
+    { name: 'punctuation', key: 'syntax!' }
+  ]
+  for (let ii = 0; ii < badKeyData.length; ii++) {
+    test(`Key format validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
+      t.plan(1)
       const planId = 'testString'
-      planData.price = badPriceData[ii]
+      const planData = {
+        name: 'testName',
+        description: 'test description',
+        pricingOptions: []
+      }
+      planData.pricingOptions.push(badKeyData[ii])
       const responseStub = [sandbox.stub()]
       const planServiceStub = new PlanService()
       sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
       try {
         await planServiceStub.updatePlanWithValidation(planId, planData)
-        t.fail('Price validation successfully threw an error')
+        t.fail('Key type validation successfully threw an error')
       } catch (err) {
         t.equal(
           err.toString(),
-          'Error: Price must be a positive number',
-          `Price validation detected bad price data: ${planData.price}`
+          `Error: Pricing option key '${badKeyData[ii].key}' must contain only lowercase letters, numbers, and hyphens`,
+          `Key format validation detected bad data: ${badKeyData[ii].name}`
         )
       }
       sandbox.restore()
@@ -139,33 +256,38 @@ function priceValidation () {
   }
 }
 
-function keyValidation () {
-  const badKeyData = [
-    'CAPITALLETTERS',
-    'Special @ Character',
-    'under_score',
-    'syntax!'
+function displayNameValidation () {
+  const badDisplayNameData = [
+    {
+      name: 'false boolean value',
+      displayName: false,
+      key: 'false-boolean-value'
+    },
+    { name: 'number value', displayName: 123, key: 'number-value' },
+    { name: 'undefined value', displayName: undefined, key: 'undefined-value' },
+    { name: 'null value', displayName: null, key: 'null-value' }
   ]
-  for (let ii = 0; ii < badKeyData.length; ii++) {
-    test(`Key validation should throw an error checking for: ${badKeyData[ii]}`, async t => {
+  for (let ii = 0; ii < badDisplayNameData.length; ii++) {
+    test(`displayName validation should throw an error checking for: ${badDisplayNameData[ii].name}`, async t => {
       t.plan(1)
       const planId = 'testString'
       const planData = {
         name: 'testName',
-        price: 1.0
+        description: 'test description',
+        pricingOptions: []
       }
-      planData.key = badKeyData[ii]
+      planData.pricingOptions.push(badDisplayNameData[ii])
       const responseStub = [sandbox.stub()]
       const planServiceStub = new PlanService()
       sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
       try {
         await planServiceStub.updatePlanWithValidation(planId, planData)
-        t.fail('Key validation successfully threw an error')
+        t.fail('Key type validation successfully threw an error')
       } catch (err) {
         t.equal(
           err.toString(),
-          'Error: Plan key must contain only lowercase letters, numbers, and hyphens',
-          `Key validation detected bad price data: ${planData.key}`
+          `Error: Pricing option \'${badDisplayNameData[ii].key}\' is missing required field \'displayName\'`,
+          `displayName validation detected bad data: ${badDisplayNameData[ii].name}`
         )
       }
       sandbox.restore()
@@ -174,47 +296,256 @@ function keyValidation () {
   }
 }
 
-test('getActivePlans should return active plans', async t => {
-  t.plan(3)
-  const numActivePlans = 2
-  const plansStub = [
+function amountValidation () {
+  const badAmountData = [
+    {
+      name: 'negative amount value',
+      displayName: 'test displayname',
+      key: 'negative-amount-value',
+      amount: -1
+    },
     {
-      plan: 'plan1',
-      active: true
+      name: 'letter value',
+      displayName: 'test displayname',
+      key: 'letter-value',
+      amount: 'abc123'
     },
     {
-      plan: 'plan2',
-      active: false
+      name: 'undefined value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: undefined
     },
     {
-      plan: 'plan3',
-      active: true
+      name: 'null value',
+      displayName: 'test displayname',
+      key: 'null-value',
+      amount: null
     }
   ]
-  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'
-  )
-})
+  for (let ii = 0; ii < badAmountData.length; ii++) {
+    test(`amount validation should throw an error checking for: ${badAmountData[ii].name}`, async t => {
+      t.plan(1)
+      const planId = 'testString'
+      const planData = {
+        name: 'testName',
+        description: 'test description',
+        pricingOptions: []
+      }
+      planData.pricingOptions.push(badAmountData[ii])
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
+      try {
+        await planServiceStub.updatePlanWithValidation(planId, planData)
+        t.fail('Key type validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          `Error: Pricing option \'${badAmountData[ii].key}\' must have a non-negative numeric \'amount\'`,
+          `amount validation detected bad data: ${badAmountData[ii].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function intervalValidation () {
+  const badAmountData = [
+    {
+      name: 'number value',
+      displayName: 'test displayname',
+      key: 'number-amount-value',
+      amount: 0,
+      interval: 123
+    },
+    {
+      name: 'unsupported string value',
+      displayName: 'test displayname',
+      key: 'letter-value',
+      amount: 0,
+      interval: 'abc123'
+    },
+    {
+      name: 'undefined value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: undefined
+    }
+  ]
+  for (let ii = 0; ii < badAmountData.length; ii++) {
+    test(`interval validation should throw an error checking for: ${badAmountData[ii].name}`, async t => {
+      t.plan(1)
+      const planId = 'testString'
+      const planData = {
+        name: 'testName',
+        description: 'test description',
+        pricingOptions: []
+      }
+      planData.pricingOptions.push(badAmountData[ii])
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
+      try {
+        await planServiceStub.updatePlanWithValidation(planId, planData)
+        t.fail('Key type validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          `Error: Pricing option \'${badAmountData[ii].key}\' has invalid interval \'${badAmountData[ii].interval}\'. Allowed: month, year, week, day or null`,
+          `interval validation detected bad data: ${badAmountData[ii].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function lookupKeyValidation () {
+  const badData = [
+    {
+      name: 'number value',
+      displayName: 'test displayname',
+      key: 'number-amount-value',
+      amount: 0,
+      interval: null,
+      lookupKey: 123
+    },
+    {
+      name: 'false boolean value',
+      displayName: 'test displayname',
+      key: 'letter-value',
+      amount: 0,
+      interval: null,
+      lookupKey: false
+    },
+    {
+      name: 'true boolean value',
+      displayName: 'test displayname',
+      key: 'letter-value',
+      amount: 0,
+      interval: null,
+      lookupKey: true
+    },
+    {
+      name: 'object value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: null,
+      lookupKey: {}
+    },
+    {
+      name: 'undefined value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: null,
+      lookupKey: undefined
+    },
+    {
+      name: 'null value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: null,
+      lookupKey: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`lookup key validation should throw an error checking for: ${badData[ii].name}`, async t => {
+      t.plan(1)
+      const planId = 'testString'
+      const planData = {
+        name: 'testName',
+        description: 'test description',
+        pricingOptions: []
+      }
+      planData.pricingOptions.push(badData[ii])
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
+      try {
+        await planServiceStub.updatePlanWithValidation(planId, planData)
+        t.fail('Key type validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          `Error: Pricing option \'${badData[ii].key}\' is missing required field \'lookupKey\'`,
+          `lookup key validation detected bad data: ${badData[ii].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function topLevelKeyValidation () {
+  const planData = [
+    {
+      name: 'Uppercase letters',
+      description: 'test description',
+      key: 'ALLCAPS'
+    },
+    {
+      name: 'Underscore character',
+      description: 'test description',
+      key: '_'
+    },
+    {
+      name: 'Special characters',
+      description: 'test description',
+      key: '!@#$%'
+    },
+    {
+      name: 'Object type',
+      description: 'test description',
+      key: {}
+    },
+    {
+      name: 'Null value',
+      description: 'test description',
+      key: null
+    }
+  ]
+  for (let ii = 0; ii < planData.length; ii++) {
+    test(`top-level key validation should throw an error checking for: ${planData[ii].name}`, async t => {
+      t.plan(1)
+      const planId = 'testString'
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'updatePlan').resolves(responseStub)
+      try {
+        await planServiceStub.updatePlanWithValidation(planId, planData[ii])
+        t.fail('Key type validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Plan key must contain only lowercase letters, numbers, and hyphens',
+          `displayName validation detected bad data: ${planData[ii].name} with ${err}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
 
-keyValidation()
-priceValidation()
+amountValidation()
+displayNameValidation()
+intervalValidation()
+keyFormatValidation()
+keyTypeValidation()
+lookupKeyValidation()
 planIdEmptyOrNotAString()
 planDataEmptyOrNotAnObject()
+pricingOptionsValidation()
+topLevelKeyValidation()
 // #endregion
 
 // #region Cleanup