@jungvonmatt/contentful-migrations 6.2.5 → 7.0.0

package/lib/helpers/validation.test.js

@@ -1,381 +0,0 @@
-const { getValidationHelpers } = require('./validation');
-
-describe('getValidationHelpers', () => {
-  const getTestContentType = () => ({
-    fields: [
-      {
-        id: 'selectWithOtherValidationProps',
-        type: 'Text',
-        validations: [
-          {
-            foo: 'test',
-          },
-          {
-            in: ['foo', 'bar', 'baz'],
-            message: 'Some message',
-          },
-        ],
-      },
-      {
-        id: 'select',
-        type: 'Text',
-        validations: [
-          {
-            in: ['foo', 'bar', 'baz'],
-          },
-        ],
-      },
-      {
-        id: 'reference',
-        type: 'Text',
-        validations: [
-          {
-            linkContentType: ['foo', 'bar', 'baz'],
-          },
-        ],
-      },
-      {
-        id: 'string',
-        type: 'Text',
-      },
-      {
-        id: 'string-array',
-        type: 'Array',
-        items: [],
-      },
-      {
-        id: 'richTextNoValidations',
-        type: 'RichText',
-      },
-      {
-        id: 'richTextFullValidations',
-        type: 'RichText',
-        validations: [
-          {
-            enabledMarks: ['bold', 'italic'],
-          },
-          {
-            enabledNodeTypes: [
-              'blockquote',
-              'embedded-entry-block',
-              'hyperlink',
-              'entry-hyperlink',
-              'embedded-entry-inline',
-            ],
-          },
-          {
-            nodes: {
-              'embedded-entry-block': [
-                {
-                  linkContentType: ['foo', 'baz'],
-                },
-              ],
-              'embedded-entry-inline': [
-                {
-                  linkContentType: ['foo'],
-                },
-              ],
-            },
-          },
-        ],
-      },
-    ],
-  });
-
-  const context = {
-    makeRequest: () => Promise.resolve(getTestContentType()),
-  };
-
-  let resultValidation;
-
-  const migration = {
-    editContentType: () => ({
-      editField: () => ({
-        validations: (validationObject) => {
-          resultValidation = validationObject;
-        },
-      }),
-    }),
-  };
-
-  beforeEach(() => {
-    resultValidation = undefined;
-  });
-
-  describe('addInValues', () => {
-    it('should add values at the end', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.addInValues('some-content-type', 'selectWithOtherValidationProps', 'bat');
-      expect(resultValidation).toEqual([
-        {
-          foo: 'test',
-        },
-        {
-          in: ['foo', 'bar', 'baz', 'bat'],
-          message: 'Some message',
-        },
-      ]);
-    });
-
-    it('should only add new values', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.addInValues('some-content-type', 'select', ['bat', 'foo', 'test']);
-      expect(resultValidation).toEqual([
-        {
-          in: ['foo', 'bar', 'baz', 'bat', 'test'],
-        },
-      ]);
-    });
-
-    it('should add new values sorted', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.addInValues('some-content-type', 'select', ['bat', 'foo', 'test'], { mode: 'sorted' });
-      expect(resultValidation).toEqual([
-        {
-          in: ['bar', 'bat', 'baz', 'foo', 'test'],
-        },
-      ]);
-    });
-
-    it('should add values where none where defined', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.addInValues('some-content-type', 'string', 'foo');
-      expect(resultValidation).toEqual([
-        {
-          in: ['foo'],
-        },
-      ]);
-    });
-  });
-
-  describe('removeInValues', () => {
-    it('should remove values', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.removeInValues('some-content-type', 'select', ['foo', 'baz']);
-      expect(resultValidation).toEqual([
-        {
-          in: ['bar'],
-        },
-      ]);
-    });
-  });
-
-  describe('modifyInValues', () => {
-    it('should modify values with custom function', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.modifyInValues('some-content-type', 'select', (values) => {
-        const result = values.slice(0, values.length - 1); // remove bar
-        result.push('test');
-        return result;
-      });
-      expect(resultValidation).toEqual([
-        {
-          in: ['foo', 'bar', 'test'],
-        },
-      ]);
-    });
-  });
-
-  describe('addLinkContentTypeValues', () => {
-    it('should add values at the end', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.addLinkContentTypeValues('some-content-type', 'reference', 'bat');
-      expect(resultValidation).toEqual([
-        {
-          linkContentType: ['foo', 'bar', 'baz', 'bat'],
-        },
-      ]);
-    });
-  });
-
-  describe('removeLinkContentTypeValues', () => {
-    it('should remove values', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.removeLinkContentTypeValues('some-content-type', 'reference', ['foo', 'baz']);
-      expect(resultValidation).toEqual([
-        {
-          linkContentType: ['bar'],
-        },
-      ]);
-    });
-  });
-
-  describe('modifyLinkContentTypeValues', () => {
-    it('should modify unique values with custom function', async () => {
-      const validations = getValidationHelpers(migration, context);
-      await validations.modifyLinkContentTypeValues('some-content-type', 'reference', (values) => {
-        const result = values.slice(0, values.length - 1); // remove bar
-        result.push('test');
-        result.push('foo'); // should be removed since it exists
-        return result;
-      });
-      expect(resultValidation).toEqual([
-        {
-          linkContentType: ['foo', 'bar', 'test'],
-        },
-      ]);
-    });
-  });
-
-  describe('richText', () => {
-    describe('addEnabledMarksValue', () => {
-      it('should add values at the end', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.addEnabledMarksValues('some-content-type', 'richTextFullValidations', 'code');
-        expect(resultValidation).toContainEqual({
-          enabledMarks: ['bold', 'italic', 'code'],
-        });
-      });
-    });
-
-    describe('removeEnabledMarksValue', () => {
-      it('should remove values', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.removeEnabledMarksValues('some-content-type', 'richTextFullValidations', 'bold');
-        expect(resultValidation).toContainEqual({
-          enabledMarks: ['italic'],
-        });
-      });
-    });
-
-    describe('modifyEnabledMarksValue', () => {
-      it('should modify unique values with custom function', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.modifyEnabledMarksValues(
-          'some-content-type',
-          'richTextFullValidations',
-          (values) => {
-            const result = values.slice(0, values.length - 1); // remove italic
-            result.push('code');
-            result.push('bold'); // should be removed since it exists
-            return result;
-          }
-        );
-        expect(resultValidation).toContainEqual({
-          enabledMarks: ['bold', 'code'],
-        });
-      });
-    });
-
-    describe('addEnabledNodeTypeValue', () => {
-      it('should add values at the end', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.addEnabledNodeTypeValues('some-content-type', 'richTextFullValidations', 'hr');
-        expect(resultValidation).toContainEqual({
-          enabledNodeTypes: [
-            'blockquote',
-            'embedded-entry-block',
-            'hyperlink',
-            'entry-hyperlink',
-            'embedded-entry-inline',
-            'hr',
-          ],
-        });
-      });
-    });
-
-    describe('removeEnabledNodeTypeValue', () => {
-      it('should remove values', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.removeEnabledNodeTypeValues(
-          'some-content-type',
-          'richTextFullValidations',
-          'blockquote'
-        );
-        expect(resultValidation).toContainEqual({
-          enabledNodeTypes: ['embedded-entry-block', 'hyperlink', 'entry-hyperlink', 'embedded-entry-inline'],
-        });
-      });
-    });
-
-    describe('modifyEnabledNodeTypeValue', () => {
-      it('should modify unique values with custom function', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.modifyEnabledNodeTypeValues(
-          'some-content-type',
-          'richTextFullValidations',
-          (values) => {
-            const result = values.slice(0, values.length - 1); // remove embedded-entry-inline
-            result.push('hr');
-            result.push('blockquote'); // should be removed since it exists
-            return result;
-          }
-        );
-        expect(resultValidation).toContainEqual({
-          enabledNodeTypes: ['blockquote', 'embedded-entry-block', 'hyperlink', 'entry-hyperlink', 'hr'],
-        });
-      });
-    });
-
-    describe('addNodeContentTypeValues', () => {
-      it('should add values at the end', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.addNodeContentTypeValues(
-          'some-content-type',
-          'richTextFullValidations',
-          'embedded-entry-block',
-          'bar'
-        );
-        expect(resultValidation.find((v) => v.nodes).nodes['embedded-entry-block']).toEqual([
-          {
-            linkContentType: ['foo', 'baz', 'bar'],
-          },
-        ]);
-      });
-
-      it('should add complete entry if not existing', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.addNodeContentTypeValues(
-          'some-content-type',
-          'richTextFullValidations',
-          'entry-hyperlink',
-          'bar'
-        );
-        expect(resultValidation.find((v) => v.nodes).nodes['entry-hyperlink']).toEqual([
-          {
-            linkContentType: ['bar'],
-          },
-        ]);
-      });
-    });
-
-    describe('removeNodeContentTypeValues', () => {
-      it('should remove values', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.removeNodeContentTypeValues(
-          'some-content-type',
-          'richTextFullValidations',
-          'embedded-entry-block',
-          'foo'
-        );
-        expect(resultValidation.find((v) => v.nodes).nodes['embedded-entry-block']).toEqual([
-          {
-            linkContentType: ['baz'],
-          },
-        ]);
-      });
-    });
-
-    describe('modifyNodeContentTypeValues', () => {
-      it('should modify unique values with custom function', async () => {
-        const validations = getValidationHelpers(migration, context);
-        await validations.richText.modifyNodeContentTypeValues(
-          'some-content-type',
-          'richTextFullValidations',
-          'embedded-entry-block',
-          (values) => {
-            const result = values.slice(0, values.length - 1); // remove foo
-            result.push('bar');
-            result.push('baz'); // should be removed since it exists
-            return result;
-          }
-        );
-        expect(resultValidation.find((v) => v.nodes).nodes['embedded-entry-block']).toEqual([
-          {
-            linkContentType: ['foo', 'bar', 'baz'],
-          },
-        ]);
-      });
-    });
-  });
-});

