@pranaysahith/decap-cms-core 3.9.1

package/src/lib/__tests__/phrases.spec.js

@@ -0,0 +1,119 @@
+import { getPhrases } from '../phrases';
+
+jest.mock('../registry');
+
+describe('defaultPhrases', () => {
+  it('should merge en locale with given locale', () => {
+    const { getLocale } = require('../registry');
+
+    const locales = {
+      en: {
+        app: {
+          header: {
+            content: 'Contents',
+            workflow: 'Workflow',
+            media: 'Media',
+            quickAdd: 'Quick add',
+          },
+          app: {
+            errorHeader: 'Error loading the CMS configuration',
+            configErrors: 'Config Errors',
+            checkConfigYml: 'Check your config.yml file.',
+            loadingConfig: 'Loading configuration...',
+            waitingBackend: 'Waiting for backend...',
+          },
+          notFoundPage: {
+            header: 'Not Found',
+          },
+        },
+        collection: {
+          sidebar: {
+            collections: 'Collections',
+            searchAll: 'Search all',
+          },
+          collectionTop: {
+            viewAs: 'View as',
+            newButton: 'New %{collectionLabel}',
+          },
+          entries: {
+            loadingEntries: 'Loading Entries',
+            cachingEntries: 'Caching Entries',
+            longerLoading: 'This might take several minutes',
+          },
+        },
+      },
+      de: {
+        app: {
+          header: {
+            content: 'Inhalt',
+          },
+        },
+      },
+    };
+
+    getLocale.mockImplementation(locale => locales[locale]);
+
+    expect(getPhrases('de')).toEqual({
+      app: {
+        header: {
+          content: 'Inhalt',
+          workflow: 'Workflow',
+          media: 'Media',
+          quickAdd: 'Quick add',
+        },
+        app: {
+          errorHeader: 'Error loading the CMS configuration',
+          configErrors: 'Config Errors',
+          checkConfigYml: 'Check your config.yml file.',
+          loadingConfig: 'Loading configuration...',
+          waitingBackend: 'Waiting for backend...',
+        },
+        notFoundPage: {
+          header: 'Not Found',
+        },
+      },
+      collection: {
+        sidebar: {
+          collections: 'Collections',
+          searchAll: 'Search all',
+        },
+        collectionTop: {
+          viewAs: 'View as',
+          newButton: 'New %{collectionLabel}',
+        },
+        entries: {
+          loadingEntries: 'Loading Entries',
+          cachingEntries: 'Caching Entries',
+          longerLoading: 'This might take several minutes',
+        },
+      },
+    });
+  });
+
+  it('should not mutate default phrases', () => {
+    const { getLocale } = require('../registry');
+
+    const locales = {
+      en: {
+        app: {
+          header: {
+            content: 'Contents',
+          },
+        },
+      },
+      de: {
+        app: {
+          header: {
+            content: 'Inhalt',
+          },
+        },
+      },
+    };
+
+    getLocale.mockImplementation(locale => locales[locale]);
+
+    const result = getPhrases('de');
+
+    expect(result === locales['en']).toBe(false);
+  });
+});

package/src/lib/__tests__/registry.spec.js

