@pranaysahith/decap-cms-core 3.9.1

package/src/actions/__tests__/media.spec.ts

@@ -0,0 +1,171 @@
+import { Map } from 'immutable';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import { mocked } from 'jest-mock';
+
+import { getAsset, ADD_ASSET, LOAD_ASSET_REQUEST } from '../media';
+import { selectMediaFilePath } from '../../reducers/entries';
+import AssetProxy from '../../valueObjects/AssetProxy';
+
+import type { State } from '../../types/redux';
+import type { AnyAction } from 'redux';
+import type { ThunkDispatch } from 'redux-thunk';
+
+const middlewares = [thunk];
+const mockStore = configureMockStore<Partial<State>, ThunkDispatch<State, {}, AnyAction>>(
+  middlewares,
+);
+const mockedSelectMediaFilePath = mocked(selectMediaFilePath);
+
+jest.mock('../../reducers/entries');
+jest.mock('../mediaLibrary');
+
+describe('media', () => {
+  const emptyAsset = new AssetProxy({
+    path: 'empty.svg',
+    file: new File([`<svg xmlns="http://www.w3.org/2000/svg"></svg>`], 'empty.svg', {
+      type: 'image/svg+xml',
+    }),
+  });
+
+  describe('getAsset', () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.URL = { createObjectURL: jest.fn() };
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('should return empty asset for null path', () => {
+      const store = mockStore({});
+
+      const payload = { collection: null, entryPath: null, entry: null, path: null };
+
+      // TODO change to proper payload when immutable is removed
+      //  from 'collections' and 'entries' state slices
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = store.dispatch(getAsset(payload));
+      const actions = store.getActions();
+      expect(actions).toHaveLength(0);
+      expect(result).toEqual(emptyAsset);
+    });
+
+    it('should return asset from medias state', () => {
+      const path = 'static/media/image.png';
+      const asset = new AssetProxy({ file: new File([], 'empty'), path });
+      const store = mockStore({
+        // TODO change to proper store data when immutable is removed
+        //  from 'config' state slice
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        config: Map(),
+        medias: {
+          [path]: { asset, isLoading: false, error: null },
+        },
+      });
+
+      mockedSelectMediaFilePath.mockReturnValue(path);
+      const payload = { collection: Map(), entry: Map({ path: 'entryPath' }), path };
+
+      // TODO change to proper payload when immutable is removed
+      //  from 'collections' and 'entries' state slices
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = store.dispatch(getAsset(payload));
+      const actions = store.getActions();
+      expect(actions).toHaveLength(0);
+
+      expect(result).toBe(asset);
+      expect(mockedSelectMediaFilePath).toHaveBeenCalledTimes(1);
+      expect(mockedSelectMediaFilePath).toHaveBeenCalledWith(
+        store.getState().config,
+        payload.collection,
+        payload.entry,
+        path,
+        undefined,
+      );
+    });
+
+    it('should create asset for absolute path when not in medias state', () => {
+      const path = 'https://asset.netlify.com/image.png';
+
+      const asset = new AssetProxy({ url: path, path });
+      const store = mockStore({
+        medias: {},
+      });
+
+      mockedSelectMediaFilePath.mockReturnValue(path);
+      const payload = { collection: null, entryPath: null, path };
+
+      // TODO change to proper payload when immutable is removed
+      //  from 'collections' state slice
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = store.dispatch(getAsset(payload));
+      const actions = store.getActions();
+      expect(actions).toHaveLength(1);
+      expect(actions[0]).toEqual({
+        type: ADD_ASSET,
+        payload: asset,
+      });
+      expect(result).toEqual(asset);
+    });
+
+    it('should return empty asset and initiate load when not in medias state', () => {
+      const path = 'static/media/image.png';
+      const store = mockStore({
+        medias: {},
+      });
+
+      mockedSelectMediaFilePath.mockReturnValue(path);
+      const payload = { path };
+
+      // TODO change to proper payload when immutable is removed
+      //  from 'collections' and 'entries' state slices
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = store.dispatch(getAsset(payload));
+      const actions = store.getActions();
+      expect(actions).toHaveLength(1);
+      expect(actions[0]).toEqual({
+        type: LOAD_ASSET_REQUEST,
+        payload: { path },
+      });
+      expect(result).toEqual(emptyAsset);
+    });
+
+    it('should return asset with original path on load error', () => {
+      const path = 'static/media/image.png';
+      const resolvePath = 'resolvePath';
+      const store = mockStore({
+        medias: {
+          [resolvePath]: {
+            asset: undefined,
+            error: new Error('test'),
+            isLoading: false,
+          },
+        },
+      });
+
+      mockedSelectMediaFilePath.mockReturnValue(resolvePath);
+      const payload = { path };
+
+      // TODO change to proper payload when immutable is removed
+      //  from 'collections' and 'entries' state slices
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = store.dispatch(getAsset(payload));
+      const actions = store.getActions();
+
+      const asset = new AssetProxy({ url: path, path: resolvePath });
+      expect(actions).toHaveLength(1);
+      expect(actions[0]).toEqual({
+        type: ADD_ASSET,
+        payload: asset,
+      });
+      expect(result).toEqual(asset);
+    });
+  });
+});

