@legalplace/wizardx-core 4.42.10-nightly.20251125120616 → 4.42.11

package/dist/redux/reducers/inputs.test.js

@@ -0,0 +1,171 @@
+import { initOptionReducer } from './inputs/initOption';
+import { updateOptionInputReducer } from './inputs/updateOptionInput';
+import { inputsReducer } from './inputs';
+import { initVariableReducer } from './inputs/initVariable';
+import { updateVariableInputReducer } from './inputs/updateVariableInput';
+describe('Inputs Options Reducer', () => {
+    it('initOption Reducer', () => {
+        const reducer = initOptionReducer({
+            variables: {},
+            options: {},
+        }, {
+            type: 'INIT_OPTION',
+            id: 123,
+            values: [false],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                123: [false],
+            },
+        });
+    });
+    it('updateOptionInput Reducer', () => {
+        const reducer = updateOptionInputReducer({
+            variables: {},
+            options: {
+                123: [false, false, false],
+            },
+        }, {
+            type: 'UPDATE_OPTION_INPUT',
+            id: 123,
+            value: true,
+            index: 1,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                123: [false, true, false],
+            },
+        });
+    });
+    it('updateOptionInput Reducer (When values did not change)', () => {
+        const initial = {
+            variables: {},
+            options: {
+                123: [false, false, false],
+            },
+        };
+        const reducer = updateOptionInputReducer(initial, {
+            type: 'UPDATE_OPTION_INPUT',
+            id: 123,
+            value: false,
+            index: 1,
+        });
+        return expect(reducer === initial).toBeTruthy();
+    });
+    it('initVariable Reducer', () => {
+        const reducer = initVariableReducer({
+            variables: {},
+            options: {},
+        }, {
+            type: 'INIT_VARIABLE',
+            id: 123,
+            values: [''],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                123: [''],
+            },
+            options: {},
+        });
+    });
+    it('updateVariableInput Reducer', () => {
+        const reducer = updateVariableInputReducer({
+            variables: {
+                123: ['', '', ''],
+            },
+            options: {},
+        }, {
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 123,
+            value: 232,
+            index: 2,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                123: ['', '', 232],
+            },
+            options: {},
+        });
+    });
+    it('updateVariableInput Reducer (Value did not change', () => {
+        const initial = {
+            variables: {
+                123: ['', 'Hello', ''],
+            },
+            options: {},
+        };
+        const reducer = updateVariableInputReducer(initial, {
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 123,
+            value: 'Hello',
+            index: 1,
+        });
+        return expect(reducer === initial).toBeTruthy();
+    });
+    it('inputsReducer INIT_OPTION ACTION', () => {
+        const reducer = inputsReducer(undefined, {
+            type: 'INIT_OPTION',
+            id: 323,
+            values: [true],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                323: [true],
+            },
+        });
+    });
+    it('inputsReducer UPDATE_OPTION_INPUT ACTION', () => {
+        const reducer = inputsReducer({
+            variables: {},
+            options: {
+                123: [false, false, false],
+            },
+        }, {
+            type: 'UPDATE_OPTION_INPUT',
+            id: 123,
+            value: true,
+            index: 1,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {},
+            options: {
+                123: [false, true, false],
+            },
+        });
+    });
+    it('inputsVariablesReducer INIT_VARIABLE ACTION', () => {
+        const reducer = inputsReducer(undefined, {
+            type: 'INIT_VARIABLE',
+            id: 323,
+            values: [''],
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                323: [''],
+            },
+            options: {},
+        });
+    });
+    it('inputsVariablesReducer UPDATE_VARIABLE_INPUT ACTION', () => {
+        const reducer = inputsReducer({
+            variables: {
+                323: ['', '', ''],
+            },
+            options: {},
+        }, {
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 323,
+            value: 'John',
+            index: 0,
+        });
+        return expect(reducer).toStrictEqual({
+            variables: {
+                323: ['John', '', ''],
+            },
+            options: {},
+        });
+    });
+});

package/dist/redux/reducers/references.js