@@ -0,0 +1,261 @@
+import { fromJS } from 'immutable';
+
+jest.spyOn(console, 'error').mockImplementation(() => {});
+
+describe('registry', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+  });
+
+  describe('registerLocale', () => {
+    it('should log error when name is empty', () => {
+      const { registerLocale } = require('../registry');
+
+      registerLocale();
+      expect(console.error).toHaveBeenCalledTimes(1);
+      expect(console.error).toHaveBeenCalledWith(
+        "Locale parameters invalid. example: CMS.registerLocale('locale', phrases)",
+      );
+    });
+
+    it('should log error when phrases are undefined', () => {
+      const { registerLocale } = require('../registry');
+
+      registerLocale('fr');
+      expect(console.error).toHaveBeenCalledTimes(1);
+      expect(console.error).toHaveBeenCalledWith(
+        "Locale parameters invalid. example: CMS.registerLocale('locale', phrases)",
+      );
+    });
+
+    it('should register locale', () => {
+      const { registerLocale, getLocale } = require('../registry');
+
+      const phrases = {
+        app: {
+          header: {
+            content: 'Inhalt',
+          },
+        },
+      };
+
+      registerLocale('de', phrases);
+
+      expect(getLocale('de')).toBe(phrases);
+    });
+  });
+
+  describe('registerCustomFormat', () => {
+    it('can register a custom format', () => {
+      const { getCustomFormats, registerCustomFormat } = require('../registry');
+
+      expect(Object.keys(getCustomFormats())).not.toContain('querystring');
+
+      registerCustomFormat('querystring', 'qs', {
+        fromFile: content => Object.fromEntries(new URLSearchParams(content)),
+        toFile: obj => new URLSearchParams(obj).toString(),
+      });
+
+      expect(Object.keys(getCustomFormats())).toContain('querystring');
+    });
+  });
+
+  describe('eventHandlers', () => {
+    const events = [
+      'prePublish',
+      'postPublish',
+      'preUnpublish',
+      'postUnpublish',
+      'preSave',
+      'postSave',
+    ];
+
+    describe('registerEventListener', () => {
+      it('should throw error on invalid event', () => {
+        const { registerEventListener } = require('../registry');
+
+        expect(() => registerEventListener({ name: 'unknown' })).toThrow(
+          new Error("Invalid event name 'unknown'"),
+        );
+      });
+
+      events.forEach(name => {
+        it(`should register '${name}' event`, () => {
+          const { registerEventListener, getEventListeners } = require('../registry');
+
+          const handler = jest.fn();
+          registerEventListener({ name, handler });
+
+          expect(getEventListeners(name)).toEqual([{ handler, options: {} }]);
+        });
+      });
+    });
+
+    describe('removeEventListener', () => {
+      it('should throw error on invalid event', () => {
+        const { removeEventListener } = require('../registry');
+
+        expect(() => removeEventListener({ name: 'unknown' })).toThrow(
+          new Error("Invalid event name 'unknown'"),
+        );
+      });
+
+      events.forEach(name => {
+        it(`should remove '${name}' event by handler`, () => {
+          const {
+            registerEventListener,
+            getEventListeners,
+            removeEventListener,
+          } = require('../registry');
+
+          const handler1 = jest.fn();
+          const handler2 = jest.fn();
+          registerEventListener({ name, handler: handler1 });
+          registerEventListener({ name, handler: handler2 });
+
+          expect(getEventListeners(name)).toHaveLength(2);
+
+          removeEventListener({ name, handler: handler1 });
+
+          expect(getEventListeners(name)).toEqual([{ handler: handler2, options: {} }]);
+        });
+      });
+
+      events.forEach(name => {
+        it(`should remove '${name}' event by name`, () => {
+          const {
+            registerEventListener,
+            getEventListeners,
+            removeEventListener,
+          } = require('../registry');
+
+          const handler1 = jest.fn();
+          const handler2 = jest.fn();
+          registerEventListener({ name, handler: handler1 });
+          registerEventListener({ name, handler: handler2 });
+
+          expect(getEventListeners(name)).toHaveLength(2);
+
+          removeEventListener({ name });
+
+          expect(getEventListeners(name)).toHaveLength(0);
+        });
+      });
+    });
+
+    describe('invokeEvent', () => {
+      it('should throw error on invalid event', async () => {
+        const { invokeEvent } = require('../registry');
+
+        await expect(invokeEvent({ name: 'unknown', data: {} })).rejects.toThrow(
+          new Error("Invalid event name 'unknown'"),
+        );
+      });
+
+      events.forEach(name => {
+        it(`should invoke '${name}' event with data`, async () => {
+          const { registerEventListener, invokeEvent } = require('../registry');
+
+          const options = { hello: 'world' };
+          const handler = jest.fn();
+
+          registerEventListener({ name, handler }, options);
+
+          const data = { entry: fromJS({ data: {} }) };
+          await invokeEvent({ name, data });
+
+          expect(handler).toHaveBeenCalledTimes(1);
+          expect(handler).toHaveBeenCalledWith(data, options);
+        });
+
+        it(`should invoke multiple handlers on '${name}`, async () => {
+          const { registerEventListener, invokeEvent } = require('../registry');
+
+          const options1 = { hello: 'test1' };
+          const options2 = { hello: 'test2' };
+          const handler = jest.fn(({ entry }) => entry.get('data'));
+
+          registerEventListener({ name, handler }, options1);
+          registerEventListener({ name, handler }, options2);
+
+          const data = { entry: fromJS({ data: {} }) };
+          await invokeEvent({ name, data });
+
+          expect(handler).toHaveBeenCalledTimes(2);
+          expect(handler).toHaveBeenLastCalledWith(data, options2);
+        });
+
+        it(`should throw error when '${name}' handler throws error`, async () => {
+          const { registerEventListener, invokeEvent } = require('../registry');
+
+          const handler = jest.fn(() => {
+            throw new Error('handler failed!');
+          });
+
+          registerEventListener({ name, handler });
+          const data = { entry: fromJS({ data: {} }) };
+
+          await expect(invokeEvent({ name, data })).rejects.toThrow('handler failed!');
+        });
+      });
+
+      it(`should return an updated entry's DataMap`, async () => {
+        const { registerEventListener, invokeEvent } = require('../registry');
+
+        const event = 'preSave';
+        const options = { hello: 'world' };
+        const handler1 = jest.fn(({ entry }) => {
+          const data = entry.get('data');
+          return data.set('a', 'test1');
+        });
+        const handler2 = jest.fn(({ entry }) => {
+          const data = entry.get('data');
+          return data.set('c', 'test2');
+        });
+
+        registerEventListener({ name: event, handler: handler1 }, options);
+        registerEventListener({ name: event, handler: handler2 }, options);
+
+        const data = {
+          entry: fromJS({ data: { a: 'foo', b: 'bar' } }),
+        };
+
+        const dataAfterFirstHandlerExecution = {
+          entry: fromJS({ data: { a: 'test1', b: 'bar' } }),
+        };
+        const dataAfterSecondHandlerExecution = {
+          entry: fromJS({ data: { a: 'test1', b: 'bar', c: 'test2' } }),
+        };
+
+        const result = await invokeEvent({ name: event, data });
+
+        expect(handler1).toHaveBeenCalledWith(data, options);
+        expect(handler2).toHaveBeenCalledWith(dataAfterFirstHandlerExecution, options);
+
+        expect(result).toEqual(dataAfterSecondHandlerExecution.entry.get('data'));
+      });
+
+      it('should allow multiple events to not return a value', async () => {
+        const { registerEventListener, invokeEvent } = require('../registry');
+
+        const event = 'prePublish';
+        const options = { hello: 'world' };
+        const handler1 = jest.fn();
+        const handler2 = jest.fn();
+
+        registerEventListener({ name: event, handler: handler1 }, options);
+        registerEventListener({ name: event, handler: handler2 }, options);
+
+        const data = {
+          entry: fromJS({ data: { a: 'foo', b: 'bar' } }),
+        };
+        const result = await invokeEvent({ name: event, data });
+
+        expect(handler1).toHaveBeenCalledWith(data, options);
+        expect(handler2).toHaveBeenCalledWith(data, options);
+        expect(result).toEqual(data.entry.get('data'));
+      });
+    });
+  });
+});