package/lib/helpers/validation.utils.test.js

@@ -1,45 +0,0 @@
-const { addOrdered, addValues, unique } = require('./validation.utils');
-
-describe('unique', () => {
-  it('should remove duplicates', async () => {
-    expect(unique(['foo', 'bar', 'foo', 'baz', 'bar'])).toEqual(['foo', 'bar', 'baz']);
-  });
-});
-
-describe('addOrdered', () => {
-  const a1 = ['foo', 'bar'];
-  const a2 = ['baz', 'bar', 'bat'];
-
-  it('should add unique values and order the list', async () => {
-    expect(addOrdered(a1, a2)).toEqual(['bar', 'bat', 'baz', 'foo']);
-  });
-});
-
-describe('addValues', () => {
-  const a1 = ['foo', 'bar', 'test'];
-  const a2 = ['baz', 'bar', 'bat'];
-
-  it('should add values sorted', async () => {
-    expect(addValues(a1, a2, { mode: 'sorted' })).toEqual(['bar', 'bat', 'baz', 'foo', 'test']);
-  });
-
-  it('should add values at start', async () => {
-    expect(addValues(a1, a2, { mode: 'start' })).toEqual(['baz', 'bar', 'bat', 'foo', 'test']);
-  });
-
-  it('should add values at end', async () => {
-    expect(addValues(a1, a2, { mode: 'end' })).toEqual(['foo', 'bar', 'test', 'baz', 'bat']);
-  });
-
-  it('should add values before', async () => {
-    expect(addValues(a1, a2, { mode: 'before', ref: 'bar' })).toEqual(['foo', 'baz', 'bar', 'bat', 'test']);
-  });
-
-  it('should add values before fallback', async () => {
-    expect(addValues(a1, a2, { mode: 'before', ref: 'unknown' })).toEqual(['foo', 'bar', 'test', 'baz', 'bat']);
-  });
-
-  it('should add values after', async () => {
-    expect(addValues(a1, a2, { mode: 'after', ref: 'bar' })).toEqual(['foo', 'bar', 'baz', 'bat', 'test']);
-  });
-});