@legalplace/tagextractor 2.1.0 → 2.3.0

package/.eslintignore

@@ -0,0 +1,2 @@
+*.test.ts
+*.test.tsx

package/.eslintrc

@@ -1,59 +1,3 @@
 {
-  "env": {
-    "browser": true,
-    "commonjs": true,
-    "es6": true,
-    "jest": true,
-    "node": true
-  },
-
-  "extends": [
-    "airbnb-base",
-    "plugin:prettier/recommended"
-  ],
-
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "project": "./tsconfig.eslint.json"
-  },
-
-  "plugins": [
-   "prettier", "@typescript-eslint"
-  ],
-
-  "rules": {
-    "prettier/prettier": ["error"],
-    "no-unused-vars": "off",
-    "@typescript-eslint/no-unused-vars": ["error", {
-      "vars": "all",
-      "args": "after-used",
-      "ignoreRestSiblings": false
-    }],
-    "import/no-extraneous-dependencies": ["error", {
-      "devDependencies": true
-    }],
-    "no-continue": 0,
-    "class-methods-use-this": 0,
-    "no-underscore-dangle": 0,
-    "import/prefer-default-export": "warn",
-    "camelcase": "error",
-    "no-undef": 0,
-    "no-dupe-class-members": "off",
-    "import/extensions": ["error", "ignorePackages", {
-      "js": "never",
-      "jsx": "never",
-      "ts": "never",
-      "tsx": "never",
-      "mjs": "never"
-    }]
-  },
-
-
-  "settings": {
-    "import/resolver": {
-      "node": {
-        "extensions": [".js", ".jsx", ".ts", ".tsx"]
-      }
-    }
-  }
-}
+  "extends": ["@legalplace/eslint-config"]
+}

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# 2.3.0 (2022-01-10)
+
+
+### Bug Fixes
+
+* fix test version api[#4631](https://git.legalplace.eu/legalplace/tagextractor/issues/4631) ([f5f15c2](https://git.legalplace.eu/legalplace/tagextractor/commits/f5f15c2e5fdd9b0d98edb822f1aeb02d3823a6ca))
+* remove unneeded gitlab-ci file api[#4631](https://git.legalplace.eu/legalplace/tagextractor/issues/4631) ([97b8424](https://git.legalplace.eu/legalplace/tagextractor/commits/97b8424281d804720438061bec2a7c0171f79b3b))
+
+
+### Features
+
+* add the tagExtractor package api[#4631](https://git.legalplace.eu/legalplace/tagextractor/issues/4631) ([70c502a](https://git.legalplace.eu/legalplace/tagextractor/commits/70c502a734ea8bf1df842d4d44c89f360d96d7db))

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import TagExtractor from './libs/Extractor';
-import TagsType, { OptionTagType, VariableTagType } from './types/tags.type';
-export { TagsType, OptionTagType, VariableTagType };
+import TagExtractor from "./libs/Extractor";
+import TagsType, { OptionTagType, VariableTagType } from "./types/tags.type";
+export type { TagsType, OptionTagType, VariableTagType };
 export default TagExtractor;

package/dist/index.js

@@ -3,5 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Extractor_1 = __importDefault(require("./libs/Extractor"));
+const Extractor_1 = __importDefault(require("./libs/Extractor"));
 exports.default = Extractor_1.default;

package/dist/libs/Extractor.d.ts

@@ -1,8 +1,8 @@
-import { ModelV3 } from '@legalplace/models-v3-types';
-import { ReferencesType } from '@legalplace/referencesparser/dist/libs/References.type';
-import InputsType from '@legalplace/types/dist/inputs';
-import OvcType from '@legalplace/types/dist/ovc';
-import TagsType from '../types/tags.type';
+import { ModelV3 } from "@legalplace/models-v3-types";
+import { ReferencesType } from "@legalplace/referencesparser/dist/libs/References.type";
+import type InputsType from "@legalplace/types/dist/inputs";
+import type OvcType from "@legalplace/types/dist/ovc";
+import TagsType from "../types/tags.type";
 declare class TagExtractor {
     private references;
     private inputs;

package/dist/libs/Extractor.js

@@ -1,130 +1,129 @@
 "use strict";
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var referencesparser_1 = require("@legalplace/referencesparser");
-var conditions_runner_1 = __importDefault(require("@legalplace/conditions-runner"));
-var ovc_converter_1 = __importDefault(require("@legalplace/ovc-converter"));
-var TagExtractor = (function () {
-    function TagExtractor(modelOrReferences, ovc) {
+const referencesparser_1 = require("@legalplace/referencesparser");
+const conditions_runner_1 = __importDefault(require("@legalplace/conditions-runner"));
+const ovc_converter_1 = __importDefault(require("@legalplace/ovc-converter"));
+class TagExtractor {
+    constructor(modelOrReferences, ovc) {
         this.tags = {
             options: {},
-            variables: {}
-        };
-        this.isReferencesType = function (_obj) {
-            return Object.keys(_obj).some(function (key) { return key === 'boxes'; });
+            variables: {},
         };
-        this.references = this.isReferencesType(modelOrReferences) ? modelOrReferences : new referencesparser_1.ReferencesParser(modelOrReferences).references;
-        this.inputs = ovc_converter_1.default.isOptionsVariables(ovc) ? ovc : ovc_converter_1.default.convertToOptionsVariables(ovc, this.references);
+        this.isReferencesType = (_obj) => Object.keys(_obj).some((key) => key === "boxes");
+        this.references = this.isReferencesType(modelOrReferences)
+            ? modelOrReferences
+            : new referencesparser_1.ReferencesParser(modelOrReferences).references;
+        this.inputs = ovc_converter_1.default.isOptionsVariables(ovc)
+            ? ovc
+            : ovc_converter_1.default.convertToOptionsVariables(ovc, this.references);
         this.conditionsRunner = new conditions_runner_1.default(this.references, this.inputs);
         this.extractFromOptions();
         this.extractFromVariables();
     }
-    Object.defineProperty(TagExtractor.prototype, "getTags", {
-        get: function () {
-            return this.tags;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TagExtractor.prototype.extractFromOptions = function () {
-        var _this = this;
-        Object.keys(this.references.options).forEach(function (id) {
-            var _a = _this.references.options[id].meta, tags = _a.tags, label = _a.label;
-            if (Array.isArray(tags) && tags.length > 0 && _this.inputs.options[id]) {
-                _this.inputs.options[id].forEach(function (v, index) {
-                    tags.forEach(function (tag) {
-                        if (_this.tags.options[tag] === undefined)
-                            _this.tags.options[tag] = [];
-                        _this.tags.options[tag].push({
+    get getTags() {
+        return this.tags;
+    }
+    extractFromOptions() {
+        Object.keys(this.references.options).forEach((id) => {
+            const { tags, label } = this.references.options[id].meta;
+            if (Array.isArray(tags) && tags.length > 0 && this.inputs.options[id]) {
+                this.inputs.options[id].forEach((v, index) => {
+                    tags.forEach((tag) => {
+                        if (this.tags.options[tag] === undefined)
+                            this.tags.options[tag] = [];
+                        this.tags.options[tag].push({
                             id: parseInt(id, 10),
-                            index: index,
-                            label: label,
-                            condition: _this.getOptionCondition(parseInt(id, 10), index),
-                            visible: _this.isOptionDisplayed(parseInt(id, 10), index),
-                            value: _this.inputs.options[id][index]
+                            index,
+                            label,
+                            condition: this.getOptionCondition(parseInt(id, 10), index),
+                            visible: this.isOptionDisplayed(parseInt(id, 10), index),
+                            value: this.inputs.options[id][index],
                         });
                     });
                 });
             }
         });
-    };
-    TagExtractor.prototype.extractFromVariables = function () {
-        var _this = this;
-        Object.keys(this.references.variables).forEach(function (id) {
-            var _a = _this.references.variables[id], tags = _a.tags, label = _a.label;
-            if (Array.isArray(tags) && tags.length > 0 && _this.inputs.variables[id]) {
-                _this.inputs.variables[id].forEach(function (v, index) {
-                    tags.forEach(function (tag) {
-                        if (_this.tags.variables[tag] === undefined)
-                            _this.tags.variables[tag] = [];
-                        _this.tags.variables[tag].push({
+    }
+    extractFromVariables() {
+        Object.keys(this.references.variables).forEach((id) => {
+            const { tags, label } = this.references.variables[id];
+            if (Array.isArray(tags) && tags.length > 0 && this.inputs.variables[id]) {
+                this.inputs.variables[id].forEach((v, index) => {
+                    tags.forEach((tag) => {
+                        if (this.tags.variables[tag] === undefined)
+                            this.tags.variables[tag] = [];
+                        this.tags.variables[tag].push({
                             id: parseInt(id, 10),
-                            index: index,
-                            label: label,
-                            condition: _this.getVariableCondition(parseInt(id, 10), index) !== false,
-                            visible: _this.isVariableDisplayed(parseInt(id, 10), index),
-                            value: _this.inputs.variables[id][index]
+                            index,
+                            label,
+                            condition: this.getVariableCondition(parseInt(id, 10), index) !== false,
+                            visible: this.isVariableDisplayed(parseInt(id, 10), index),
+                            value: this.inputs.variables[id][index],
                         });
                     });
                 });
             }
         });
-    };
-    TagExtractor.prototype.isVariableDisplayed = function (id, index) {
+    }
+    isVariableDisplayed(id, index) {
         var _a, _b;
-        var variableCondition = this.getVariableCondition(id, index);
-        var variableParents = ((_a = this.references.relations.variables[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
-        var parentOptionIsDisplayed = this.isOptionDisplayed(variableParents[0], index);
-        var parentOptionIsTruethful = ((_b = this.inputs.options[variableParents[0]]) === null || _b === void 0 ? void 0 : _b[index]) === true;
-        return [variableCondition, parentOptionIsDisplayed, parentOptionIsTruethful].filter(function (c) { return c !== true; }).length === 0;
-    };
-    TagExtractor.prototype.isOptionDisplayed = function (id, index) {
-        var _this = this;
+        const variableCondition = this.getVariableCondition(id, index);
+        const variableParents = ((_a = this.references.relations.variables[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
+        const parentOptionIsDisplayed = this.isOptionDisplayed(variableParents[0], index);
+        const parentOptionIsTruethful = ((_b = this.inputs.options[variableParents[0]]) === null || _b === void 0 ? void 0 : _b[index]) === true;
+        return ([
+            variableCondition,
+            parentOptionIsDisplayed,
+            parentOptionIsTruethful,
+        ].filter((c) => c !== true).length === 0);
+    }
+    isOptionDisplayed(id, index) {
         var _a;
-        var optionCondition = this.getOptionCondition(id, index);
-        var optionParents = ((_a = this.references.relations.options[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
-        var parentsConditions = optionParents.map(function (optionId) {
-            return _this.getOptionCondition(optionId, index) !== false;
-        });
-        var parentsInputs = optionParents.map(function (optionId) {
-            var _a;
-            return ((_a = _this.inputs.options[optionId]) === null || _a === void 0 ? void 0 : _a[index]) || false;
-        });
-        var parentSectionId = this.getOptionParentSection(id);
-        var parentSectionCondition = this.getSectionCondition(parentSectionId) !== false;
-        return __spreadArrays([optionCondition, parentSectionCondition], parentsConditions, parentsInputs).filter(function (c) { return c !== true; }).length === 0;
-    };
-    TagExtractor.prototype.getVariableCondition = function (id, index) {
-        var conditionObject = this.references.conditions.variables[id];
-        return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, index, 'variables');
-    };
-    TagExtractor.prototype.getOptionCondition = function (id, index) {
-        var conditionObject = this.references.conditions.options[id];
-        return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, index, 'options');
-    };
-    TagExtractor.prototype.getSectionCondition = function (id) {
-        var conditionObject = this.references.conditions.sections.main[id];
-        return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, 0, 'sections');
-    };
-    TagExtractor.prototype.getOptionParentSection = function (id) {
-        var parents = this.references.relations.options[id].parents;
-        var rootId = parents.length > 0 ? parents[parents.length - 1] : id;
-        var sections = Object.values(this.references.sections.main);
-        for (var i = 0; i < sections.length; i += 1) {
+        const optionCondition = this.getOptionCondition(id, index);
+        const optionParents = ((_a = this.references.relations.options[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
+        const parentsConditions = optionParents.map((optionId) => this.getOptionCondition(optionId, index) !== false);
+        const parentsInputs = optionParents.map((optionId) => this.inputs.options[optionId]
+            ? this.inputs.options[optionId][index]
+            : false);
+        const parentSectionId = this.getOptionParentSection(id);
+        const parentSectionCondition = this.getSectionCondition(parentSectionId) !== false;
+        return ([
+            optionCondition,
+            parentSectionCondition,
+            ...parentsConditions,
+            ...parentsInputs,
+        ].filter((c) => c !== true).length === 0);
+    }
+    getVariableCondition(id, index) {
+        const conditionObject = this.references.conditions.variables[id];
+        return conditionObject === undefined
+            ? true
+            : this.conditionsRunner.executeCondition(conditionObject, id, index, "variables");
+    }
+    getOptionCondition(id, index) {
+        const conditionObject = this.references.conditions.options[id];
+        return conditionObject === undefined
+            ? true
+            : this.conditionsRunner.executeCondition(conditionObject, id, index, "options");
+    }
+    getSectionCondition(id) {
+        const conditionObject = this.references.conditions.sections.main[id];
+        return conditionObject === undefined
+            ? true
+            : this.conditionsRunner.executeCondition(conditionObject, id, 0, "sections");
+    }
+    getOptionParentSection(id) {
+        const { parents } = this.references.relations.options[id];
+        const rootId = parents.length > 0 ? parents[parents.length - 1] : id;
+        const sections = Object.values(this.references.sections.main);
+        for (let i = 0; i < sections.length; i += 1) {
             if (sections[i].options.includes(rootId))
                 return sections[i].id;
         }
-        throw new Error("Cannot find parent section for option " + id + " (Root option id: " + rootId + ")");
-    };
-    return TagExtractor;
-}());
+        throw new Error(`Cannot find parent section for option ${id} (Root option id: ${rootId})`);
+    }
+}
 exports.default = TagExtractor;

package/dist/libs/Extractor.test.d.ts

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

package/dist/libs/Extractor.test.js

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Extractor_1 = __importDefault(require("./Extractor"));
+const ovc_json_1 = __importDefault(require("./fixtures/ovc.json"));
+const inputs_json_1 = __importDefault(require("./fixtures/inputs.json"));
+const references_json_1 = __importDefault(require("./fixtures/references.json"));
+const model_json_1 = __importDefault(require("./fixtures/model.json"));
+const simpleReferences = references_json_1.default;
+const simpleModel = model_json_1.default;
+const simpleOvc = ovc_json_1.default;
+const simpleInputs = inputs_json_1.default;
+describe("TagsExtractor", () => {
+    const tagExtractor = new Extractor_1.default(simpleReferences, simpleInputs);
+    afterEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    describe("IsVariableDisplayed", () => {
+        it("should return false when variable condition is false", () => {
+            const getVariableCondition = jest.spyOn(Extractor_1.default.prototype, "getVariableCondition");
+            getVariableCondition.mockImplementation(() => false);
+            expect(tagExtractor.isVariableDisplayed(1, 0)).toBeFalsy();
+            expect(getVariableCondition).toHaveBeenCalledWith(1, 0);
+        });
+        it("should return false when parent Option is not displayed", () => {
+            const isOptionDisplayed = jest.spyOn(Extractor_1.default.prototype, "isOptionDisplayed");
+            isOptionDisplayed.mockImplementation(() => false);
+            expect(tagExtractor.isVariableDisplayed(1, 0)).toBeFalsy();
+            expect(isOptionDisplayed).toHaveBeenCalledWith(6, 0);
+        });
+        it("should return false when parent Option is not truthful", () => {
+            const inputsWithParentsFalse = {
+                ...simpleInputs,
+                options: { ...simpleInputs.options, "6": [false] },
+            };
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputsWithParentsFalse);
+            expect(customTagExtractor.isVariableDisplayed(1, 0)).toBeFalsy();
+        });
+        it("should return true when all checks are okay", () => {
+            const inputsWithAllChecks = {
+                ...simpleInputs,
+                options: { ...simpleInputs.options, "8": [true] },
+            };
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputsWithAllChecks);
+            expect(customTagExtractor.isVariableDisplayed(1, 0)).toBeTruthy();
+        });
+    });
+    describe("IsOptionDisplayed", () => {
+        it("should return false when option condition is false", () => {
+            const getOptionCondition = jest.spyOn(Extractor_1.default.prototype, "getOptionCondition");
+            getOptionCondition.mockImplementation((id, index) => !(id === 24 && index === 0));
+            expect(tagExtractor.isOptionDisplayed(24, 0)).toBeFalsy();
+            expect(getOptionCondition).toHaveBeenCalledWith(24, 0);
+        });
+        it("should return false when parentSectionCondition is false", () => {
+            const getSectionCondition = jest.spyOn(Extractor_1.default.prototype, "getSectionCondition");
+            getSectionCondition.mockImplementation(() => false);
+            expect(tagExtractor.isOptionDisplayed(24, 0)).toBeFalsy();
+            expect(getSectionCondition).toHaveBeenCalledWith(1);
+        });
+        it("should return false when parentCondition contains false value", () => {
+            const getOptionCondition = jest.spyOn(Extractor_1.default.prototype, "getOptionCondition");
+            getOptionCondition.mockImplementation((id, index) => !(id === 6 && index === 0));
+            expect(tagExtractor.isOptionDisplayed(24, 0)).toBeFalsy();
+            expect(getOptionCondition).toHaveBeenCalledWith(24, 0);
+        });
+        it("should return false when parentsInputs list contains false value", () => {
+            const inputsWithParentsInputsFalse = {
+                ...simpleInputs,
+                options: { ...simpleInputs.options, "6": [false] },
+            };
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputsWithParentsInputsFalse);
+            expect(customTagExtractor.isOptionDisplayed(24, 0)).toBeFalsy();
+        });
+        it("should not return errors when parentsInputs is undefined", () => {
+            const inputsWithParentsInputsUndefined = {
+                ...simpleInputs,
+                options: { ...simpleInputs.options },
+            };
+            delete inputsWithParentsInputsUndefined.options["6"];
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputsWithParentsInputsUndefined);
+            expect(customTagExtractor.isOptionDisplayed(24, 0)).toBeFalsy();
+        });
+        it("should return true when all checks are okay", () => {
+            expect(tagExtractor.isOptionDisplayed(24, 0)).toBeTruthy();
+        });
+    });
+    describe("convertToOptionVariables", () => {
+        it("should tag extraction match when instanciating TagExtractor with ovc or inputs", () => {
+            const customTagExtractor = new Extractor_1.default(simpleReferences, simpleOvc);
+            const expectedTags = new Extractor_1.default(simpleReferences, simpleInputs)
+                .getTags;
+            expect(customTagExtractor.getTags).toMatchObject(expectedTags);
+        });
+    });
+    describe("ReferenceParser", () => {
+        it("should tag extraction match when instanciating TagExtractor with model or references", () => {
+            const customTagExtractor = new Extractor_1.default(simpleModel, simpleInputs);
+            const expectedTags = new Extractor_1.default(simpleReferences, simpleInputs)
+                .getTags;
+            expect(customTagExtractor.getTags).toMatchObject(expectedTags);
+        });
+    });
+    describe("extractFromOptions", () => {
+        it("should return empty tag object when tags are undefined", () => {
+            const referencesWithoutOptionTagArray = {
+                ...simpleReferences,
+                options: {
+                    ...simpleReferences.options,
+                    "7": {
+                        ...simpleReferences.options["7"],
+                        meta: { ...simpleReferences.options["7"].meta, tags: undefined },
+                    },
+                },
+            };
+            const customTagExtractor = new Extractor_1.default(referencesWithoutOptionTagArray, simpleInputs);
+            expect(customTagExtractor.getTags.options).toMatchObject({});
+        });
+        it("should return empty tag object when options tags are empty", () => {
+            const referencesWithoutOptionTags = {
+                ...simpleReferences,
+                options: {
+                    ...simpleReferences.options,
+                    "7": {
+                        ...simpleReferences.options["7"],
+                        meta: { ...simpleReferences.options["7"].meta, tags: [] },
+                    },
+                },
+            };
+            const customTagExtractor = new Extractor_1.default(referencesWithoutOptionTags, simpleInputs);
+            expect(customTagExtractor.getTags.options).toMatchObject({});
+        });
+        it("should return empty tags when input's option is undefined", () => {
+            const inputsWithoutOptionTaggedAnswer = {
+                ...simpleInputs,
+                options: { ...simpleInputs.options },
+            };
+            delete inputsWithoutOptionTaggedAnswer.options["7"];
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputsWithoutOptionTaggedAnswer);
+            expect(customTagExtractor.getTags.options).toMatchObject({});
+        });
+        it("should return option tag when champ multiples", () => {
+            const inputWithChampMultiple = {
+                ...simpleInputs,
+                options: { ...simpleInputs.options, "7": [true, false] },
+            };
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputWithChampMultiple);
+            const expectedOptionTags = {
+                LP_fan: [
+                    {
+                        id: 7,
+                        index: 0,
+                        label: "Connaissiez-vous déjà LegalPlace ?",
+                        condition: true,
+                        visible: true,
+                        value: true,
+                    },
+                    {
+                        id: 7,
+                        index: 1,
+                        label: "Connaissiez-vous déjà LegalPlace ?",
+                        condition: true,
+                        visible: true,
+                        value: false,
+                    },
+                ],
+            };
+            expect(customTagExtractor.getTags.options).toMatchObject(expectedOptionTags);
+        });
+        it("should return option tags", () => {
+            const expectedOptionTags = {
+                LP_fan: [
+                    {
+                        id: 7,
+                        index: 0,
+                        label: "Connaissiez-vous déjà LegalPlace ?",
+                        condition: true,
+                        visible: true,
+                        value: true,
+                    },
+                ],
+            };
+            expect(tagExtractor.getTags.options).toMatchObject(expectedOptionTags);
+        });
+    });
+    describe("extractFromVariables", () => {
+        it("should return empty tag object when tags are undefined", () => {
+            const referenceWithoutVariableTagArray = {
+                ...simpleReferences,
+                variables: {
+                    ...simpleReferences.variables,
+                    "1": { ...simpleReferences.variables["1"], tags: undefined },
+                },
+            };
+            const customTagExtractor = new Extractor_1.default(referenceWithoutVariableTagArray, simpleInputs);
+            expect(customTagExtractor.getTags.variables).toMatchObject({});
+        });
+        it("should return empty tag object when variables tags are empty", () => {
+            const referenceWithoutTags = {
+                ...simpleReferences,
+                variables: {
+                    ...simpleReferences.variables,
+                    "1": { ...simpleReferences.variables["1"], tags: [] },
+                },
+            };
+            const customTagExtractor = new Extractor_1.default(referenceWithoutTags, simpleInputs);
+            expect(customTagExtractor.getTags.variables).toMatchObject({});
+        });
+        it("should return empty tags when input's variable is undefined", () => {
+            const inputsWithoutVariableTaggedAnswer = {
+                ...simpleInputs,
+                variables: { ...simpleInputs.variables },
+            };
+            delete inputsWithoutVariableTaggedAnswer.variables[1];
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputsWithoutVariableTaggedAnswer);
+            expect(customTagExtractor.getTags.variables).toMatchObject({});
+        });
+        it("should not throw error when input's variable does not match any references variable", () => {
+            const referenceWithoutMatchingVariable = {
+                ...simpleReferences,
+                variables: { ...simpleReferences.variables },
+            };
+            delete referenceWithoutMatchingVariable.variables["2"];
+            const customTagExtractor = new Extractor_1.default(referenceWithoutMatchingVariable, simpleInputs);
+            const expectedVariableTags = {
+                Company_name: [
+                    {
+                        id: 1,
+                        index: 0,
+                        label: "Nom de l'entreprise",
+                        condition: false,
+                        visible: false,
+                        value: "Company",
+                    },
+                ],
+            };
+            expect(customTagExtractor.getTags.variables).toMatchObject(expectedVariableTags);
+        });
+        it("should return variable tag when champ multiples", () => {
+            const inputVariableWithChampMultiple = {
+                ...simpleInputs,
+                variables: {
+                    ...simpleInputs.variables,
+                    "1": ["Nom de la companie", "Testing Company"],
+                },
+            };
+            const customTagExtractor = new Extractor_1.default(simpleReferences, inputVariableWithChampMultiple);
+            const expectedVariableTags = {
+                Company_name: [
+                    {
+                        id: 1,
+                        index: 0,
+                        label: "Nom de l'entreprise",
+                        condition: false,
+                        visible: false,
+                        value: "Nom de la companie",
+                    },
+                    {
+                        id: 1,
+                        index: 1,
+                        label: "Nom de l'entreprise",
+                        condition: false,
+                        visible: false,
+                        value: "Testing Company",
+                    },
+                ],
+            };
+            expect(customTagExtractor.getTags.variables).toMatchObject(expectedVariableTags);
+        });
+    });
+});