@movable/rollup-plugin-manifest-validator 3.2.0-app-validation

package/test/utils/app-manifest-validation.js

@@ -0,0 +1,785 @@
+import YAML from 'yamljs';
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import { readFileSync } from 'fs';
+import manifestValidator from '../../src/apps/utils/app-manifest-validator';
+import { fieldTypes } from '../../src/schemas/enums';
+import { MANIFEST_PATH_APPS, ALLOWED_VALUES_MESSAGE } from '../helpers/lib';
+
+const parseYAML = (filePath) => YAML.parse(readFileSync(filePath).toString('utf-8'));
+
+describe('appManifestValidator utility', async () => {
+  it('can validate the master manifest', async () => {
+    const masterManifest = parseYAML(MANIFEST_PATH_APPS);
+
+    const { warnings, errors } = manifestValidator(masterManifest);
+
+    expect(warnings.length).to.eq(0, 'a valid manifest has no warnings');
+    expect(errors.length).to.eq(0, 'a valid manifest thows no errors');
+  });
+
+  describe('field', async () => {
+    it('cannot have properties that are not allowed and must have required properties', async () => {
+      const manifest = {
+        name: 'test',
+        fields: [
+          {
+            name: 'test-field',
+            label: 'Test Field',
+            type: 'text',
+            cat: 'dog',
+            placeholder: 'Test Field Placeholder'
+          }
+        ]
+      };
+      const { errors } = manifestValidator(manifest);
+      const params = { additional: [], missing: [] };
+      errors.forEach((e) => {
+        const missing = e.params.missingProperty;
+        if (missing) return params.missing.push(missing);
+        const additional = e.params.additionalProperty;
+        if (additional) params.additional.push(additional);
+      });
+
+      expect(params.additional).to.have.members(
+        ['cat', 'cat', 'placeholder'],
+        'should NOT have additional properties'
+      );
+      expect(params.missing).to.have.members(['authors'], 'should have required property');
+    });
+
+    it('types must be correct', async () => {
+      const manifest = {
+        name: 'test',
+        fields: [
+          {
+            type: 1,
+            allows_dynamic: 1,
+            default: [],
+            description: 1,
+            label: 1,
+            max: 'one',
+            name: 1,
+            options: [1],
+            placeholder: [],
+            preview_text: 1,
+            provider: 1,
+            template: 1,
+            value: [],
+            heading: 1
+          }
+        ]
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const typeLookup = errors.reduce((acc, w) => {
+        const { type } = w.params;
+        if (type) {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = type;
+        }
+        return acc;
+      }, {});
+
+      expect(1).to.equal(1);
+
+      expect(typeLookup).to.deep.eq(
+        {
+          name: 'string',
+          type: 'string',
+          label: 'string',
+          placeholder: 'string,number',
+          provider: 'string',
+          max: 'number',
+          description: 'string',
+          template: 'string',
+          heading: 'string',
+          value: 'string,number,boolean'
+        },
+        'types must be correct'
+      );
+    });
+
+    it('only allows valid field types', async () => {
+      const manifest = {
+        name: 'test',
+        authors: ['test'],
+        fields: [
+          {
+            name: 'test',
+            label: 'test',
+            type: 'dog'
+          }
+        ]
+      };
+      const {
+        errors: [error]
+      } = manifestValidator(manifest);
+
+      expect(error.message).to.eq(ALLOWED_VALUES_MESSAGE, 'fields may only have valid types');
+      expect(error.params.allowedValues).to.have.members(
+        fieldTypes,
+        'valid field types are correct'
+      );
+    });
+
+    it('nonoption fields may not have an options property', async () => {
+      ['select', 'radio', 'checkbox'].forEach((type) => {
+        const manifest = {
+          name: 'test',
+          authors: ['test'],
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: type
+            }
+          ]
+        };
+        const { errors } = manifestValidator(manifest);
+
+        expect(errors.length).to.eq(0, `${type} type fields may have the options`);
+      });
+    });
+  });
+
+  describe('studio_options', async () => {
+    it('cannot have properties that are not allowed', async () => {
+      const manifest = {
+        authors: ['test'],
+        name: 'test',
+        studio_options: {
+          cat: 'dog'
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      expect(errors[0]).to.deep.eq(
+        {
+          message: 'should NOT have additional properties',
+          dataPath: '.studio_options',
+          params: { additionalProperty: 'cat' }
+        },
+        'extra properties are not allowed'
+      );
+    });
+
+    it('types must be correct', async () => {
+      const manifest = {
+        authors: ['test'],
+        name: 1,
+        studio_options: {
+          prohibit_custom_params: 1,
+          framework_version: 1,
+          tools: [1],
+          preview_fields: [1],
+          property_groups: [1],
+          element_modifiers: [1]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const typeLookup = errors.reduce((acc, w) => {
+        const nameFromPath = w.dataPath.split('.').pop();
+        acc[nameFromPath] = w.params.type;
+        return acc;
+      }, {});
+
+      expect(typeLookup).to.deep.eq(
+        {
+          name: 'string',
+          prohibit_custom_params: 'boolean',
+          'tools[0]': 'object',
+          'preview_fields[0]': undefined,
+          'element_modifiers[0]': 'object',
+          'property_groups[0]': 'object'
+        },
+        'types must be correct'
+      );
+    });
+  });
+
+  describe('property_group', async () => {
+    it('cannot have properties that are not allowed and must have required properties', async () => {
+      const manifest = {
+        authors: ['test'],
+        name: 'test',
+        studio_options: {
+          property_groups: [
+            {
+              cat: 'dog'
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const params = { additional: [], missing: [] };
+      errors.forEach((w) => {
+        const missing = w.params.missingProperty;
+        if (missing) return params.missing.push(missing);
+        params.additional.push(w.params.additionalProperty);
+      });
+
+      expect(params.missing).to.have.members(
+        ['name', 'label', 'properties'],
+        'must have required properties'
+      );
+    });
+
+    it('types must be correct', async () => {
+      const manifest = {
+        name: 'test',
+        studio_options: {
+          property_groups: [
+            {
+              name: 'test', // name tested separately
+              label: 1,
+              description: 1,
+              properties: [1]
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const typeLookup = errors.reduce((acc, w) => {
+        const nameFromPath = w.dataPath.split('.').pop();
+        acc[nameFromPath] = w.params.type;
+        return acc;
+      }, {});
+
+      expect(typeLookup).to.deep.eq(
+        {
+          yml: undefined,
+          label: 'string',
+          description: 'string',
+          'properties[0]': 'object'
+        },
+        'types must be correct'
+      );
+    });
+  });
+
+  describe('property', async () => {
+    it('cannot have properties that are not allowed and must have required properties', async () => {
+      const manifest = {
+        name: 'test',
+        authors: ['test'],
+        studio_options: {
+          property_groups: [
+            {
+              name: 'test',
+              label: 'test',
+              properties: [
+                {
+                  cat: 'dog'
+                }
+              ]
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const params = { additional: [], missing: [] };
+      errors.forEach((w) => {
+        const missing = w.params.missingProperty;
+        if (missing) return params.missing.push(missing);
+        params.additional.push(w.params.additionalProperty);
+      });
+
+      expect(params.missing).to.have.members(['name', 'label'], 'must have required properties');
+    });
+
+    it('types must be correct', async () => {
+      const manifest = {
+        name: 'test',
+        studio_options: {
+          property_groups: [
+            {
+              name: 'test',
+              label: 'test',
+              properties: [
+                {
+                  name: 1,
+                  type: 'text', // type tested separately
+                  label: 1,
+                  description: 1,
+                  preview_text: [{}],
+                  preview_values: [{}],
+                  context_options: [1]
+                }
+              ]
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const typeLookup = errors.reduce((acc, w) => {
+        const nameFromPath = w.dataPath.split('.').pop();
+        acc[nameFromPath] = w.params.type;
+        return acc;
+      }, {});
+
+      expect(typeLookup).to.deep.eq(
+        {
+          yml: undefined,
+          name: 'string',
+          label: 'string',
+          'context_options[0]': 'object',
+          'preview_values[0]': 'string,number,boolean'
+        },
+        'types must be correct'
+      );
+    });
+
+    it('type property must be an allowed value', async () => {
+      const manifest = {
+        name: 'test',
+        authors: ['test'],
+        studio_options: {
+          property_groups: [
+            {
+              name: 'test',
+              label: 'test',
+              properties: [
+                {
+                  name: 'test',
+                  type: 'dog',
+                  label: 'test'
+                }
+              ]
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      expect(errors[0].message).to.eq(
+        'should be equal to one of the allowed values',
+        'type property must match an allowed value'
+      );
+    });
+
+    describe('context_options', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          authors: ['test'],
+          studio_options: {
+            property_groups: [
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    name: 'test',
+                    type: 'text',
+                    label: 'test',
+                    context_options: [
+                      {
+                        cat: 'dog',
+                        type: 'text' // type tested separately
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { errors } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        errors.forEach((w) => {
+          const missing = w.params.missingProperty;
+          if (missing) return params.missing.push(missing);
+          params.additional.push(w.params.additionalProperty);
+        });
+
+        expect(params.missing).to.have.members(['name'], 'must have required properties');
+      });
+
+      it('types must be correct', async () => {
+        const manifest = {
+          name: 'test',
+          authors: ['test'],
+          studio_options: {
+            property_groups: [
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    name: 'test',
+                    label: 'test',
+                    context_options: [
+                      {
+                        name: 1,
+                        type: 'select',
+                        description: 1,
+                        defaultValue: 'one',
+                        options: [
+                          {
+                            label: 1,
+                            value: {}
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { errors } = manifestValidator(manifest);
+
+        const typeLookup = errors.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          {
+            name: 'string',
+            description: 'string',
+            value: 'string,number,boolean',
+            label: 'string'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('options cannot have have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          authors: ['test'],
+          studio_options: {
+            property_groups: [
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    name: 'test',
+                    type: 'text',
+                    label: 'test',
+                    context_options: [
+                      {
+                        name: 'test',
+                        type: 'select',
+                        options: [{ cat: 'dog' }]
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { errors } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        errors.forEach((w) => {
+          const missing = w.params.missingProperty;
+          if (missing) return params.missing.push(missing);
+          params.additional.push(w.params.additionalProperty);
+        });
+
+        expect(params.missing).to.have.members(['label', 'value'], 'must have required properties');
+      });
+    });
+  });
+
+  describe('tool', async () => {
+    it('cannot have properties that are not allowed and must have required properties', async () => {
+      const manifest = {
+        authors: ['test'],
+        name: 'test',
+        studio_options: {
+          tools: [
+            {
+              cat: 'dog'
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const params = { additional: [], missing: [] };
+      errors.forEach((w) => {
+        const missing = w.params.missingProperty;
+        if (missing) return params.missing.push(missing);
+        params.additional.push(w.params.additionalProperty);
+      });
+
+      expect(params.additional).to.have.members(
+        ['cat'],
+        'cannot have properties that are not allowed'
+      );
+
+      expect(params.missing).to.have.members(
+        ['icon', 'type', 'name'],
+        'must have required properties'
+      );
+    });
+
+    it('types must be correct', async () => {
+      const manifest = {
+        authors: ['test'],
+        name: 'test',
+        studio_options: {
+          tools: [
+            {
+              class_names: 1,
+              fields: 1,
+              icon: 'avatar', // icon tested separately
+              label: 1,
+              name: 1,
+              type: 1,
+              locked: 'one',
+              dynamic_fields: {},
+              defaults: []
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const typeLookup = errors.reduce((acc, w) => {
+        const nameFromPath = w.dataPath.split('.').pop();
+        acc[nameFromPath] = w.params.type;
+        return acc;
+      }, {});
+
+      expect(typeLookup).to.deep.eq(
+        {
+          name: 'string',
+          type: 'string',
+          class_names: 'string',
+          locked: 'boolean',
+          fields: 'array',
+          dynamic_fields: 'array'
+        },
+        'types must be correct'
+      );
+    });
+
+    it('icon must be an allowed value', async () => {
+      const manifest = {
+        authors: ['test'],
+        name: 'test',
+        studio_options: {
+          tools: [
+            {
+              name: 'test',
+              label: 'test',
+              icon: 'bananas',
+              type: 'current-value'
+            }
+          ]
+        }
+      };
+
+      const {
+        errors: [{ dataPath, message }]
+      } = manifestValidator(manifest);
+
+      expect({ dataPath, message }).to.deep.equal(
+        {
+          message: ALLOWED_VALUES_MESSAGE,
+          dataPath: '.studio_options.tools[0].icon'
+        },
+        'icon must be an allowed value'
+      );
+    });
+
+    describe('dynamic_fields', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          authors: ['test'],
+          name: 'test',
+          studio_options: {
+            tools: [
+              {
+                name: 'test',
+                icon: 'avatar',
+                label: 'test',
+                type: 'test-value',
+                dynamic_fields: [
+                  {
+                    type: 'text', // type tested separately
+                    cat: 'dog'
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { errors } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        errors.forEach((w) => {
+          const missing = w.params.missingProperty;
+          if (missing) return params.missing.push(missing);
+          params.additional.push(w.params.additionalProperty);
+        });
+
+        expect(params.missing).to.have.members(['name'], 'must have required properties');
+      });
+
+      it('types must be correct', async () => {
+        const manifest = {
+          name: 'test',
+          authors: ['test'],
+          studio_options: {
+            tools: [
+              {
+                name: 'test',
+                icon: 'avatar',
+                label: 'test',
+                type: 'test-value',
+                dynamic_fields: [
+                  {
+                    name: 1,
+                    label: 1,
+                    type: 'text', // type tested separately
+                    allow_static_option: 'one'
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { errors } = manifestValidator(manifest);
+
+        const typeLookup = errors.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          { name: 'string', label: 'string', allow_static_option: 'boolean' },
+          'types must be correct'
+        );
+      });
+    });
+
+    describe('defaults', async () => {
+      it('types must be correct', async () => {
+        const manifest = {
+          name: 'test',
+          authors: ['test'],
+          studio_options: {
+            tools: [
+              {
+                name: 'test',
+                icon: 'avatar',
+                label: 'test',
+                type: 'test-value',
+                defaults: {
+                  width: 'one',
+                  height: 'one',
+                  dynamicProperty: 1
+                }
+              }
+            ]
+          }
+        };
+        const { errors } = manifestValidator(manifest);
+
+        const typeLookup = errors.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq({ dynamicProperty: 'object' }, 'types must be correct');
+      });
+    });
+  });
+
+  describe('dynamicProperty', async () => {
+    it('cannot have properties that are not allowed and must have required properties', async () => {
+      const manifest = {
+        name: 'test',
+        authors: ['test'],
+        studio_options: {
+          tools: [
+            {
+              name: 'test',
+              icon: 'avatar',
+              label: 'test',
+              type: 'test-value',
+              defaults: {
+                dynamicProperty: {
+                  cat: 'dog'
+                }
+              }
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const params = { additional: [], missing: [] };
+      errors.forEach((w) => {
+        const missing = w.params.missingProperty;
+        if (missing) return params.missing.push(missing);
+        params.additional.push(w.params.additionalProperty);
+      });
+
+      expect(params.missing).to.have.members(['propertyPath'], 'must have required properties');
+    });
+
+    it('types must be correct', async () => {
+      const manifest = {
+        name: 'test',
+        authors: ['test'],
+        studio_options: {
+          tools: [
+            {
+              name: 'test',
+              icon: 'avatar',
+              label: 'test',
+              type: 'test-value',
+              defaults: {
+                dynamicProperty: {
+                  propertyPath: 1,
+                  propertyGroupKey: 1,
+                  propertyPreview: [],
+                  propertyFallback: [],
+                  propertyValue: [],
+                  context: []
+                }
+              }
+            }
+          ]
+        }
+      };
+      const { errors } = manifestValidator(manifest);
+
+      const typeLookup = errors.reduce((acc, w) => {
+        const nameFromPath = w.dataPath.split('.').pop();
+        acc[nameFromPath] = w.params.type;
+        return acc;
+      }, {});
+
+      expect(typeLookup).to.deep.eq(
+        {
+          propertyPath: 'string',
+          propertyPreview: 'string',
+          propertyFallback: 'string',
+          propertyGroupKey: 'string',
+          propertyValue: 'string'
+        },
+        'types must be correct'
+      );
+    });
+  });
+});