@inseefr/lunatic 0.1.7 → 0.1.8-experimental

package/src/tests/utils/{items-positioning.spec.js → lib/items-positioning.spec.js}

@@ -1,4 +1,4 @@
-import { getItemsPositioningClass } from 'utils/items-positioning';
+import { getItemsPositioningClass } from 'utils/lib';
 
 describe('string utils', () => {
 	describe('getItemsPositioningClass', () => {
@@ -8,9 +8,9 @@ describe('string utils', () => {
 			expect(getItemsPositioningClass('DEFAULT')).toEqual('');
 			expect(getItemsPositioningClass('VERTICAL')).toEqual('');
 		});
-		it('should return "horizontal-items"', () => {
+		it('should return "horizontal-options"', () => {
 			expect(getItemsPositioningClass('HORIZONTAL')).toEqual(
-				'horizontal-items'
+				'horizontal-options'
 			);
 		});
 	});

package/src/tests/utils/{label-position.spec.js → lib/label-position.spec.js}

@@ -1,10 +1,10 @@
-import { getLabelPositionClass } from 'utils/label-position';
+import { getLabelPositionClass } from 'utils/lib';
 
 describe('string utils', () => {
 	describe('getLabelPositionClass', () => {
 		it('should return default value', () => {
-			expect(getLabelPositionClass()).toEqual('label-left');
-			expect(getLabelPositionClass('')).toEqual('label-left');
+			expect(getLabelPositionClass()).toEqual('label-top');
+			expect(getLabelPositionClass('')).toEqual('label-top');
 		});
 		it('should return "label-top"', () => {
 			expect(getLabelPositionClass('TOP')).toEqual('label-top');
@@ -15,5 +15,8 @@ describe('string utils', () => {
 		it('should return "label-right"', () => {
 			expect(getLabelPositionClass('RIGHT')).toEqual('label-right');
 		});
+		it('should return "label-left"', () => {
+			expect(getLabelPositionClass('LEFT')).toEqual('label-left');
+		});
 	});
 });

package/src/tests/utils/lib/loops/bindings.spec.js

@@ -0,0 +1,75 @@
+import * as U from 'utils/lib';
+
+const bindings = { A: 'AAA', B: ['b', 'bb'] };
+
+describe('loop bindings utils', () => {
+	describe('buildBindingsForDeeperComponents', () => {
+		it('should return default value', () => {
+			expect(U.buildBindingsForDeeperComponents()()).toEqual({});
+			expect(U.buildBindingsForDeeperComponents(0)()).toEqual({});
+			expect(U.buildBindingsForDeeperComponents()({})).toEqual({});
+		});
+		it('should return bindings for loop', () => {
+			expect(U.buildBindingsForDeeperComponents(1)(bindings)).toEqual({
+				A: 'AAA',
+				B: 'bb',
+			});
+		});
+	});
+	describe('buildLoopBindings', () => {
+		it('should return default value', () => {
+			expect(U.buildLoopBindings(0)()).toEqual({});
+			expect(U.buildLoopBindings(0)({})).toEqual({});
+		});
+		it('should return bindings for loop', () => {
+			expect(
+				U.buildLoopBindings(1)([
+					['a', 'A'],
+					['b', ['B0', 'B1']],
+				])
+			).toEqual({
+				a: 'A',
+				b: 'B1',
+			});
+		});
+	});
+	describe('buildVectorialBindings', () => {
+		it('should return default value', () => {
+			expect(U.buildVectorialBindings()).toEqual({});
+			expect(U.buildVectorialBindings({})).toEqual({});
+		});
+		it('should return vectorial bindings', () => {
+			expect(U.buildVectorialBindings(bindings)).toEqual({
+				A: 'AAA',
+				B: { dataStructure: { B: {} }, dataPoints: { B: ['b', 'bb'] } },
+			});
+		});
+	});
+	describe('displayLoop', () => {
+		it('should return default value', () => {
+			expect(U.displayLoop()()).toBeFalsy();
+			expect(U.displayLoop([])({})).toBeFalsy();
+		});
+		it('should return display loop', () => {
+			expect(U.displayLoop(['A'])({ A: [null] })).toBeFalsy();
+		});
+		it('should return display loop', () => {
+			expect(U.displayLoop(['A'])({ A: ['a'] })).toBeTruthy();
+		});
+	});
+	describe('displayLoopQuestion', () => {
+		it('should return default value', () => {
+			expect(U.displayLoopQuestion()()).toBeFalsy();
+			expect(U.displayLoopQuestion([])({})).toBeFalsy();
+		});
+		it('should return display loop', () => {
+			expect(
+				U.displayLoopQuestion(['A', 'B'])({ A: [[null]], B: null })
+			).toBeFalsy();
+		});
+		it('should return display loop', () => {
+			expect(U.displayLoopQuestion(['A'])({ A: [[null]] })).toBeTruthy();
+			expect(U.displayLoopQuestion(['A'])({ A: 'a' })).toBeTruthy();
+		});
+	});
+});

package/src/tests/utils/lib/loops/shared.spec.js

@@ -0,0 +1,82 @@
+import * as U from 'utils/lib';
+
+const componentsForInit = [
+	{
+		id: '1',
+		response: { name: 'a', values: { COLLECTED: [null, 'a'] } },
+		missingResponse: { name: 'z', depth: 0 },
+		depth: 0,
+	},
+	{
+		id: '2',
+		response: { name: 'b', values: { COLLECTED: [null, 'b'] } },
+		depth: 0,
+	},
+	{
+		id: '3',
+		responses: [
+			{
+				id: '3.1',
+				depth: 1,
+				response: { name: 'c', values: { COLLECTED: [null, null] } },
+				missingResponse: { name: 'zz', depth: 1 },
+			},
+		],
+	},
+];
+
+describe('loop roster utils', () => {
+	describe('getLoopConstructorInitLines', () => {
+		it('should return default value', () => {
+			expect(U.getLoopConstructorInitLines()).toEqual(0);
+			expect(U.getLoopConstructorInitLines([])).toEqual(0);
+		});
+		it('should return roster init line length', () => {
+			expect(U.getLoopConstructorInitLines(componentsForInit)).toEqual(2);
+		});
+	});
+	describe('getInvolvedVariables', () => {
+		it('should return default value', () => {
+			expect(U.getInvolvedVariables()).toEqual([]);
+			expect(U.getInvolvedVariables([])).toEqual([]);
+		});
+		it('should return variables involved into roster for loop', () => {
+			expect(U.getInvolvedVariables(componentsForInit)).toEqual([
+				{ name: 'a', depth: 0 },
+				{ name: 'z', depth: 0 },
+				{ name: 'b', depth: 0 },
+				{ name: 'c', depth: 1 },
+				{ name: 'zz', depth: 1 },
+			]);
+		});
+	});
+	describe('lastLoopChildLineIsEmpty', () => {
+		it('should return default value', () => {
+			expect(U.lastLoopChildLineIsEmpty()()).toBeTruthy();
+			expect(U.lastLoopChildLineIsEmpty({})([])).toBeTruthy();
+		});
+		it('should return last line is not empty', () => {
+			const d = { A: [null, 'a'], B: ['b', null] };
+			const iv = [{ name: 'A' }, { name: 'B' }];
+			expect(U.lastLoopChildLineIsEmpty(d)(iv)).toBeFalsy();
+		});
+		it('should return last line is empty', () => {
+			const d = { A: [null, null], B: ['b', null] };
+			const iv = [{ name: 'A' }, { name: 'B' }];
+			expect(U.lastLoopChildLineIsEmpty(d)(iv)).toBeTruthy();
+		});
+	});
+
+	describe('buildEmptyValue', () => {
+		it('should return default value', () => {
+			expect(U.buildEmptyValue()).toBeNull();
+			expect(U.buildEmptyValue(0)).toBeNull();
+			expect(U.buildEmptyValue(1)).toBeNull();
+			expect(U.buildEmptyValue(2)).toBeNull();
+		});
+		it('should return null array thanks to depth', () => {
+			expect(U.buildEmptyValue(3)).toEqual([null]);
+			expect(U.buildEmptyValue(4)).toEqual([[null]]);
+		});
+	});
+});

package/src/tests/utils/lib/missing/missing.spec.js

@@ -0,0 +1,74 @@
+import * as U from 'utils/lib';
+import * as M from './mock';
+
+describe('buildLoopMissingResponse', () => {
+	it('should return default value', () => {
+		expect(U.buildLoopMissingResponse()({})).toBeUndefined();
+		expect(U.buildLoopMissingResponse(0)()).toBeUndefined();
+	});
+	it('should return new missingResponse', () => {
+		expect(
+			U.buildLoopMissingResponse([1])({
+				name: 'var',
+				values: { COLLECTED: [null, 1], EDITED: [null, 2] },
+			})
+		).toEqual({
+			name: 'var',
+			values: { COLLECTED: 1, EDITED: 2 },
+		});
+		expect(
+			U.buildLoopMissingResponse([0])({
+				name: 'var',
+				values: { COLLECTED: [null, 1], EDITED: [null, 2] },
+			})
+		).toEqual({
+			name: 'var',
+			values: { COLLECTED: null, EDITED: null },
+		});
+	});
+	it('should return getToClean for response', () => {
+		expect(U.getToClean('COLLECTED')(M.qRespTrue)).toEqual({
+			response: null,
+		});
+		expect(U.getToClean('COLLECTED')(M.qRespFalse)).toEqual({});
+	});
+	it('should return getToClean for responses', () => {
+		expect(U.getToClean('COLLECTED')(M.qRespsTrue)).toEqual({
+			response1: null,
+			response2: null,
+		});
+		expect(U.getToClean('COLLECTED')(M.qRespsFalse)).toEqual({});
+	});
+	it('should return getToClean for cells', () => {
+		expect(U.getToClean('COLLECTED')(M.qCellsTrue)).toEqual({
+			response2: null,
+		});
+		expect(U.getToClean('COLLECTED')(M.qCellsFalse)).toEqual({});
+	});
+	it('should return getToClean for components', () => {
+		expect(U.getToClean('COLLECTED')(M.qComponentsTrue)).toEqual({
+			response2: [
+				[null, null],
+				[null, null],
+			],
+			response3: null,
+		});
+		expect(U.getToClean('COLLECTED')(M.qComponentsFalse)).toEqual({});
+	});
+	it('should return hasToCleanMissing for response', () => {
+		expect(U.hasToCleanMissing('COLLECTED')(M.qRespTrue)).toBeTruthy();
+		expect(U.hasToCleanMissing('COLLECTED')(M.qRespFalse)).toBeFalsy();
+	});
+	it('should return hasToCleanMissing for responses', () => {
+		expect(U.hasToCleanMissing('COLLECTED')(M.qRespsTrue)).toBeTruthy();
+		expect(U.hasToCleanMissing('COLLECTED')(M.qRespsFalse)).toBeFalsy();
+	});
+	it('should return hasToCleanMissing for cells', () => {
+		expect(U.hasToCleanMissing('COLLECTED')(M.qCellsTrue)).toBeTruthy();
+		expect(U.hasToCleanMissing('COLLECTED')(M.qCellsFalse)).toBeFalsy();
+	});
+	it('should return hasToCleanMissing for components', () => {
+		expect(U.hasToCleanMissing('COLLECTED')(M.qComponentsTrue)).toBeTruthy();
+		expect(U.hasToCleanMissing('COLLECTED')(M.qComponentsFalse)).toBeFalsy();
+	});
+});

package/src/tests/utils/lib/missing/mock.js

@@ -0,0 +1,137 @@
+export const qRespTrue = {
+	response: { name: 'response', values: { COLLECTED: 'toto' } },
+	missingResponse: {
+		name: 'missingResponse',
+		values: { COLLECTED: 'toto' },
+	},
+};
+
+export const qRespFalse = {
+	response: { name: 'response', values: { COLLECTED: null } },
+	missingResponse: {
+		name: 'missingResponse',
+		values: { COLLECTED: 'toto' },
+	},
+};
+
+export const qRespsTrue = {
+	responses: [
+		{
+			response: { name: 'response1', values: { COLLECTED: 'ok' } },
+		},
+		{
+			response: { name: 'response2', values: { COLLECTED: 'ok' } },
+		},
+	],
+	missingResponse: {
+		name: 'missingResponse',
+		values: { COLLECTED: 'toto' },
+	},
+};
+
+export const qRespsFalse = {
+	responses: [
+		{
+			response: { name: 'response1', values: { COLLECTED: null } },
+		},
+		{
+			response: { name: 'response2', values: { COLLECTED: null } },
+		},
+	],
+	missingResponse: {
+		name: 'missingResponse',
+		values: { COLLECTED: 'toto' },
+	},
+};
+
+export const qCellsTrue = {
+	cells: [
+		[
+			{ label: 'line1' },
+			{
+				response: { name: 'response1', values: { COLLECTED: null } },
+			},
+		],
+		[
+			{ label: 'line2' },
+			{
+				response: { name: 'response2', values: { COLLECTED: 'ok' } },
+			},
+		],
+	],
+};
+
+export const qCellsFalse = {
+	cells: [
+		[
+			{ label: 'line1' },
+			{
+				response: { name: 'response1', values: { COLLECTED: null } },
+			},
+		],
+		[
+			{ label: 'line2' },
+			{
+				response: { name: 'response2', values: { COLLECTED: null } },
+			},
+		],
+	],
+};
+
+export const qComponentsTrue = {
+	components: [
+		{
+			response: { name: 'response1', values: { COLLECTED: null } },
+		},
+		{
+			responses: [
+				{
+					response: {
+						name: 'response2',
+						values: {
+							COLLECTED: [
+								['ok', 'ok'],
+								['ok', 'ok'],
+							],
+						},
+					},
+				},
+			],
+		},
+		{
+			cells: [
+				[
+					{ label: 'line1' },
+					{
+						response: { name: 'response3', values: { COLLECTED: 'ok' } },
+					},
+				],
+			],
+		},
+	],
+};
+
+export const qComponentsFalse = {
+	components: [
+		{
+			response: { name: 'response1', values: { COLLECTED: null } },
+		},
+		{
+			responses: [
+				{
+					response: { name: 'response2', values: { COLLECTED: null } },
+				},
+			],
+		},
+		{
+			cells: [
+				[
+					{ label: 'line1' },
+					{
+						response: { name: 'response3', values: { COLLECTED: null } },
+					},
+				],
+			],
+		},
+	],
+};

package/src/tests/utils/lib/pagination/shared.spec.js

@@ -0,0 +1,42 @@
+import { splitPage } from 'utils/lib';
+
+describe('string utils', () => {
+	describe('splitPage', () => {
+		it('should return splitted pages without depth', () => {
+			const {
+				currentRootPage,
+				currentComponentIndex,
+				currentIteration,
+				currentPageWithoutAnyIteration,
+			} = splitPage('1.2#3.10#1');
+			expect(currentRootPage).toEqual('1.2#3');
+			expect(currentComponentIndex).toEqual(10);
+			expect(currentIteration).toEqual(1);
+			expect(currentPageWithoutAnyIteration).toEqual('1.2.10');
+		});
+		it('should return splitted pages with depth 1', () => {
+			const {
+				currentRootPage,
+				currentComponentIndex,
+				currentIteration,
+				currentPageWithoutAnyIteration,
+			} = splitPage('1.2#3.10#1', 1);
+			expect(currentRootPage).toEqual('1');
+			expect(currentComponentIndex).toEqual(2);
+			expect(currentIteration).toEqual(3);
+			expect(currentPageWithoutAnyIteration).toEqual('1.2');
+		});
+		it('should return splitted pages with depth 2', () => {
+			const {
+				currentRootPage,
+				currentComponentIndex,
+				currentIteration,
+				currentPageWithoutAnyIteration,
+			} = splitPage('1.2#3.10#1', 2);
+			expect(currentRootPage).toEqual('1.2#3');
+			expect(currentComponentIndex).toEqual(10);
+			expect(currentIteration).toEqual(1);
+			expect(currentPageWithoutAnyIteration).toEqual('1.2.10');
+		});
+	});
+});

package/src/tests/utils/lib/responses.spec.js

@@ -0,0 +1,64 @@
+import * as R from 'utils/lib/responses';
+
+describe('responses utils', () => {
+	describe('getResponseName', () => {
+		it('should return default value', () => {
+			expect(R.getResponseName({})).toEqual('');
+		});
+	});
+	describe('getResponseByPreference', () => {
+		it('should return default value', () => {
+			expect(R.getResponseByPreference([])({})).toEqual(null);
+			expect(
+				R.getResponseByPreference([])({
+					name: 'name',
+					values: { COLLECTED: 'Collected' },
+				})
+			).toEqual(null);
+		});
+		it('should return Collected', () => {
+			expect(
+				R.getResponseByPreference(['COLLECTED'])({
+					name: 'name',
+					values: { COLLECTED: 'Collected' },
+				})
+			).toEqual('Collected');
+		});
+		it('should return Collected', () => {
+			expect(
+				R.getResponseByPreference(['COLLECTED'])({
+					name: 'name',
+					values: { COLLECTED: 'Collected', FORCED: 'Forced' },
+				})
+			).toEqual('Collected');
+		});
+		it('should return Collected', () => {
+			expect(
+				R.getResponseByPreference(['COLLECTED', 'FORCED'])({
+					name: 'name',
+					values: {
+						COLLECTED: 'Collected',
+						FORCED: null,
+					},
+				})
+			).toEqual('Collected');
+		});
+		it('should return Forced', () => {
+			expect(
+				R.getResponseByPreference(['COLLECTED', 'FORCED'])({
+					name: 'name',
+					values: { COLLECTED: 'Collected', FORCED: 'Forced' },
+				})
+			).toEqual('Forced');
+		});
+
+		it('should return ""', () => {
+			expect(
+				R.getResponseByPreference(['COLLECTED', 'FORCED', 'EDITED'])({
+					name: 'name',
+					values: { COLLECTED: 'Collected', FORCED: '', EDITED: null },
+				})
+			).toEqual('');
+		});
+	});
+});

package/src/tests/utils/{string-utils.spec.js → lib/style.spec.js}

@@ -1,19 +1,19 @@
-import * as A from 'utils/string-utils';
+import { buildStyleObject } from 'utils/lib';
 
-describe('string utils', () => {
+describe('style', () => {
 	describe('buildStyleObject', () => {
 		it('should return an empty object', () => {
-			expect(A.buildStyleObject()).toEqual({});
-			expect(A.buildStyleObject({})).toEqual({});
+			expect(buildStyleObject()).toEqual({});
+			expect(buildStyleObject({})).toEqual({});
 		});
 		it('should return same object', () => {
-			expect(A.buildStyleObject({ border: 'border' })).toEqual({
+			expect(buildStyleObject({ border: 'border' })).toEqual({
 				border: 'border',
 			});
 		});
 		it('should return object with camelCase keys', () => {
 			expect(
-				A.buildStyleObject({
+				buildStyleObject({
 					'border-top': '10',
 					':hover': { 'background-color': 'pink' },
 				})

package/src/tests/utils/lib/table/roster.spec.js

@@ -0,0 +1,25 @@
+import { getRosterInitLines } from 'utils/lib';
+
+const emptyCells = [[{ response: { values: { '': null } } }]];
+const cells = [
+	[
+		{ response: { values: { '': 'ok' } } },
+		{ response: { values: { '': 'ok2' } } },
+	],
+	[{ response: { values: { '': 'ok' } } }],
+	[],
+	[{ response: { values: { '': null } } }],
+	[{ response: { values: { '1': 'ok', '2': 'ok2' } } }],
+];
+
+describe('roster utils', () => {
+	describe('getRosterInitLines', () => {
+		it('should return 0', () => {
+			expect(getRosterInitLines()).toEqual(0);
+			expect(getRosterInitLines(emptyCells)).toEqual(0);
+		});
+		it('should return 2', () => {
+			expect(getRosterInitLines(cells)).toEqual(3);
+		});
+	});
+});

package/src/tests/utils/lib/tooltip/build-response.spec.js

@@ -0,0 +1,95 @@
+import {
+	buildMultiTooltipResponse,
+	buildBooleanTooltipResponse,
+} from 'utils/lib';
+
+const options = [
+	{ value: '1', label: 'Yes' },
+	{ value: '0', label: 'No' },
+];
+
+const responseNull = {
+	name: 'Response',
+	values: {
+		PREVIOUS: null,
+		COLLECTED: null,
+		FORCED: null,
+		EDITED: null,
+		INPUTED: null,
+	},
+};
+
+const response = {
+	name: 'Response',
+	values: {
+		PREVIOUS: null,
+		COLLECTED: '1',
+		FORCED: '0',
+		EDITED: '1',
+		INPUTED: null,
+	},
+};
+
+const finalResponse = {
+	name: 'Response',
+	values: {
+		PREVIOUS: null,
+		COLLECTED: 'Yes',
+		FORCED: 'No',
+		EDITED: 'Yes',
+		INPUTED: null,
+	},
+};
+
+const booleanResponse = {
+	name: 'Response',
+	values: {
+		PREVIOUS: null,
+		COLLECTED: true,
+		FORCED: false,
+		EDITED: true,
+		INPUTED: null,
+	},
+};
+
+const booleanFinalResponse = {
+	name: 'Response',
+	values: {
+		PREVIOUS: null,
+		COLLECTED: 'Vrai',
+		FORCED: 'Faux',
+		EDITED: 'Vrai',
+		INPUTED: null,
+	},
+};
+
+describe('build response', () => {
+	describe('buildMultiTooltipResponse', () => {
+		it('should return default value', () => {
+			expect(buildMultiTooltipResponse()()).toEqual({});
+		});
+		it('should return same response', () => {
+			expect(buildMultiTooltipResponse(options)(responseNull)).toEqual(
+				responseNull
+			);
+		});
+		it('should return updated response', () => {
+			expect(buildMultiTooltipResponse(options)(response)).toEqual(
+				finalResponse
+			);
+		});
+	});
+	describe('buildBooleanTooltipResponse', () => {
+		it('should return default value', () => {
+			expect(buildBooleanTooltipResponse()).toEqual({});
+		});
+		it('should return same response', () => {
+			expect(buildBooleanTooltipResponse(responseNull)).toEqual(responseNull);
+		});
+		it('should return updated response', () => {
+			expect(buildBooleanTooltipResponse(booleanResponse)).toEqual(
+				booleanFinalResponse
+			);
+		});
+	});
+});