package/src/actions/__tests__/mediaLibrary.spec.js

@@ -0,0 +1,327 @@
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import { List, Map } from 'immutable';
+
+import { insertMedia, persistMedia, deleteMedia } from '../mediaLibrary';
+
+jest.mock('../../backend');
+jest.mock('../waitUntil');
+jest.mock('decap-cms-lib-util', () => {
+  const lib = jest.requireActual('decap-cms-lib-util');
+  return {
+    ...lib,
+    getBlobSHA: jest.fn(),
+  };
+});
+
+const middlewares = [thunk];
+const mockStore = configureMockStore(middlewares);
+
+describe('mediaLibrary', () => {
+  describe('insertMedia', () => {
+    it('should return mediaPath as string when string is given', () => {
+      const store = mockStore({
+        config: {
+          public_folder: '/media',
+        },
+        collections: Map({
+          posts: Map({ name: 'posts' }),
+        }),
+        entryDraft: Map({
+          entry: Map({ isPersisting: false, collection: 'posts' }),
+        }),
+      });
+
+      store.dispatch(insertMedia('foo.png'));
+      expect(store.getActions()[0]).toEqual({
+        type: 'MEDIA_INSERT',
+        payload: { mediaPath: '/media/foo.png' },
+      });
+    });
+
+    it('should return mediaPath as array of strings when array of strings is given', () => {
+      const store = mockStore({
+        config: {
+          public_folder: '/media',
+        },
+        collections: Map({
+          posts: Map({ name: 'posts' }),
+        }),
+        entryDraft: Map({
+          entry: Map({ isPersisting: false, collection: 'posts' }),
+        }),
+      });
+
+      store.dispatch(insertMedia(['foo.png']));
+      expect(store.getActions()[0]).toEqual({
+        type: 'MEDIA_INSERT',
+        payload: { mediaPath: ['/media/foo.png'] },
+      });
+    });
+  });
+
+  const { currentBackend } = require('../../backend');
+
+  const backend = {
+    persistMedia: jest.fn(() => ({ id: 'id' })),
+    deleteMedia: jest.fn(),
+  };
+
+  currentBackend.mockReturnValue(backend);
+
+  describe('persistMedia', () => {
+    global.URL = { createObjectURL: jest.fn().mockReturnValue('displayURL') };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should not persist media when editing draft', () => {
+      const { getBlobSHA } = require('decap-cms-lib-util');
+
+      getBlobSHA.mockReturnValue('000000000000000');
+
+      const store = mockStore({
+        config: {
+          media_folder: 'static/media',
+          slug: {
+            encoding: 'unicode',
+            clean_accents: false,
+            sanitize_replacement: '-',
+          },
+        },
+        collections: Map({
+          posts: Map({ name: 'posts' }),
+        }),
+        integrations: Map(),
+        mediaLibrary: Map({
+          files: List(),
+        }),
+        entryDraft: Map({
+          entry: Map({ isPersisting: false, collection: 'posts' }),
+        }),
+      });
+
+      const file = new File([''], 'name.png');
+
+      return store.dispatch(persistMedia(file)).then(() => {
+        const actions = store.getActions();
+
+        expect(actions).toHaveLength(2);
+        expect(actions[0].type).toEqual('ADD_ASSET');
+        expect(actions[0].payload).toEqual(
+          expect.objectContaining({
+            path: 'static/media/name.png',
+          }),
+        );
+        expect(actions[1].type).toEqual('ADD_DRAFT_ENTRY_MEDIA_FILE');
+        expect(actions[1].payload).toEqual(
+          expect.objectContaining({
+            draft: true,
+            id: '000000000000000',
+            path: 'static/media/name.png',
+            size: file.size,
+            name: file.name,
+          }),
+        );
+
+        expect(getBlobSHA).toHaveBeenCalledTimes(1);
+        expect(getBlobSHA).toHaveBeenCalledWith(file);
+        expect(backend.persistMedia).toHaveBeenCalledTimes(0);
+      });
+    });
+
+    it('should persist media when not editing draft', () => {
+      const store = mockStore({
+        config: {
+          media_folder: 'static/media',
+          slug: {
+            encoding: 'unicode',
+            clean_accents: false,
+            sanitize_replacement: '-',
+          },
+        },
+        collections: Map({
+          posts: Map({ name: 'posts' }),
+        }),
+        integrations: Map(),
+        mediaLibrary: Map({
+          files: List(),
+        }),
+        entryDraft: Map({
+          entry: Map(),
+        }),
+      });
+
+      const file = new File([''], 'name.png');
+
+      return store.dispatch(persistMedia(file)).then(() => {
+        const actions = store.getActions();
+
+        expect(actions).toHaveLength(3);
+
+        expect(actions).toHaveLength(3);
+        expect(actions[0]).toEqual({ type: 'MEDIA_PERSIST_REQUEST' });
+        expect(actions[1].type).toEqual('ADD_ASSET');
+        expect(actions[1].payload).toEqual(
+          expect.objectContaining({
+            path: 'static/media/name.png',
+          }),
+        );
+        expect(actions[2]).toEqual({
+          type: 'MEDIA_PERSIST_SUCCESS',
+          payload: {
+            file: { id: 'id' },
+          },
+        });
+
+        expect(backend.persistMedia).toHaveBeenCalledTimes(1);
+        expect(backend.persistMedia).toHaveBeenCalledWith(
+          store.getState().config,
+          expect.objectContaining({
+            path: 'static/media/name.png',
+          }),
+        );
+      });
+    });
+
+    it('should sanitize media name if needed when persisting', () => {
+      const store = mockStore({
+        config: {
+          media_folder: 'static/media',
+          slug: {
+            encoding: 'ascii',
+            clean_accents: true,
+            sanitize_replacement: '_',
+          },
+        },
+        collections: Map({
+          posts: Map({ name: 'posts' }),
+        }),
+        integrations: Map(),
+        mediaLibrary: Map({
+          files: List(),
+        }),
+        entryDraft: Map({
+          entry: Map(),
+        }),
+      });
+
+      const file = new File([''], 'abc DEF éâçÖ $;, .png');
+
+      return store.dispatch(persistMedia(file)).then(() => {
+        const actions = store.getActions();
+
+        expect(actions).toHaveLength(3);
+
+        expect(actions[0]).toEqual({ type: 'MEDIA_PERSIST_REQUEST' });
+
+        expect(actions[1].type).toEqual('ADD_ASSET');
+        expect(actions[1].payload).toEqual(
+          expect.objectContaining({
+            path: 'static/media/abc_def_eaco_.png',
+          }),
+        );
+
+        expect(actions[2]).toEqual({
+          type: 'MEDIA_PERSIST_SUCCESS',
+          payload: {
+            file: { id: 'id' },
+          },
+        });
+
+        expect(backend.persistMedia).toHaveBeenCalledTimes(1);
+        expect(backend.persistMedia).toHaveBeenCalledWith(
+          store.getState().config,
+          expect.objectContaining({
+            path: 'static/media/abc_def_eaco_.png',
+          }),
+        );
+      });
+    });
+  });
+
+  describe('deleteMedia', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should delete non draft file', () => {
+      const store = mockStore({
+        config: {
+          publish_mode: 'editorial_workflow',
+        },
+        collections: Map(),
+        integrations: Map(),
+        mediaLibrary: Map({
+          files: List(),
+        }),
+        entryDraft: Map({
+          entry: Map({ isPersisting: false }),
+        }),
+      });
+
+      const file = { name: 'name.png', id: 'id', path: 'static/media/name.png', draft: false };
+
+      return store.dispatch(deleteMedia(file)).then(() => {
+        const actions = store.getActions();
+
+        expect(actions).toHaveLength(4);
+        expect(actions[0]).toEqual({ type: 'MEDIA_DELETE_REQUEST' });
+        expect(actions[1]).toEqual({
+          type: 'REMOVE_ASSET',
+          payload: 'static/media/name.png',
+        });
+        expect(actions[2]).toEqual({
+          type: 'MEDIA_DELETE_SUCCESS',
+          payload: { file },
+        });
+        expect(actions[3]).toEqual({
+          type: 'REMOVE_DRAFT_ENTRY_MEDIA_FILE',
+          payload: { id: 'id' },
+        });
+
+        expect(backend.deleteMedia).toHaveBeenCalledTimes(1);
+        expect(backend.deleteMedia).toHaveBeenCalledWith(
+          store.getState().config,
+          'static/media/name.png',
+        );
+      });
+    });
+
+    it('should not delete a draft file', () => {
+      const store = mockStore({
+        config: {
+          publish_mode: 'editorial_workflow',
+        },
+        collections: Map(),
+        integrations: Map(),
+        mediaLibrary: Map({
+          files: List(),
+        }),
+        entryDraft: Map({
+          entry: Map({ isPersisting: false }),
+        }),
+      });
+
+      const file = { name: 'name.png', id: 'id', path: 'static/media/name.png', draft: true };
+
+      return store.dispatch(deleteMedia(file)).then(() => {
+        const actions = store.getActions();
+
+        expect(actions).toHaveLength(2);
+        expect(actions[0]).toEqual({
+          type: 'REMOVE_ASSET',
+          payload: 'static/media/name.png',
+        });
+
+        expect(actions[1]).toEqual({
+          type: 'REMOVE_DRAFT_ENTRY_MEDIA_FILE',
+          payload: { id: 'id' },
+        });
+
+        expect(backend.deleteMedia).toHaveBeenCalledTimes(0);
+      });
+    });
+  });
+});

