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

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

@@ -0,0 +1,1515 @@
+import YAML from 'yamljs';
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import { readFileSync } from 'fs';
+import manifestValidator from '../../src/packages/utils/package-manifest-validator';
+import { fieldTypes } from '../../src/schemas/enums';
+import {
+  generateShouldHavePropertyMessage,
+  MANIFEST_PATH,
+  ALLOWED_VALUES_MESSAGE,
+  TOP_LEVEL_PROHIBITED_PROPERTY_MESSAGE
+} from '../helpers/lib';
+
+const parseYAML = (filePath) => YAML.parse(readFileSync(filePath).toString('utf-8'));
+
+describe('pacakgeManifestValidator utility', async () => {
+  it('can validate the master manifest', async () => {
+    const masterManifest = parseYAML(MANIFEST_PATH);
+
+    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('warnings', async () => {
+    describe('manifest', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = { cat: 'dog' };
+        const { warnings } = manifestValidator(manifest);
+
+        expect(warnings).to.deep.eq([
+          {
+            message: 'should NOT have additional properties',
+            dataPath: 'package-manifest.yml',
+            params: { additionalProperty: 'cat' }
+          },
+          {
+            message: "should have required property 'name'",
+            dataPath: 'package-manifest.yml',
+            params: { missingProperty: 'name' }
+          }
+        ]);
+      });
+
+      it('types must be correct', async () => {
+        const manifest = {
+          name: 1,
+          label: 1,
+          query_params: [1],
+          cold_states: [1],
+          integration_ids: [1],
+          fields: [1],
+          studio_options: [1]
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.match(/([a-zA-Z]|_)+/)[0];
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          {
+            name: 'string',
+            label: 'string',
+            query_params: 'object',
+            cold_states: 'object',
+            integration_ids: 'string',
+            fields: 'object',
+            studio_options: 'object'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('integration_id must be valid', async () => {
+        const manifest = {
+          name: 'test',
+          integration_ids: ['tooooooshort', 'tooooooolooooooo', 'badCharacters!!']
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const messages = warnings.map((w) => w.message);
+
+        expect(messages).to.have.members(
+          [
+            'should NOT be longer than 15 characters',
+            'should NOT be shorter than 15 characters',
+            'should match pattern "^[a-zA-Z0-9]+$"'
+          ],
+          'correctly evaluates invalid integration_id'
+        );
+      });
+    });
+
+    describe('field', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          fields: [
+            {
+              type: 'text', // type tested separately
+              cat: 'dog'
+            }
+          ]
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.forEach((w) => {
+          const missing = w.params.missingProperty;
+          if (missing) return params.missing.push(missing);
+          const additional = w.params.additionalProperty;
+          if (additional) params.additional.push(additional);
+        });
+
+        expect(params.additional).to.have.members(
+          ['cat'],
+          'cannot have properties that are not allowed'
+        );
+
+        expect(params.missing).to.have.members(['label', 'name'], 'must have required properties');
+      });
+
+      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 { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.reduce((acc, w) => {
+          const { type } = w.params;
+          if (type) {
+            const nameFromPath = w.dataPath.split('.').pop();
+            acc[nameFromPath] = type;
+          }
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          {
+            type: 'string',
+            allows_dynamic: 'boolean',
+            default: 'string,number,boolean',
+            description: 'string',
+            label: 'string',
+            max: 'number',
+            name: 'string',
+            'options[0]': 'object',
+            placeholder: 'string,number',
+            preview_text: 'array',
+            provider: 'string',
+            template: 'string',
+            value: 'string,number,boolean',
+            heading: 'string'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('only allows valid field types', async () => {
+        const manifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'dog'
+            }
+          ]
+        };
+        const {
+          warnings: [warning]
+        } = manifestValidator(manifest);
+
+        expect(warning.message).to.eq(ALLOWED_VALUES_MESSAGE, 'fields may only have valid types');
+        expect(warning.params.allowedValues).to.have.members(
+          fieldTypes,
+          'valid field types are correct'
+        );
+      });
+
+      it('only oAuthAccount fields may and must have a provider property', async () => {
+        const missingProviderManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'oAuthAccount'
+            }
+          ]
+        };
+        const { warnings: missingProviderWarnings } = manifestValidator(missingProviderManifest);
+
+        const extraProviderManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'text',
+              provider: 'provider'
+            }
+          ]
+        };
+        const { warnings: extraProviderWarnings } = manifestValidator(extraProviderManifest);
+
+        const validManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'oAuthAccount',
+              provider: 'provider'
+            }
+          ]
+        };
+        const { warnings: validManifestWarnings } = manifestValidator(validManifest);
+
+        expect(validManifestWarnings.length).to.eq(
+          0,
+          'oAuthAccount type field allows the provider property'
+        );
+        expect(missingProviderWarnings.map((w) => w.message)).to.include(
+          generateShouldHavePropertyMessage('provider'),
+          'oAuthAccount type fields require a provider property'
+        );
+        expect(extraProviderWarnings.length).to.be.greaterThan(
+          0,
+          'only oAuthAccount type fields allow a provider property'
+        );
+      });
+
+      it('only token or number fields may have a max property', async () => {
+        const extraMaxManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'text',
+              max: 5
+            }
+          ]
+        };
+        const { warnings: extraMaxWarnings } = manifestValidator(extraMaxManifest);
+
+        const validNumberFieldManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'token',
+              max: 555
+            }
+          ]
+        };
+        const { warnings: validNumberFieldManifestWarnings } =
+          manifestValidator(validNumberFieldManifest);
+
+        const validNumberTokenManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'token',
+              max: 555
+            }
+          ]
+        };
+        const { warnings: validTokenFieldManifestWarnings } =
+          manifestValidator(validNumberTokenManifest);
+
+        expect(validTokenFieldManifestWarnings.length).to.eq(
+          0,
+          'token type field allows the max property'
+        );
+        expect(validNumberFieldManifestWarnings.length).to.eq(
+          0,
+          'number type field allows the max property'
+        );
+        expect(extraMaxWarnings.length).to.be.greaterThan(
+          0,
+          'only number and token type fields allow a max property'
+        );
+      });
+
+      it('only data-source fields may have a template property', async () => {
+        const extraTemplateManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'text',
+              template: 'template'
+            }
+          ]
+        };
+        const { warnings: extraTemplateWarnings } = manifestValidator(extraTemplateManifest);
+
+        const validManifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'data-source',
+              template: 'template'
+            }
+          ]
+        };
+        const { warnings: validManifestWarnings } = manifestValidator(validManifest);
+
+        expect(validManifestWarnings.length).to.eq(
+          0,
+          'data-source type field allows the template property'
+        );
+        expect(extraTemplateWarnings.length).to.be.greaterThan(
+          0,
+          'only data-source type fields allow a template property'
+        );
+      });
+
+      it('nonoption fields may not have an options property', async () => {
+        ['select', 'radio', 'checkbox'].forEach((type) => {
+          const manifest = {
+            name: 'test',
+            fields: [
+              {
+                name: 'test',
+                label: 'test',
+                type: type
+              }
+            ]
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          expect(warnings.length).to.eq(0, `${type} type fields may have the options`);
+        });
+
+        const manifest = {
+          name: 'test',
+          fields: [
+            {
+              name: 'test',
+              label: 'test',
+              type: 'text',
+              options: [{ value: 2, label: 'two' }]
+            }
+          ]
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        expect(warnings.length).to.be.greaterThan(0, `text fields may not have the options`);
+      });
+    });
+
+    describe('studio_options', async () => {
+      it('cannot have properties that are not allowed', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            cat: 'dog'
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        expect(warnings[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 = {
+          name: 1,
+          studio_options: {
+            prohibit_custom_params: 1,
+            framework_version: 1,
+            tools: [1],
+            preview_fields: [1],
+            property_groups: [1],
+            element_modifiers: [1],
+            property_modifiers: [1]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.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',
+            framework_version: 'string',
+            'tools[0]': 'object',
+            'preview_fields[0]': 'string',
+            'property_groups[0]': 'object',
+            'element_modifiers[0]': 'object',
+            'property_modifiers[0]': 'object'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('has a single property group', async () => {
+        const noPropertyGroupsManifest = {
+          name: 'test',
+          studio_options: {
+            property_groups: []
+          }
+        };
+        const { warnings: noPropertyGroupsWarnings } = manifestValidator(noPropertyGroupsManifest);
+
+        const tooManyMPropertyGroupsManifest = {
+          name: 'test',
+          studio_options: {
+            property_groups: [
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    name: 'dog',
+                    label: 'dog'
+                  }
+                ]
+              },
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    name: 'cat',
+                    label: 'cat'
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { warnings: tooManyMPropertyGroupsWarnings } = manifestValidator(
+          tooManyMPropertyGroupsManifest
+        );
+
+        expect(noPropertyGroupsWarnings[0].message).to.eq(
+          'should NOT have fewer than 1 items',
+          'must have exactly one property group'
+        );
+        expect(tooManyMPropertyGroupsWarnings[0].message).to.eq(
+          'should NOT have more than 1 items',
+          'cannot have more than one property group'
+        );
+      });
+    });
+
+    describe('property_group', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_groups: [
+              {
+                cat: 'dog'
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.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(
+          ['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 { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          {
+            label: 'string',
+            description: 'string',
+            'properties[0]': 'object'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('name must match package name', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_groups: [
+              {
+                name: 'dog',
+                label: 'dog',
+                properties: [
+                  {
+                    name: 'dog',
+                    label: 'dog'
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        expect(warnings).to.deep.eq(
+          [
+            {
+              message: 'property_group name must match package name',
+              dataPath: '.studio_options.propertyGroups[0]',
+              params: { name: 'dog' }
+            }
+          ],
+          'property_group name must match package name'
+        );
+      });
+    });
+
+    describe('property', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_groups: [
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    cat: 'dog'
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.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(['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 { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.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',
+            description: 'string',
+            'preview_text[0]': 'string,number,boolean',
+            'preview_values[0]': 'string,number,boolean',
+            'context_options[0]': 'object'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('type property must be an allowed value', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_groups: [
+              {
+                name: 'test',
+                label: 'test',
+                properties: [
+                  {
+                    name: 'test',
+                    type: 'dog',
+                    label: 'test'
+                  }
+                ]
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        expect(warnings[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',
+            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 { warnings } = manifestValidator(manifest);
+
+          const params = { additional: [], missing: [] };
+          warnings.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(['name'], 'must have required properties');
+        });
+
+        it('types must be correct', async () => {
+          const manifest = {
+            name: '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 { warnings } = manifestValidator(manifest);
+
+          const typeLookup = warnings.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',
+              defaultValue: 'number',
+              label: 'string',
+              value: 'string,number,boolean'
+            },
+            'types must be correct'
+          );
+        });
+
+        it('option context_options require options', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              property_groups: [
+                {
+                  name: 'test',
+                  label: 'test',
+                  properties: [
+                    {
+                      name: 'test',
+                      type: 'text',
+                      label: 'test',
+                      context_options: [
+                        {
+                          name: 'test',
+                          type: 'select'
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          expect(warnings.some((w) => w.message === generateShouldHavePropertyMessage('options')))
+            .to.be.true;
+        });
+
+        it('options must have at least one option', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              property_groups: [
+                {
+                  name: 'test',
+                  label: 'test',
+                  properties: [
+                    {
+                      name: 'test',
+                      type: 'text',
+                      label: 'test',
+                      context_options: [
+                        {
+                          name: 'test',
+                          type: 'select',
+                          options: []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          expect(warnings[0].message).to.eq(
+            'should NOT have fewer than 1 items',
+            'must have at least one option'
+          );
+        });
+
+        it('options cannot have have properties that are not allowed and must have required properties', async () => {
+          const manifest = {
+            name: '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 { warnings } = manifestValidator(manifest);
+
+          const params = { additional: [], missing: [] };
+          warnings.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(
+            ['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 = {
+          name: 'test',
+          studio_options: {
+            tools: [
+              {
+                cat: 'dog'
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.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', 'label', 'type', 'name'],
+          'must have required properties'
+        );
+      });
+
+      it('types must be correct', async () => {
+        const manifest = {
+          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 { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          {
+            class_names: 'string',
+            fields: 'array',
+            label: 'string',
+            name: 'string',
+            type: 'string',
+            locked: 'boolean',
+            dynamic_fields: 'array',
+            defaults: 'object'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('icon must be an allowed value', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            tools: [
+              {
+                name: 'test',
+                label: 'test',
+                icon: 'bananas',
+                type: 'current-value'
+              }
+            ]
+          }
+        };
+
+        const {
+          warnings: [{ 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 = {
+            name: 'test',
+            studio_options: {
+              tools: [
+                {
+                  name: 'test',
+                  icon: 'avatar',
+                  label: 'test',
+                  type: 'test-value',
+                  dynamic_fields: [
+                    {
+                      type: 'text', // type tested separately
+                      cat: 'dog'
+                    }
+                  ]
+                }
+              ]
+            }
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          const params = { additional: [], missing: [] };
+          warnings.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(
+            ['label', 'name'],
+            'must have required properties'
+          );
+        });
+
+        it('types must be correct', async () => {
+          const manifest = {
+            name: '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 { warnings } = manifestValidator(manifest);
+
+          const typeLookup = warnings.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'
+          );
+        });
+
+        it('type property must be an allowed value', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              tools: [
+                {
+                  name: 'test',
+                  icon: 'avatar',
+                  label: 'test',
+                  type: 'test-value',
+                  dynamic_fields: [
+                    {
+                      name: 'test',
+                      label: 'test',
+                      type: 'dog'
+                    }
+                  ]
+                }
+              ]
+            }
+          };
+
+          const {
+            warnings: [{ dataPath, message }]
+          } = manifestValidator(manifest);
+
+          expect({ dataPath, message }).to.deep.eq(
+            {
+              message: ALLOWED_VALUES_MESSAGE,
+              dataPath: '.studio_options.tools[0].dynamic_fields[0].type'
+            },
+            'icon must be an allowed value'
+          );
+        });
+      });
+
+      describe('defaults', async () => {
+        it('cannot have properties that are not allowed', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              tools: [
+                {
+                  name: 'test',
+                  icon: 'avatar',
+                  label: 'test',
+                  type: 'test-value',
+                  defaults: {
+                    cat: 'dog'
+                  }
+                }
+              ]
+            }
+          };
+
+          const {
+            warnings: [
+              {
+                message,
+                params: { additionalProperty }
+              }
+            ]
+          } = manifestValidator(manifest);
+
+          expect({ message, additionalProperty }).to.deep.eq(
+            {
+              message: 'should NOT have additional properties',
+              additionalProperty: 'cat'
+            },
+            'cannot have properties that are not allowed'
+          );
+        });
+
+        it('types must be correct', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              tools: [
+                {
+                  name: 'test',
+                  icon: 'avatar',
+                  label: 'test',
+                  type: 'test-value',
+                  defaults: {
+                    width: 'one',
+                    height: 'one',
+                    dynamicProperty: 1
+                  }
+                }
+              ]
+            }
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          const typeLookup = warnings.reduce((acc, w) => {
+            const nameFromPath = w.dataPath.split('.').pop();
+            acc[nameFromPath] = w.params.type;
+            return acc;
+          }, {});
+
+          expect(typeLookup).to.deep.eq(
+            { dynamicProperty: 'object', height: 'number', width: 'number' },
+            'types must be correct'
+          );
+        });
+      });
+    });
+
+    describe('property_modifiers', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_modifiers: [
+              {
+                cat: 'dog'
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.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(['name', 'label'], 'must have required properties');
+      });
+
+      it('has correct types', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_modifiers: [
+              {
+                name: 1,
+                label: 1,
+                type: 'text', // type tested separately
+                preview_text: [{}],
+                description: 1,
+                propertyInputs: {}
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.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',
+            'preview_text[0]': 'string,number,boolean',
+            description: 'string',
+            propertyInputs: 'array'
+          },
+          'types must be correct'
+        );
+      });
+
+      it('type property must be an allowed value', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            property_modifiers: [
+              {
+                name: 'test',
+                label: 'test',
+                type: 'dog'
+              }
+            ]
+          }
+        };
+        const {
+          warnings: [{ dataPath, message }]
+        } = manifestValidator(manifest);
+
+        expect({ dataPath, message }).to.deep.eq(
+          {
+            message: ALLOWED_VALUES_MESSAGE,
+            dataPath: '.studio_options.property_modifiers[0].type'
+          },
+          'icon must be an allowed value'
+        );
+      });
+
+      describe('propertyInputs', async () => {
+        it('cannot have properties that are not allowed and must have required properties', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              property_modifiers: [
+                {
+                  name: 'test',
+                  label: 'test',
+                  type: 'text',
+                  propertyInputs: [{ cat: 'dog' }]
+                }
+              ]
+            }
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          const params = { additional: [], missing: [] };
+          warnings.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(
+            ['name', 'label', 'variableName'],
+            'must have required properties'
+          );
+        });
+
+        it('types must be correct', async () => {
+          const manifest = {
+            name: 'test',
+            studio_options: {
+              property_modifiers: [
+                {
+                  name: 'test',
+                  label: 'test',
+                  type: 'text',
+                  propertyInputs: [
+                    {
+                      name: 1,
+                      variableName: 1,
+                      label: 1,
+                      allow_static_option: 1,
+                      type: 1
+                    }
+                  ]
+                }
+              ]
+            }
+          };
+          const { warnings } = manifestValidator(manifest);
+
+          const typeLookup = warnings.reduce((acc, w) => {
+            const nameFromPath = w.dataPath.split('.').pop();
+            acc[nameFromPath] = w.params.type;
+            return acc;
+          }, {});
+
+          expect(typeLookup).to.deep.eq(
+            {
+              name: 'string',
+              variableName: 'string',
+              label: 'string',
+              allow_static_option: 'boolean',
+              type: 'string'
+            },
+            'types must be correct'
+          );
+        });
+      });
+    });
+
+    describe('element_modifiers', async () => {
+      it('cannot have properties that are not allowed and must have required properties', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            element_modifiers: [
+              {
+                cat: 'dog'
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.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(['name', 'label'], 'must have required properties');
+      });
+
+      it('types must be correct', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            element_modifiers: [
+              {
+                name: 1,
+                label: 1,
+                description: 1
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.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', description: 'string' },
+          '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',
+          studio_options: {
+            tools: [
+              {
+                name: 'test',
+                icon: 'avatar',
+                label: 'test',
+                type: 'test-value',
+                defaults: {
+                  dynamicProperty: {
+                    cat: 'dog'
+                  }
+                }
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const params = { additional: [], missing: [] };
+        warnings.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(['propertyPath'], 'must have required properties');
+      });
+
+      it('types must be correct', async () => {
+        const manifest = {
+          name: 'test',
+          studio_options: {
+            tools: [
+              {
+                name: 'test',
+                icon: 'avatar',
+                label: 'test',
+                type: 'test-value',
+                defaults: {
+                  dynamicProperty: {
+                    propertyPath: 1,
+                    propertyGroupKey: 1,
+                    propertyPreview: [],
+                    propertyFallback: [],
+                    propertyValue: [],
+                    context: []
+                  }
+                }
+              }
+            ]
+          }
+        };
+        const { warnings } = manifestValidator(manifest);
+
+        const typeLookup = warnings.reduce((acc, w) => {
+          const nameFromPath = w.dataPath.split('.').pop();
+          acc[nameFromPath] = w.params.type;
+          return acc;
+        }, {});
+
+        expect(typeLookup).to.deep.eq(
+          {
+            propertyGroupKey: 'string',
+            propertyPath: 'string',
+            propertyPreview: 'string,number,boolean',
+            propertyFallback: 'string,number,boolean',
+            propertyValue: 'string',
+            context: 'object'
+          },
+          'types must be correct'
+        );
+      });
+    });
+  });
+
+  describe('errors', async () => {
+    it('must have a name', async () => {
+      const manifest = { cat: 'dog' };
+      const { errors } = manifestValidator(manifest);
+
+      expect(errors.map((w) => w.message)).to.include(
+        generateShouldHavePropertyMessage('name'),
+        'name property is required'
+      );
+    });
+
+    it('must not have prohibited keys', async () => {
+      const manifest = { name: 'dog', clickthrough_dynamic_property: 'www.example.com' };
+      const { errors } = manifestValidator(manifest);
+
+      expect(errors.map((w) => w.message)).to.include(
+        TOP_LEVEL_PROHIBITED_PROPERTY_MESSAGE,
+        'prohibited properties are prohibited'
+      );
+    });
+  });
+});