project-booster-vue 8.119.2 → 8.119.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-booster-vue",
-  "version": "8.119.2",
+  "version": "8.119.3",
   "private": false,
   "scripts": {
     "test:unit": "vue-cli-service test:unit --forceExit --detectOpenHandles",
@@ -24,6 +24,7 @@
     "dist/*",
     "src/*",
     "public/*",
+    "scenario-validator/*",
     "*.json"
   ],
   "dependencies": {

package/scenario-validator/index.js

@@ -0,0 +1,115 @@
+const R = require('ramda');
+const request = require('request');
+const axios = require('axios');
+const Ajv = require('ajv');
+const {
+  getAllStepName,
+  hasTemplates,
+  hasNoTemplates,
+  createDirectGraphForJson,
+  getAllConfigurationForTemplateLiteral,
+  getPictures,
+  getStepComponent,
+} = require('./jsonExplorer');
+
+const getUrlStatusCode = (url) => {
+  return new Promise((resolve, reject) => {
+    const r = request(url);
+    r.on('response', (response) => {
+      r.abort();
+      resolve(response.statusCode);
+    });
+    r.on('error', function (err) {
+      reject(err);
+    });
+  });
+};
+
+const isOffline = process.env.OFFLINE;
+
+const itOnline = isOffline ? it.skip : it;
+
+const testImage = (url) => {
+  describe(url, () => {
+    itOnline('should exist', async () => {
+      const status = await getUrlStatusCode(url);
+      expect(status).toBe(200);
+    });
+    it('should not be on a subproject bucket', () => {
+      const bucketRegex = /^https:\/\/storage.googleapis.com\/budget-estimate-[^\/]+subproject-forms\/.*/;
+      expect(bucketRegex.test(url)).toBeFalsy();
+    });
+  });
+};
+
+const validateSchema = (rawJson) => {
+  itOnline('should be valid according to json schema', async () => {
+    const jsonSchema = (await axios.get('https://adeo.github.io/project-booster-vue/jsonSchema/scenario.json')).data;
+    const ajv = new Ajv({ allErrors: true });
+    const validate = ajv.compile(jsonSchema);
+    const valid = validate(rawJson);
+    if (!valid) {
+      console.error(validate.errors);
+    }
+    expect(valid).toBeTruthy();
+  });
+};
+const sharedScenarioTests = (json) => {
+  validateSchema(json);
+  it('should have a __START__ step', () => {
+    expect(json['__START__']).toBeDefined();
+  });
+  it('should have keys same as code', () => {
+    R.toPairs(json).forEach(([key, { code }]) => {
+      expect(key).toEqual(code);
+    });
+  });
+  describe('images', () => {
+    describe('static images', () => {
+      const images = getPictures(json).filter(hasNoTemplates);
+      for (let url of images) {
+        testImage(url);
+      }
+    });
+    describe('dynamic images', () => {
+      const images = getPictures(json)
+        .filter(hasTemplates)
+        .filter((v, i, a) => a.indexOf(v) === i);
+      for (let template of images) {
+        describe(template, () => {
+          for (let url of getAllConfigurationForTemplateLiteral(json, template)) {
+            testImage(url);
+          }
+        });
+      }
+    });
+  });
+  describe('steps', () => {
+    const graph = createDirectGraphForJson(json);
+    const allSteps = getAllStepName(json);
+    Object.entries(graph).map(([key, val]) => {
+      describe(key, () => {
+        it('should have valid destination', () => {
+          val.forEach((destination) => {
+            expect(allSteps.indexOf(destination)).toBeGreaterThanOrEqual(0);
+          });
+        });
+
+        const stepComponentName = getStepComponent(json[key]);
+
+        if (stepComponentName === 'PbSpaceInput' || stepComponentName === 'PbAmountInput') {
+          it('should have a value for going back for a numeric input', () => {
+            expect(json[key].payload.value).toBeDefined();
+            expect(typeof json[key].payload.value).toBe('object');
+          });
+        }
+      });
+    });
+  });
+};
+
+module.exports.sharedScenarioTests = sharedScenarioTests;
+module.exports.validateSchema = validateSchema;
+module.exports.testImage = testImage;
+module.exports.getUrlStatusCode = getUrlStatusCode;
+module.exports.getPictures = getPictures;

package/scenario-validator/jsonExplorer.js

@@ -0,0 +1,165 @@
+const R = require('ramda');
+
+const getStepComponent = (step) => (step && step.component) || undefined;
+
+const getTemplates = R.match(/(\${.*?})/g);
+
+const hasTemplates = (string) => getTemplates(string).length > 0;
+const hasNoTemplates = (string) => getTemplates(string).length === 0;
+
+const getPictures = (json) => {
+  const polishArray = R.pipe(R.reject(R.isNil), R.flatten, R.reject(R.isNil), R.filter(R.reject(R.isNil)), R.uniq);
+  const getAnswersImages = R.pipe(
+    R.map(R.pipe(R.path(['payload', 'answers']), R.values, R.map(R.path(['viewModel', 'image'])))),
+    R.values,
+  );
+  const getStrips = R.pipe(R.values, R.map(R.path(['payload', 'viewModel', 'decoratorStripe'])));
+  const images = [...getStrips(json), ...getAnswersImages(json)];
+  return images.length > 0 ? polishArray(images) : images;
+};
+
+const getAllConfigurationForTemplateLiteral = (json, string) => {
+  const stepForString = R.pipe(
+    R.values,
+    R.filter(
+      R.compose(
+        R.includes(string),
+        R.pipe(R.path(['payload', 'answers']), R.values, R.map(R.path(['viewModel', 'image']))),
+      ),
+    ),
+  )(json)[0];
+
+  const defaultValuesData = R.path(['payload', 'defaultDecoratorValue'], stepForString);
+
+  const defaultValues = R.pipe(
+    R.match(/defaultValue\..+?[ }]/g),
+    R.map(
+      R.pipe(
+        R.split('.'),
+        R.nth(1),
+        (str) => str.substring(0, str.length - 1),
+        (val) => R.path([val], defaultValuesData),
+      ),
+    ),
+  );
+
+  const answersValues = R.pipe(
+    R.match(/(.+?)\[0]\.value/g),
+    R.map(
+      R.pipe(
+        R.split('.'),
+        R.nth(1),
+        R.split('['),
+        R.nth(0),
+        (val) => json[val],
+        R.path(['payload', 'answers']),
+        R.values,
+        R.map(R.path(['value'])),
+        R.flatten,
+      ),
+    ),
+    R.flatten,
+  );
+
+  const combinator = R.pipe(
+    getTemplates,
+    R.map((val) => R.concat(defaultValues(val), answersValues(val))),
+  );
+
+  let combined = combinator(string);
+
+  if (combined.length > 1) {
+    combined = R.reduce(R.xprod, [], combined);
+  } else {
+    combined = R.splitEvery(1, combined[0]);
+  }
+
+  const urls = R.map((pair) => {
+    const templates = getTemplates(string);
+    let newString = string;
+    pair.forEach((value, i) => {
+      newString = R.replace(templates[i], value, newString);
+    });
+    return newString;
+  }, combined);
+
+  return R.uniq(urls);
+};
+
+const isTypeScenario = R.propEq('type', 'SCENARIO');
+
+const getDestinationFromScenario = (step) => {
+  const direction = R.prop('stepCode');
+
+  return R.filter(R.is(String))([direction(step)]);
+};
+
+const getDestinationFromStep = (step) => {
+  const forPayload = R.pipe(
+    R.path(['payload', 'multiSelect', 'actions', 'VALIDATE', 'nextStep', 'code']),
+    R.ifElse(
+      R.is(String),
+      (val) => [val],
+      () => [],
+    ),
+  );
+
+  const baseForStep = R.ifElse(
+    R.has('nextStep'),
+    R.pipe(
+      R.prop('nextStep'),
+      R.ifElse(
+        R.has('code'),
+        R.pipe(R.prop('code'), (val) => [val]),
+        R.ifElse(
+          R.has('conditionals'),
+          R.pipe(R.prop('conditionals'), R.map(R.path(['nextStep', 'code']))),
+          R.pipe(() => []),
+        ),
+      ),
+      (val) => val || [],
+    ),
+    () => [],
+  );
+
+  const stepsInside = R.pipe(
+    R.ifElse(
+      R.propEq('component', 'PbQuestion'),
+      R.pipe(R.path(['payload', 'answers']), R.values, R.map(R.path(['nextStep', 'code']))),
+      R.ifElse(
+        R.propEq('component', 'PbRestitution'),
+        R.pipe(
+          R.path(['payload', 'callToActions']),
+          R.values,
+          R.map(R.prop('action')),
+          R.filter(R.is(Object)),
+          R.map(R.prop('code')),
+        ),
+        () => R.init([]),
+      ),
+    ),
+    (val) => val || [],
+  );
+
+  const ret = R.filter(R.is(String))(R.concat(stepsInside(step), R.concat(baseForStep(step), forPayload(step))));
+
+  return ret || [];
+};
+
+const getAllStepName = R.keys;
+
+const createDirectGraphForJson = (json) => {
+  const directGraph = R.pipe(
+    R.map(R.pipe(R.ifElse(isTypeScenario, getDestinationFromScenario, getDestinationFromStep), R.uniq())),
+  )(json);
+
+  return R.map(R.filter((val) => val !== 'null'))(directGraph);
+};
+
+module.exports.getPictures = getPictures;
+module.exports.getAllStepName = getAllStepName;
+module.exports.getStepComponent = getStepComponent;
+module.exports.createDirectGraphForJson = createDirectGraphForJson;
+module.exports.hasTemplates = hasTemplates;
+module.exports.hasNoTemplates = hasNoTemplates;
+module.exports.getAllConfigurationForTemplateLiteral = getAllConfigurationForTemplateLiteral;