package/src/actions/__tests__/search.spec.js

@@ -0,0 +1,209 @@
+import { fromJS } from 'immutable';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+
+import { searchEntries } from '../search';
+
+const middlewares = [thunk];
+const mockStore = configureMockStore(middlewares);
+
+jest.mock('../../reducers');
+jest.mock('../../backend');
+jest.mock('../../integrations');
+
+describe('search', () => {
+  describe('searchEntries', () => {
+    const { currentBackend } = require('../../backend');
+    const { selectIntegration } = require('../../reducers');
+    const { getIntegrationProvider } = require('../../integrations');
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+    it('should search entries in all collections using integration', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: {},
+      });
+
+      selectIntegration.mockReturnValue('search_integration');
+      currentBackend.mockReturnValue({});
+      const response = { entries: [{ name: '1' }, { name: '' }], pagination: 1 };
+      const integration = { search: jest.fn().mockResolvedValue(response) };
+      getIntegrationProvider.mockReturnValue(integration);
+
+      await store.dispatch(searchEntries('find me'));
+      const actions = store.getActions();
+      expect(actions).toHaveLength(2);
+
+      expect(actions[0]).toEqual({
+        type: 'SEARCH_ENTRIES_REQUEST',
+        payload: {
+          searchTerm: 'find me',
+          searchCollections: ['posts', 'pages'],
+          page: 0,
+        },
+      });
+      expect(actions[1]).toEqual({
+        type: 'SEARCH_ENTRIES_SUCCESS',
+        payload: {
+          entries: response.entries,
+          page: response.pagination,
+        },
+      });
+
+      expect(integration.search).toHaveBeenCalledTimes(1);
+      expect(integration.search).toHaveBeenCalledWith(['posts', 'pages'], 'find me', 0);
+    });
+
+    it('should search entries in a subset of collections using integration', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: {},
+      });
+
+      selectIntegration.mockReturnValue('search_integration');
+      currentBackend.mockReturnValue({});
+      const response = { entries: [{ name: '1' }, { name: '' }], pagination: 1 };
+      const integration = { search: jest.fn().mockResolvedValue(response) };
+      getIntegrationProvider.mockReturnValue(integration);
+
+      await store.dispatch(searchEntries('find me', ['pages']));
+      const actions = store.getActions();
+      expect(actions).toHaveLength(2);
+
+      expect(actions[0]).toEqual({
+        type: 'SEARCH_ENTRIES_REQUEST',
+        payload: {
+          searchTerm: 'find me',
+          searchCollections: ['pages'],
+          page: 0,
+        },
+      });
+      expect(actions[1]).toEqual({
+        type: 'SEARCH_ENTRIES_SUCCESS',
+        payload: {
+          entries: response.entries,
+          page: response.pagination,
+        },
+      });
+
+      expect(integration.search).toHaveBeenCalledTimes(1);
+      expect(integration.search).toHaveBeenCalledWith(['pages'], 'find me', 0);
+    });
+
+    it('should search entries in all collections using backend', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: {},
+      });
+
+      const response = { entries: [{ name: '1' }, { name: '' }], pagination: 1 };
+      const backend = { search: jest.fn().mockResolvedValue(response) };
+      currentBackend.mockReturnValue(backend);
+
+      await store.dispatch(searchEntries('find me'));
+
+      const actions = store.getActions();
+      expect(actions).toHaveLength(2);
+
+      expect(actions[0]).toEqual({
+        type: 'SEARCH_ENTRIES_REQUEST',
+        payload: {
+          searchTerm: 'find me',
+          searchCollections: ['posts', 'pages'],
+          page: 0,
+        },
+      });
+      expect(actions[1]).toEqual({
+        type: 'SEARCH_ENTRIES_SUCCESS',
+        payload: {
+          entries: response.entries,
+          page: response.pagination,
+        },
+      });
+
+      expect(backend.search).toHaveBeenCalledTimes(1);
+      expect(backend.search).toHaveBeenCalledWith(
+        [fromJS({ name: 'posts' }), fromJS({ name: 'pages' })],
+        'find me',
+      );
+    });
+
+    it('should search entries in a subset of collections using backend', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: {},
+      });
+
+      const response = { entries: [{ name: '1' }, { name: '' }], pagination: 1 };
+      const backend = { search: jest.fn().mockResolvedValue(response) };
+      currentBackend.mockReturnValue(backend);
+
+      await store.dispatch(searchEntries('find me', ['pages']));
+
+      const actions = store.getActions();
+      expect(actions).toHaveLength(2);
+
+      expect(actions[0]).toEqual({
+        type: 'SEARCH_ENTRIES_REQUEST',
+        payload: {
+          searchTerm: 'find me',
+          searchCollections: ['pages'],
+          page: 0,
+        },
+      });
+      expect(actions[1]).toEqual({
+        type: 'SEARCH_ENTRIES_SUCCESS',
+        payload: {
+          entries: response.entries,
+          page: response.pagination,
+        },
+      });
+
+      expect(backend.search).toHaveBeenCalledTimes(1);
+      expect(backend.search).toHaveBeenCalledWith([fromJS({ name: 'pages' })], 'find me');
+    });
+
+    it('should ignore identical search in all collections', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: { isFetching: true, term: 'find me', collections: ['posts', 'pages'] },
+      });
+
+      await store.dispatch(searchEntries('find me'));
+
+      const actions = store.getActions();
+      expect(actions).toHaveLength(0);
+    });
+
+    it('should ignore identical search in a subset of collections', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: { isFetching: true, term: 'find me', collections: ['pages'] },
+      });
+
+      await store.dispatch(searchEntries('find me', ['pages']));
+
+      const actions = store.getActions();
+      expect(actions).toHaveLength(0);
+    });
+
+    it('should not ignore same search term in different search collections', async () => {
+      const store = mockStore({
+        collections: fromJS({ posts: { name: 'posts' }, pages: { name: 'pages' } }),
+        search: { isFetching: true, term: 'find me', collections: ['pages'] },
+      });
+      const backend = { search: jest.fn().mockResolvedValue({}) };
+      currentBackend.mockReturnValue(backend);
+
+      await store.dispatch(searchEntries('find me', ['posts', 'pages']));
+
+      expect(backend.search).toHaveBeenCalledTimes(1);
+      expect(backend.search).toHaveBeenCalledWith(
+        [fromJS({ name: 'posts' }), fromJS({ name: 'pages' })],
+        'find me',
+      );
+    });
+  });
+});