@eeacms/volto-clms-theme 1.0.63 → 1.0.67

package/src/reducers/extra_breadcrumbs/extra_breadcrumb_reducer.js

@@ -6,6 +6,9 @@
 import { GET_EXTRA_BREADCRUMB_ITEMS } from '../../actions/extra_breadcrumbs/extra_breadcrumb';
 
 const initialState = {
+  loading: false,
+  loaded: false,
+  error: null,
   items: [],
 };
 
@@ -14,9 +17,26 @@ export const extraBreadcrumbItemsReducer = (
   action = {},
 ) => {
   switch (action?.type) {
-    case GET_EXTRA_BREADCRUMB_ITEMS:
+    case `${GET_EXTRA_BREADCRUMB_ITEMS}_PENDING`:
       return {
         ...state,
+        loading: true,
+        loaded: false,
+        items: action.items,
+      };
+    case `${GET_EXTRA_BREADCRUMB_ITEMS}_SUCCESS`:
+      return {
+        ...state,
+        loading: false,
+        loaded: true,
+        items: action.items,
+      };
+    case `${GET_EXTRA_BREADCRUMB_ITEMS}_FAIL`:
+      return {
+        ...state,
+        loading: false,
+        loaded: true,
+        error: true,
         items: action.items,
       };
     default:

package/src/reducers/extra_breadcrumbs/extra_breadcrumb_reducer.test.js

@@ -0,0 +1,51 @@
+import { extraBreadcrumbItemsReducer } from './extra_breadcrumb_reducer';
+import { GET_EXTRA_BREADCRUMB_ITEMS } from '../../actions/extra_breadcrumbs/extra_breadcrumb';
+
+//jest test for extraBreadcrumbItemsReducer
+describe('extraBreadcrumbItemsReducer', () => {
+  it('should return the initial state', () => {
+    expect(extraBreadcrumbItemsReducer(undefined)).toEqual({
+      error: null,
+      items: [],
+      loaded: false,
+      loading: false,
+    });
+  });
+  //jest test for extraBreadcrumbItemsReducer -success
+  it('should handle GET_EXTRA_BREADCRUMB_ITEMS_SUCCESS', () => {
+    const action = {
+      type: `${GET_EXTRA_BREADCRUMB_ITEMS}_SUCCESS`,
+      items: ['breadcrumb-item-1'],
+    };
+    expect(extraBreadcrumbItemsReducer({}, action)).toEqual({
+      loading: false,
+      loaded: true,
+      items: action.items,
+    });
+  });
+  //jest test for extraBreadcrumbItemsReducer -fail
+  it('should handle GET_EXTRA_BREADCRUMB_ITEMS_FAIL', () => {
+    const action = {
+      type: `${GET_EXTRA_BREADCRUMB_ITEMS}_FAIL`,
+      items: ['breadcrumb-item-1'],
+    };
+    expect(extraBreadcrumbItemsReducer({}, action)).toEqual({
+      items: action.items,
+      loading: false,
+      loaded: true,
+      error: true,
+    });
+  });
+  //jest test for extraBreadcrumbItemsReducer -pending
+  it('should handle GET_EXTRA_BREADCRUMB_ITEMS_PENDING', () => {
+    const action = {
+      type: `${GET_EXTRA_BREADCRUMB_ITEMS}_PENDING`,
+      items: ['breadcrumb-item-1'],
+    };
+    expect(extraBreadcrumbItemsReducer({}, action)).toEqual({
+      loading: true,
+      loaded: false,
+      items: action.items,
+    });
+  });
+});

package/src/reducers/geonetwork/import_geonetwork_reducer.test.js

@@ -0,0 +1,60 @@
+import { importGeonetworkReducer } from './import_geonetwork_reducer';
+import { POST_IMPORT_GEONETWORK } from '../../actions';
+
+//jest test for importGeonetworkReducer
+describe('importGeonetworkReducer', () => {
+  it('should return the initial state', () => {
+    expect(importGeonetworkReducer(undefined)).toEqual({
+      error: null,
+      loaded: false,
+      loading: false,
+      imported_data: {},
+    });
+  });
+  //jest test for importGeonetworkReducer -success
+  it('should handle POST_IMPORT_GEONETWORK_SUCCESS', () => {
+    const action = {
+      type: `${POST_IMPORT_GEONETWORK}_SUCCESS`,
+      result: '{"imported_data": {"id": "1"}}',
+    };
+    expect(importGeonetworkReducer({}, action)).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+      imported_data: JSON.parse(action.result),
+    });
+  });
+  //jest test for importGeonetworkReducer -fail
+  it('should handle POST_IMPORT_GEONETWORK_FAIL', () => {
+    expect(
+      importGeonetworkReducer(
+        {},
+        {
+          type: `${POST_IMPORT_GEONETWORK}_FAIL`,
+          error: 'error',
+        },
+      ),
+    ).toEqual({
+      error: 'error',
+      loaded: false,
+      loading: false,
+      imported_data: {},
+    });
+  });
+  //jest test for importGeonetworkReducer -pending
+  it('should handle POST_IMPORT_GEONETWORK_PENDING', () => {
+    expect(
+      importGeonetworkReducer(
+        {},
+        {
+          type: `${POST_IMPORT_GEONETWORK}_PENDING`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+      imported_data: {},
+    });
+  });
+});

package/src/reducers/index.js

@@ -9,13 +9,12 @@ import { extraBreadcrumbItemsReducer } from './extra_breadcrumbs/extra_breadcrum
 import { importGeonetworkReducer } from './geonetwork/import_geonetwork_reducer';
 import { meetingRegisterReducer } from './meeting/meeting_register_reducer';
 import { meetingSubscribersReducer } from './meeting/meeting_subscribers_reducer';
+import { newsletterSubscribersReducer } from './newsletter/get_newsletter_reducer';
+import { nutsnamesReducer } from './downloadtool/nutsnames_reducer';
 import { registryReducer } from './registry/registry';
-// import defaultReducers from '@plone/volto/reducers';
+import { subscribeToReducer } from './subscription/subscription_reducer';
 import tokens from './tokens/tokens';
 import { userschemaReducer } from './userschema/userschema';
-// import { newsletterReducer } from './newsletter/newsletter_reducer';
-import { newsletterSubscribersReducer } from './newsletter/get_newsletter_reducer';
-import { subscribeToReducer } from './subscription/subscription_reducer';
 
 /**
  * Root reducer.
@@ -32,6 +31,7 @@ const reducers = {
   meeting_register: meetingRegisterReducer,
   subscribers: meetingSubscribersReducer,
   downloadtool: downloadtoolReducer,
+  nutsnames: nutsnamesReducer,
   registry: registryReducer,
   geonetwork_importation: importGeonetworkReducer,
   userschema: userschemaReducer,

package/src/reducers/meeting/meeting_register_reducer.test.js

@@ -0,0 +1,82 @@
+import { POST_MEETING_REGISTER } from '../../actions';
+import { meetingRegisterReducer } from './meeting_register_reducer';
+
+//jest test to meetingRegisterReducer
+describe('meetingRegisterReducer', () => {
+  it('should return the initial state', () => {
+    expect(meetingRegisterReducer(undefined)).toEqual({
+      error: null,
+      loaded: false,
+      loading: false,
+      logged_user_registration: false,
+      registered_message: '',
+    });
+  });
+  //jest test to POST_MEETING_REGISTER_SUCCESS
+  /* it('should handle POST_MEETING_REGISTER_SUCCESS', () => {
+    const action = {
+      result: { email: true, subject: '', body: '' },
+    };
+    expect(
+      meetingRegisterReducer(
+        {
+          error: null,
+          loaded: false,
+          loading: false,
+          logged_user_registration: false,
+          registered_message: action.result.registered_message,
+        },
+        {
+          type: `${POST_MEETING_REGISTER}_SUCCESS`,
+          logged_user_registration: true,
+          registered_message: '',
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+      logged_user_registration: true,
+      registered_message: action.result.registered_message,
+    });
+  }); */
+  //jest test to meetingRegisterReducer -fail
+  it('should handle POST_MEETING_REGISTER_FAIL', () => {
+    const action = {
+      type: `${POST_MEETING_REGISTER}_FAIL`,
+      error: true,
+      loaded: false,
+      loading: false,
+      result: {
+        message: '',
+      },
+    };
+    expect(meetingRegisterReducer({}, action)).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      registered_message: action.result?.message || action.error?.message,
+      logged_user_registration: false,
+    });
+  });
+  //jest test to meetingRegisterReducer -pending
+  it('should handle POST_MEETING_REGISTER_PENDING', () => {
+    expect(
+      meetingRegisterReducer(
+        {},
+        {
+          type: `${POST_MEETING_REGISTER}_PENDING`,
+          error: null,
+          loaded: false,
+          loading: true,
+          logged_user_registration: false,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+      logged_user_registration: false,
+    });
+  });
+});