@@ -15,8 +15,6 @@ const initialState = {
         sections: {},
     },
     conditions: {
-        prechecked: { options: {}, variables: {} },
-        prechecked: {},
         options: {},
         variables: {},
         prefillers: {},

package/dist/redux/reducers/user.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/reducers/user.test.js

@@ -0,0 +1,42 @@
+import { initUserReducer } from './user/initUser';
+import { userReducer } from './user';
+describe('User Reducer test suits', () => {
+    it('initUserReducer Reducer', () => {
+        const reducer = initUserReducer({
+            status: 'unauthenticated',
+            level: 'GUEST',
+            displayName: '',
+            email: '',
+            validToken: false,
+        }, {
+            type: 'INIT_USER',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+        return expect(reducer).toStrictEqual({
+            status: 'unauthenticated',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+    });
+    it('user Reducer INIT_USER Action', () => {
+        const reducer = userReducer(undefined, {
+            type: 'INIT_USER',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+        return expect(reducer).toStrictEqual({
+            status: 'unauthenticated',
+            level: 'ADMIN',
+            displayName: 'John Doe',
+            email: 'doe@legalplace.fr',
+            validToken: false,
+        });
+    });
+});

package/dist/redux/routerHistore.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/routerHistore.test.js

@@ -0,0 +1,15 @@
+import { createHistory, getHistory } from './routerHistory';
+describe('Router History', () => {
+    it('Thows an error when history is not initiated', () => {
+        expect(getHistory).toThrowError('History not yet created');
+    });
+    it('Creates and returns history', () => {
+        const history = createHistory('memory');
+        expect(history).toHaveProperty('location');
+    });
+    it('Returns history', () => {
+        createHistory('memory');
+        const history = getHistory();
+        expect(history).toHaveProperty('location');
+    });
+});

package/dist/redux/sagas/fetchModel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/sagas/fetchModel.test.js

@@ -0,0 +1,127 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as fs from 'fs';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initInstanceAction } from '../actions/app';
+import { fetchModelPrerequisitesAction } from '../actions/sagas/model';
+import { ReferencesParser } from '@legalplace/referencesparser';
+const permalink = 'test-model';
+const uniqid = 'myMockUniqid';
+const mockApiEndpoint = 'https://api.mock/api/v1/';
+const model = JSON.parse(fs.readFileSync('./src/misc/test_models/testmodel.json', 'utf8'));
+const meta = {
+    id: 123,
+    title: 'Test model',
+    permalink,
+};
+jest.mock('../../config', () => ({
+    getConfig: () => ({
+        apiEndpoint: 'https://api.mock/api/v1/',
+        router: {
+            wizardPath: '/:permalink/questionnaire/:page([0-9]+|sommaire)',
+            wizardInstancePath: '/:permalink/questionnaire/:uniqid([0-9a-zA-Z]+)/:page([0-9]+|sommaire)',
+        },
+        appStates: ['wizard'],
+        plugins: {},
+        theme: {
+            name: "legacy"
+        }
+    }),
+    updateConfig: () => { }
+}));
+jest.mock('../../Globals.ts', () => ({
+    __esModule: true,
+    default: {
+        loadTheme: () => __awaiter(void 0, void 0, void 0, function* () { return ({ default: {} }); })
+    }
+}));
+describe('Fetch model saga', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch({
+            type: 'SET_DEFAULTS',
+        });
+        store.dispatch(initMetaAction({
+            id: 123,
+            title: 'Test model',
+            prefix: '',
+            permalink,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        store.dispatch(initInstanceAction({
+            uniqid,
+            isPaid: false,
+            dataStatus: 'saved',
+            steps: '*',
+        }));
+        fetchMock.resetMocks();
+    });
+    it('Sends fetch client config request to API', () => {
+        fetchMock.mockResponse((request) => __awaiter(void 0, void 0, void 0, function* () {
+            switch (request.url) {
+                case "https://api.mock/api/v1/client-config?permalink=test-model&disableOnBoarding=true":
+                    return JSON.stringify({
+                        clientConfig: {
+                            domain: "api.mock",
+                            prefix: null,
+                            metadata: {}
+                        }
+                    });
+                case "https://api.mock/api/v1/wizard/contractv1/config/test-model/myMockUniqid":
+                    return JSON.stringify({
+                        modelUuid: "mock-uuid"
+                    });
+                case "https://api.mock/api/v1/wizard/contractv1/model/mock-uuid":
+                    return JSON.stringify({
+                        references: new ReferencesParser(model).getReferences(),
+                        meta: {
+                            id: 1,
+                            title: "Mock Model",
+                            modelVersion: 1,
+                            productType: "contract",
+                            metdata: null
+                        },
+                        customization: {
+                            disableAutoDefault: true,
+                            meta: {
+                                isTwoSteps: false,
+                                disableDownloads: false,
+                                scenario: {},
+                                contractType: {
+                                    socialType: "individual",
+                                    privacy: "public"
+                                }
+                            },
+                            dataStorage: {
+                                extendedDuration: false
+                            }
+                        },
+                        ovc: {
+                            options: {},
+                            variables: {}
+                        },
+                        smartScript: false
+                    });
+                case "https://api.mock/api/v1/wizard/contractv1/test-model/myMockUniqid":
+                    return JSON.stringify({
+                        model,
+                        meta
+                    });
+            }
+            return "{}";
+        }));
+        store.dispatch(fetchModelPrerequisitesAction(permalink));
+        expect(fetchMock.mock.calls.length).toEqual(1);
+        expect(fetchMock.mock.calls[0][0]).toEqual(`${mockApiEndpoint}contract/instance/${uniqid}/refresh-model`);
+    });
+});

package/dist/redux/sagas/runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/sagas/runner.test.js

@@ -0,0 +1,10 @@
+import { sagasRunner } from './runner';
+describe('Runner', () => {
+    it('Runs sagas', () => {
+        const SagaMiddleware = {
+            run: jest.fn(),
+        };
+        sagasRunner(SagaMiddleware);
+        expect(SagaMiddleware.run).toHaveBeenCalled();
+    });
+});

package/dist/redux/sagas/saveData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/sagas/saveData.test.js

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initPaginationAction, initInstanceAction, } from '../actions/app';
+import { initReferencesAction } from '../actions/references';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initOptionAction, initVariableAction, updateOptionAction, } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+import { saveDataAction } from '../actions/sagas/data';
+require('jest-fetch-mock').enableMocks();
+const permalink = 'test-model';
+const uniqid = 'myMockUniqid';
+const mockApiEndpoint = 'https://api.mock/api/v1/';
+jest.mock('../../config', () => ({
+    getConfig: () => ({
+        apiEndpoint: mockApiEndpoint,
+    }),
+}));
+describe('Save data saga', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch({
+            type: 'SET_DEFAULTS',
+        });
+        const model = JSON.parse(fs.readFileSync('./src/misc/test_models/setDefaults.testmodel.json', 'utf8'));
+        const references = new ReferencesParser(model).getReferences();
+        store.dispatch(initReferencesAction(references));
+        const inputs = new IntputsInitiator(references, null).getInputs();
+        Object.keys(inputs.options).forEach((optionId) => {
+            const values = inputs.options[optionId];
+            store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+        });
+        Object.keys(inputs.variables).forEach((variableId) => {
+            const values = inputs.variables[variableId];
+            store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+        });
+        store.dispatch(initMetaAction({
+            id: 123,
+            title: 'Test model',
+            permalink,
+            modelVersion: 1,
+            prefix: '',
+            productType: 'demarche',
+        }));
+        store.dispatch(initInstanceAction({
+            uniqid,
+            isPaid: false,
+            dataStatus: 'unsaved',
+            steps: '*',
+        }));
+        store.dispatch(initPaginationAction({
+            availableAppStates: ['wizard', 'termsheet'],
+            currentAppState: 'wizard',
+            currentPage: 4,
+            greatestPage: 4,
+            currentSectionId: 1,
+            availableSections: [1, 3],
+        }));
+        const conditions = new ConditionsInitiator(references, inputs).getConditions();
+        store.dispatch(initConditionsAction(conditions));
+        store.dispatch({ type: 'SET_DEFAULTS' });
+        store.dispatch(updateOptionAction(15, true, 0));
+        fetchMock.resetMocks();
+    });
+    it('Sends save request to API', () => {
+        fetchMock.mockResponseOnce(JSON.stringify({ status: 'success' }));
+        store.dispatch(saveDataAction());
+        expect(fetchMock.mock.calls.length).toEqual(1);
+        expect(fetchMock.mock.calls[0][0]).toEqual(`${mockApiEndpoint}wizard/instance/${permalink}/${uniqid}`);
+    });
+});

package/dist/redux/sagas/setDefaults.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/sagas/setDefaults.test.js

@@ -0,0 +1,73 @@
+import * as fs from 'fs';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initPaginationAction } from '../actions/app';
+import { initReferencesAction } from '../actions/references';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+describe('Set defaults saga', () => {
+    let store;
+    beforeEach(() => {
+        createAppStore('memory');
+        store = getStore();
+        store.dispatch({
+            type: 'SET_DEFAULTS',
+        });
+        const model = JSON.parse(fs.readFileSync('./src/misc/test_models/setDefaults.testmodel.json', 'utf8'));
+        const references = new ReferencesParser(model).getReferences();
+        store.dispatch(initReferencesAction(references));
+        const inputs = new IntputsInitiator(references, null).getInputs();
+        Object.keys(inputs.options).forEach((optionId) => {
+            const values = inputs.options[optionId];
+            store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+        });
+        Object.keys(inputs.variables).forEach((variableId) => {
+            const values = inputs.variables[variableId];
+            store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+        });
+        store.dispatch(initMetaAction({
+            id: 123,
+            title: 'Test model',
+            permalink: 'test-model',
+            prefix: '',
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        store.dispatch(initPaginationAction({
+            availableAppStates: ['wizard', 'termsheet'],
+            currentAppState: 'wizard',
+            currentPage: 4,
+            greatestPage: 4,
+            currentSectionId: 1,
+            availableSections: [1, 3],
+        }));
+        const conditions = new ConditionsInitiator(references, inputs).getConditions();
+        store.dispatch(initConditionsAction(conditions));
+    });
+    it('Sets defaults properly', () => {
+        store.dispatch({ type: 'SET_DEFAULTS' });
+        expect(store.getState().app.wizard.availableSections).toStrictEqual([
+            1, 2, 3,
+        ]);
+        expect(store.getState().inputs.options).toStrictEqual({
+            1: [true],
+            2: [true],
+            3: [false],
+            4: [true],
+            5: [true],
+            6: [true],
+            7: [true],
+            8: [true],
+            9: [true],
+            10: [true],
+            11: [false],
+            12: [true],
+            13: [false],
+            14: [true],
+            15: [false],
+            16: [false],
+        });
+    });
+});

package/dist/redux/selectors/app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/selectors/app.test.js

@@ -0,0 +1,99 @@
+import { createAppStore, getStore } from '../store';
+import { initPaginationAction, initMetaAction, initInstanceAction, } from '../actions/app';
+import { selectCurrentPage, selectCurrentSectionId, selectAvailableSections, selectPermalink, selectDocumentId, selectDocumentTitle, selectInstanceUniqid, selectInstanceIsPaid, } from './app';
+createAppStore('memory');
+const store = getStore();
+describe('App selectors test suit', () => {
+    it('Returns current page correctly', () => {
+        store.dispatch(initPaginationAction({
+            currentSectionId: 1,
+            currentPage: 13,
+            greatestPage: 1,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        }));
+        const selector = selectCurrentPage();
+        expect(selector).toBe(13);
+    });
+    it('Returns current section id correctly', () => {
+        store.dispatch(initPaginationAction({
+            currentSectionId: 32,
+            currentPage: 13,
+            greatestPage: 13,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        }));
+        const selector = selectCurrentSectionId();
+        expect(selector).toBe(32);
+    });
+    it('Returns available sections correctly', () => {
+        store.dispatch(initPaginationAction({
+            currentSectionId: 32,
+            currentPage: 13,
+            greatestPage: 13,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        }));
+        const selector = selectAvailableSections();
+        expect(selector).toEqual([1, 2, 3]);
+    });
+    it('Returns permalink correctly', () => {
+        store.dispatch(initMetaAction({
+            permalink: 'some-permalink',
+            title: 'Some title',
+            prefix: '',
+            id: 123,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        const selector = selectPermalink();
+        expect(selector).toBe('some-permalink');
+    });
+    it('Returns document id correctly', () => {
+        store.dispatch(initMetaAction({
+            permalink: 'some-permalink',
+            title: 'Some title',
+            prefix: '',
+            id: 123,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        const selector = selectDocumentId();
+        expect(selector).toBe(123);
+    });
+    it('Returns document title correctly', () => {
+        store.dispatch(initMetaAction({
+            permalink: 'some-permalink',
+            title: 'Some title',
+            prefix: '',
+            id: 123,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        const selector = selectDocumentTitle();
+        expect(selector).toBe('Some title');
+    });
+    it('Returns instance uniqid correctly', () => {
+        store.dispatch(initInstanceAction({
+            dataStatus: 'saved',
+            uniqid: 'SomeUNiqID',
+            isPaid: false,
+            steps: '*',
+        }));
+        const selector = selectInstanceUniqid();
+        expect(selector).toBe('SomeUNiqID');
+    });
+    it('Returns instance isPaid correctly', () => {
+        store.dispatch(initInstanceAction({
+            dataStatus: 'saved',
+            uniqid: 'SomeUNiqID',
+            isPaid: true,
+            steps: '*',
+        }));
+        const selector = selectInstanceIsPaid();
+        expect(selector).toBeTruthy();
+    });
+});

package/dist/redux/selectors/conditions.test.d.ts

@@ -0,0 +1 @@
+export {};