package/src/lib/__tests__/serializeEntryValues.spec.js

@@ -0,0 +1,22 @@
+import { fromJS } from 'immutable';
+
+import { serializeValues, deserializeValues } from '../serializeEntryValues';
+
+const values = fromJS({ title: 'New Post', unknown: 'Unknown Field' });
+const fields = fromJS([{ name: 'title', widget: 'string' }]);
+
+describe('serializeValues', () => {
+  it('should retain unknown fields', () => {
+    expect(serializeValues(values, fields)).toEqual(
+      fromJS({ title: 'New Post', unknown: 'Unknown Field' }),
+    );
+  });
+});
+
+describe('deserializeValues', () => {
+  it('should retain unknown fields', () => {
+    expect(deserializeValues(values, fields)).toEqual(
+      fromJS({ title: 'New Post', unknown: 'Unknown Field' }),
+    );
+  });
+});

package/src/lib/__tests__/urlHelper.spec.js

@@ -0,0 +1,138 @@
+import { sanitizeURI, sanitizeSlug, sanitizeChar } from '../urlHelper';
+
+describe('sanitizeURI', () => {
+  // `sanitizeURI` tests from RFC 3987
+  it('should keep valid URI chars (letters digits _ - . ~)', () => {
+    expect(sanitizeURI('This, that-one_or.the~other 123!')).toEqual('Thisthat-one_or.the~other123');
+  });
+
+  it('should not remove accents', () => {
+    expect(sanitizeURI('ěščřžý')).toEqual('ěščřžý');
+  });
+
+  it('should keep valid non-latin chars (ucschars in RFC 3987)', () => {
+    expect(sanitizeURI('日本語のタイトル')).toEqual('日本語のタイトル');
+  });
+
+  it('should not keep valid non-latin chars (ucschars in RFC 3987) if set to ASCII mode', () => {
+    expect(sanitizeURI('ěščřžý日本語のタイトル', { encoding: 'ascii' })).toEqual('');
+  });
+
+  it('should not normalize Unicode strings', () => {
+    expect(sanitizeURI('\u017F\u0323\u0307')).toEqual('\u017F\u0323\u0307');
+    expect(sanitizeURI('\u017F\u0323\u0307')).not.toEqual('\u1E9B\u0323');
+  });
+
+  it('should allow a custom replacement character', () => {
+    expect(sanitizeURI('duck\\goose.elephant', { replacement: '-' })).toEqual(
+      'duck-goose.elephant',
+    );
+  });
+
+  it('should not allow an improper replacement character', () => {
+    expect(() => {
+      sanitizeURI('I! like! dollars!', { replacement: '$' });
+    }).toThrow();
+  });
+
+  it('should not actually URI-encode the characters', () => {
+    expect(sanitizeURI('🎉')).toEqual('🎉');
+    expect(sanitizeURI('🎉')).not.toEqual('%F0%9F%8E%89');
+  });
+});
+
+const slugConfig = {
+  encoding: 'unicode',
+  clean_accents: false,
+  sanitize_replacement: '-',
+};
+
+describe('sanitizeSlug', () => {
+  it('throws an error for non-strings', () => {
+    expect(() => sanitizeSlug({})).toThrowError('The input slug must be a string.');
+    expect(() => sanitizeSlug([])).toThrowError('The input slug must be a string.');
+    expect(() => sanitizeSlug(false)).toThrowError('The input slug must be a string.');
+    expect(() => sanitizeSlug(null)).toThrowError('The input slug must be a string.');
+    expect(() => sanitizeSlug(11234)).toThrowError('The input slug must be a string.');
+    expect(() => sanitizeSlug(undefined)).toThrowError('The input slug must be a string.');
+    expect(() => sanitizeSlug(() => {})).toThrowError('The input slug must be a string.');
+  });
+
+  it('throws an error for non-string replacements', () => {
+    expect(() => sanitizeSlug('test', { sanitize_replacement: {} })).toThrowError(
+      '`options.replacement` must be a string.',
+    );
+    expect(() => sanitizeSlug('test', { sanitize_replacement: [] })).toThrowError(
+      '`options.replacement` must be a string.',
+    );
+    expect(() => sanitizeSlug('test', { sanitize_replacement: false })).toThrowError(
+      '`options.replacement` must be a string.',
+    );
+    expect(() => sanitizeSlug('test', { sanitize_replacement: null })).toThrowError(
+      '`options.replacement` must be a string.',
+    );
+    expect(() => sanitizeSlug('test', { sanitize_replacement: 11232 })).toThrowError(
+      '`options.replacement` must be a string.',
+    );
+    // do not test undefined for this variant since a default is set in the constructor.
+    //expect(() => sanitizeSlug('test', { sanitize_replacement: undefined })).toThrowError("`options.replacement` must be a string.");
+    expect(() => sanitizeSlug('test', { sanitize_replacement: () => {} })).toThrowError(
+      '`options.replacement` must be a string.',
+    );
+  });
+
+  it('should keep valid URI chars (letters digits _ - . ~)', () => {
+    expect(sanitizeSlug('This, that-one_or.the~other 123!', slugConfig)).toEqual(
+      'This-that-one_or.the~other-123',
+    );
+  });
+
+  it('should remove accents with `clean_accents` set', () => {
+    expect(sanitizeSlug('ěščřžý', { ...slugConfig, clean_accents: true })).toEqual('escrzy');
+  });
+
+  it('should remove non-latin chars in "ascii" mode', () => {
+    expect(sanitizeSlug('ěščřžý日本語のタイトル', { ...slugConfig, encoding: 'ascii' })).toEqual(
+      '',
+    );
+  });
+
+  it('should clean accents and strip non-latin chars in "ascii" mode with `clean_accents` set', () => {
+    expect(
+      sanitizeSlug('ěščřžý日本語のタイトル', {
+        ...slugConfig,
+        encoding: 'ascii',
+        clean_accents: true,
+      }),
+    ).toEqual('escrzy');
+  });
+
+  it('removes double replacements', () => {
+    expect(sanitizeSlug('test--test', slugConfig)).toEqual('test-test');
+    expect(sanitizeSlug('test   test', slugConfig)).toEqual('test-test');
+  });
+
+  it('removes trailing replacements', () => {
+    expect(sanitizeSlug('test   test   ', slugConfig)).toEqual('test-test');
+  });
+
+  it('removes leading replacements', () => {
+    expect(sanitizeSlug('"test"    test', slugConfig)).toEqual('test-test');
+  });
+
+  it('uses alternate replacements', () => {
+    expect(sanitizeSlug('test   test   ', { ...slugConfig, sanitize_replacement: '_' })).toEqual(
+      'test_test',
+    );
+  });
+});
+
+describe('sanitizeChar', () => {
+  it('should sanitize whitespace with default replacement', () => {
+    expect(sanitizeChar(' ', slugConfig)).toBe('-');
+  });
+
+  it('should sanitize whitespace with custom replacement', () => {
+    expect(sanitizeChar(' ', { ...slugConfig, sanitize_replacement: '_' })).toBe('_');
+  });
+});

package/src/lib/consoleError.js

@@ -0,0 +1,7 @@
+export default function consoleError(title, description) {
+  console.error(
+    `%c ⛔ ${title}\n` + `%c${description}\n\n`,
+    'color: black; font-weight: bold; font-size: 16px; line-height: 50px;',
+    'color: black;',
+  );
+}