package/src/reducers/meeting/meeting_subscribers_reducer.js

@@ -3,8 +3,10 @@
  * @module reducers/cartItemsReducer
  */
 
-import { MEETING_SUBSCRIBERS } from '../../actions';
-import { MEETING_SUBSCRIBERS_MANIPULATION } from '../../actions';
+import {
+  MEETING_SUBSCRIBERS,
+  MEETING_SUBSCRIBERS_MANIPULATION,
+} from '../../actions';
 
 const initialState = {
   error: null,

package/src/reducers/meeting/meeting_subscribers_reducer.test.js

@@ -0,0 +1,149 @@
+import {
+  MEETING_SUBSCRIBERS,
+  MEETING_SUBSCRIBERS_MANIPULATION,
+} from '../../actions';
+import { meetingSubscribersReducer } from './meeting_subscribers_reducer';
+
+//jest test to meetingSubscribersReducer
+describe('meetingSubscribersReducer', () => {
+  it('should return the initial state', () => {
+    expect(meetingSubscribersReducer(undefined)).toEqual({
+      error: null,
+      loaded: false,
+      loading: false,
+      items: [],
+      message: '',
+    });
+  });
+  //jest test to meetingSubscribersReducer -success
+  it('should handle MEETING_SUBSCRIBERS_SUCCESS', () => {
+    expect(
+      meetingSubscribersReducer(
+        {},
+        {
+          type: `${MEETING_SUBSCRIBERS}_SUCCESS`,
+          result: {
+            items: [
+              {
+                id: '1',
+                name: 'test',
+                email: '',
+              },
+            ],
+          },
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+      items: [
+        {
+          id: '1',
+          name: 'test',
+          email: '',
+        },
+      ],
+      message: '',
+    });
+  });
+  //jest test to meetingSubscribersReducer -fail
+  it('should handle MEETING_SUBSCRIBERS_FAIL', () => {
+    const action = {
+      type: `${MEETING_SUBSCRIBERS}_FAIL`,
+      error: true,
+      loaded: false,
+      loading: false,
+    };
+    expect(meetingSubscribersReducer({}, action)).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      message: '',
+    });
+  });
+  //jest test to meetingSubscribersReducer -pending
+  it('should handle MEETING_SUBSCRIBERS_PENDING', () => {
+    expect(
+      meetingSubscribersReducer(
+        {},
+        {
+          type: `${MEETING_SUBSCRIBERS}_PENDING`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+      message: '',
+    });
+  });
+  //jest test to meetingSubscribersReducer -manipulation  -success
+  it('should handle MEETING_SUBSCRIBERS_MANIPULATION_SUCCESS', () => {
+    expect(
+      meetingSubscribersReducer(
+        {},
+        {
+          type: `${MEETING_SUBSCRIBERS_MANIPULATION}_SUCCESS`,
+          result: {
+            message: 'success',
+            items: [],
+          },
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+      items: [],
+      message: 'success',
+    });
+  });
+  //jest test to meetingSubscribersReducer -manipulation  -fail
+  it('should handle MEETING_SUBSCRIBERS_MANIPULATION_FAIL', () => {
+    const action = {
+      type: `${MEETING_SUBSCRIBERS_MANIPULATION}_FAIL`,
+      result: {
+        message: 'error',
+      },
+      error: true,
+    };
+    expect(meetingSubscribersReducer({}, action)).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      message: 'error' || '',
+    });
+  });
+  it('should handle MEETING_SUBSCRIBERS_MANIPULATION_FAIL without error message', () => {
+    const action = {
+      type: `${MEETING_SUBSCRIBERS_MANIPULATION}_FAIL`,
+      error: true,
+      result: {
+        message: '',
+      },
+    };
+    expect(meetingSubscribersReducer({}, action)).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      message: '',
+    });
+  });
+  //jest test to meetingSubscribersReducer -manipulation  -pending
+  it('should handle MEETING_SUBSCRIBERS_MANIPULATION_PENDING', () => {
+    expect(
+      meetingSubscribersReducer(
+        {},
+        {
+          type: `${MEETING_SUBSCRIBERS_MANIPULATION}_PENDING`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+    });
+  });
+});
+// End of file

package/src/reducers/newsletter/get_newsletter_reducer.test.js

@@ -0,0 +1,75 @@
+import { newsletterSubscribersReducer } from './get_newsletter_reducer';
+import { GET_NEWSLETTER } from '../../actions';
+
+//jest test for newsletterSubscribersReducer
+describe('newsletterSubscribersReducer', () => {
+  it('should return the initial state', () => {
+    expect(newsletterSubscribersReducer(undefined)).toEqual({
+      error: null,
+      loaded: false,
+      loading: false,
+      items: [],
+    });
+  });
+  //jest test for newsletterSubscribersReducer -pending
+  it('should handle GET_NEWSLETTER_PENDING', () => {
+    expect(
+      newsletterSubscribersReducer(
+        {},
+        {
+          type: `${GET_NEWSLETTER}_PENDING`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+      items: [],
+    });
+  });
+  //jest test for newsletterSubscribersReducer -fail
+  it('should handle GET_NEWSLETTER_FAIL', () => {
+    expect(
+      newsletterSubscribersReducer(
+        {},
+        {
+          type: `${GET_NEWSLETTER}_FAIL`,
+        },
+      ),
+    ).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      items: [],
+    });
+  });
+  //jest test for newsletterSubscribersReducer -success
+  it('should handle GET_NEWSLETTER_SUCCESS', () => {
+    expect(
+      newsletterSubscribersReducer(
+        {},
+        {
+          type: `${GET_NEWSLETTER}_SUCCESS`,
+          result: {
+            subscribers: [
+              {
+                id: 'newsletter-subscriber-1',
+                email: '',
+              },
+            ],
+          },
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+      items: [
+        {
+          id: 'newsletter-subscriber-1',
+          email: '',
+        },
+      ],
+    });
+  });
+});

package/src/reducers/registry/registry.test.js

@@ -0,0 +1,74 @@
+import { GET_REGISTRY } from '../../actions';
+import { registryReducer } from './registry';
+
+//jest test for registryReducer
+describe('registryReducer', () => {
+  it('should return the initial state', () => {
+    expect(registryReducer(undefined)).toEqual({
+      error: null,
+      loaded: false,
+      loading: false,
+      records: {},
+    });
+  });
+  //jest test for registryReducer -pending
+  it('should handle GET_REGISTRY_PENDING', () => {
+    expect(
+      registryReducer(
+        {},
+        {
+          type: `${GET_REGISTRY}_PENDING`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+    });
+  });
+  //jest test for registryReducer -fail
+  it('should handle GET_REGISTRY_FAIL', () => {
+    const action = {
+      type: `${GET_REGISTRY}_FAIL`,
+      error: 'error',
+    };
+    expect(registryReducer({}, action)).toEqual({
+      error: action.error,
+      loaded: false,
+      loading: false,
+    });
+  });
+  //jest test for registryReducer -success
+  it('should handle GET_REGISTRY_SUCCESS', () => {
+    const action = {
+      type: `${GET_REGISTRY}_SUCCESS`,
+      registry_key: 'registry_key',
+      result: {
+        records: {
+          'registry-1': {
+            id: 'registry-1',
+            name: 'Registry 1',
+            description: 'Registry 1 description',
+            owner: 'registry-owner-1',
+            owner_email: '',
+          },
+          'registry-2': {
+            id: 'registry-2',
+            name: 'Registry 2',
+            description: 'Registry 2 description',
+            owner: 'registry-owner-2',
+            owner_email: '',
+          },
+        },
+      },
+    };
+    expect(registryReducer({}, action)).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+      records: {
+        [action.registry_key]: action.result,
+      },
+    });
+  });
+});

package/src/reducers/subscription/subscription_reducer.test.js

@@ -0,0 +1,71 @@
+import { POST_SUBSCRIBE_TO } from '../../actions';
+import { subscribeToReducer } from './subscription_reducer';
+
+//jest test for subscribeToReducer
+describe('subscribeToReducer', () => {
+  it('should return the initial state', () => {
+    expect(subscribeToReducer(undefined)).toEqual({
+      error: null,
+      loaded: false,
+      loading: false,
+    });
+  });
+  //jest test for subscribeToReducer -success
+  it('should handle POST_SUBSCRIBE_TO_SUCCESS', () => {
+    expect(
+      subscribeToReducer(
+        {},
+        {
+          type: `${POST_SUBSCRIBE_TO}_SUCCESS`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: true,
+      loading: false,
+    });
+  });
+  //jest test for subscribeToReducer -fail
+  it('should handle POST_SUBSCRIBE_TO_FAIL', () => {
+    const action = {
+      type: `${POST_SUBSCRIBE_TO}_FAIL`,
+      error: {
+        response: {
+          body: { error: 'error' },
+        },
+      },
+    };
+    expect(subscribeToReducer({}, action)).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      error_message: action.error?.response?.body?.error || '',
+    });
+  });
+  it('should handle POST_SUBSCRIBE_TO_FAIL without error message', () => {
+    const action = {
+      type: `${POST_SUBSCRIBE_TO}_FAIL`,
+    };
+    expect(subscribeToReducer({}, action)).toEqual({
+      error: true,
+      loaded: false,
+      loading: false,
+      error_message: action.error?.response?.body?.error || '',
+    });
+  });
+  //jest test for subscribeToReducer -pending
+  it('should handle POST_SUBSCRIBE_TO_PENDING', () => {
+    expect(
+      subscribeToReducer(
+        {},
+        {
+          type: `${POST_SUBSCRIBE_TO}_PENDING`,
+        },
+      ),
+    ).toEqual({
+      error: null,
+      loaded: false,
+      loading: true,
+    });
+  });
+});