localizedConstants.test.ts ➔ badCriteriaType - Code Metrics - Inspection of "Create functions for converting api data to form d..." - GCTC-NTGC/TalentCloud - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — feature/experience-form-modals ( 7402c2...37703b )

by Tristan

created 2020-06-11 19:05 UTC

localizedConstants.test.ts ➔ badCriteriaType A

↳ Parent: resources/assets/js/models/localizedConstants.test.ts

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
dl	0
loc	2
rs	10
c	0
b	0
f	0

/* eslint-disable no-undef */
import {
  skillLevelName,
  skillLevelDescription,
  assessmentType,
  criteriaType,
} from "./localizedConstants";
import {
  AssessmentTypeId,
  CriteriaTypeId,
  SkillLevelId,
  SkillTypeId,
  enumToIds,
} from "./lookupConstants";

test("enumToIds works", (): void => {
  const skillLevelIdValues: number[] = enumToIds(SkillLevelId);
  expect(skillLevelIdValues).toEqual([1, 2, 3, 4]);
});

describe("skillLevelName", (): void => {
  it("returns a truthy object", (): void => {
    expect(skillLevelName(1, 1)).toBeTruthy();
  });

  it("raise an error when skill level value is not part of enum", (): void => {
    function badSkillLevel(): void {
      skillLevelName(42, SkillTypeId.Soft);
    }
    expect(badSkillLevel).toThrow("invalid SkillLevelIdValue");
  });

  it("raise an error when skill type value is not part of enum", (): void => {
    function badSkillType(): void {
      skillLevelName(SkillLevelId.Basic, 42);
    }
    expect(badSkillType).toThrow("invalid SkillTypeIdValue");
  });

  it("returns a basic soft localization", (): void => {
    expect(skillLevelName(SkillLevelId.Basic, SkillTypeId.Soft).id).toEqual(
      "skillLevel.soft.basic.name",
    );
  });

  it("returns a intermediate soft localization", (): void => {
    expect(
      skillLevelName(SkillLevelId.Intermediate, SkillTypeId.Soft).id,
    ).toEqual("skillLevel.soft.intermediate.name");
  });

  it("returns a advanced soft localization", (): void => {
    expect(skillLevelName(SkillLevelId.Advanced, SkillTypeId.Soft).id).toEqual(
      "skillLevel.soft.advanced.name",
    );
  });

  it("returns a expert soft localization", (): void => {
    expect(skillLevelName(SkillLevelId.Expert, SkillTypeId.Soft).id).toEqual(
      "skillLevel.soft.expert.name",
    );
  });

  it("returns a basic hard localization", (): void => {
    expect(skillLevelName(SkillLevelId.Basic, SkillTypeId.Hard).id).toEqual(
      "skillLevel.hard.basic.name",
    );
  });

  it("returns a intermediate hard localization", (): void => {
    expect(
      skillLevelName(SkillLevelId.Intermediate, SkillTypeId.Hard).id,
    ).toEqual("skillLevel.hard.intermediate.name");
  });

  it("returns a advanced hard localization", (): void => {
    expect(skillLevelName(SkillLevelId.Advanced, SkillTypeId.Hard).id).toEqual(
      "skillLevel.hard.advanced.name",
    );
  });

  it("returns a expert hard localization", (): void => {
    expect(skillLevelName(SkillLevelId.Expert, SkillTypeId.Hard).id).toEqual(
      "skillLevel.hard.expert.name",
    );
  });
});

describe("skillLevelDescription", (): void => {
  it("returns a truthy object", (): void => {
    expect(skillLevelDescription(1, 1)).toBeTruthy();
  });

  it("raise an error when skill level value is not part of enum", (): void => {
    function badSkillLevel(): void {
      skillLevelName(42, SkillTypeId.Soft);
    }
    expect(badSkillLevel).toThrow("invalid SkillLevelIdValue");
  });

  it("raise an error when skill type value is not part of enum", (): void => {
    function badSkillType(): void {
      skillLevelName(SkillLevelId.Basic, 42);
    }
    expect(badSkillType).toThrow("invalid SkillTypeIdValue");
  });

  it("returns a basic soft localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Basic, SkillTypeId.Soft).id,
    ).toEqual("skillLevel.soft.basic.description");
  });

  it("returns a intermediate soft localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Intermediate, SkillTypeId.Soft).id,
    ).toEqual("skillLevel.soft.intermediate.description");
  });

  it("returns a advanced soft localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Advanced, SkillTypeId.Soft).id,
    ).toEqual("skillLevel.soft.advanced.description");
  });

  it("returns a expert soft localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Expert, SkillTypeId.Soft).id,
    ).toEqual("skillLevel.soft.expert.description");
  });

  it("returns a basic hard localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Basic, SkillTypeId.Hard).id,
    ).toEqual("skillLevel.hard.basic.description");
  });

  it("returns a intermediate hard localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Intermediate, SkillTypeId.Hard).id,
    ).toEqual("skillLevel.hard.intermediate.description");
  });

  it("returns a advanced hard localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Advanced, SkillTypeId.Hard).id,
    ).toEqual("skillLevel.hard.advanced.description");
  });

  it("returns a expert hard localization", (): void => {
    expect(
      skillLevelDescription(SkillLevelId.Expert, SkillTypeId.Hard).id,
    ).toEqual("skillLevel.hard.expert.description");
  });
});

describe("assessmentType", (): void => {
  it("returns a truthy object", (): void => {
    expect(assessmentType(AssessmentTypeId.NarrativeAssessment)).toBeTruthy();
  });

  it("raise an error when Assessment Type value is not part of enum", (): void => {
    function badAssessmentType(): void {
      assessmentType(42);
    }
    expect(badAssessmentType).toThrow("invalid AssessmentTypeValue");
  });

  it("returns a narrative assessment localization", (): void => {
    expect(assessmentType(AssessmentTypeId.NarrativeAssessment).id).toEqual(
      "assessmentType.narrativeAssessment",
    );
  });

  it("returns a narrative assessment localization", (): void => {
    expect(assessmentType(AssessmentTypeId.NarrativeAssessment).id).toEqual(
      "assessmentType.narrativeAssessment",
    );
  });

  it("returns a group test localization", (): void => {
    expect(assessmentType(AssessmentTypeId.GroupTest).id).toEqual(
      "assessmentType.groupTest",
    );
  });

  it("returns an informal phone conversation localization", (): void => {
    expect(
      assessmentType(AssessmentTypeId.InformalPhoneConversation).id,
    ).toEqual("assessmentType.informalPhoneConversation");
  });

  it("returns an interview localization", (): void => {
    expect(assessmentType(AssessmentTypeId.Interview).id).toEqual(
      "assessmentType.interview",
    );
  });

  it("returns an online exam localization", (): void => {
    expect(assessmentType(AssessmentTypeId.OnlineExam).id).toEqual(
      "assessmentType.onlineExam",
    );
  });

  it("returns an on site exam localization", (): void => {
    expect(assessmentType(AssessmentTypeId.OnSiteExam).id).toEqual(
      "assessmentType.onSiteExam",
    );
  });

  it("returns a take home exam localization", (): void => {
    expect(assessmentType(AssessmentTypeId.TakeHomeExam).id).toEqual(
      "assessmentType.takeHomeExam",
    );
  });

  it("returns a portfolio review localization", (): void => {
    expect(assessmentType(AssessmentTypeId.PortfolioReview).id).toEqual(
      "assessmentType.portfolioReview",
    );
  });

  it("returns a reference check localization", (): void => {
    expect(assessmentType(AssessmentTypeId.ReferenceCheck).id).toEqual(
      "assessmentType.referenceCheck",
    );
  });

  it("returns a serious Games localization", (): void => {
    expect(assessmentType(AssessmentTypeId.SeriousGames).id).toEqual(
      "assessmentType.seriousGames",
    );
  });
});

describe("criteriaType", (): void => {
  it("returns a truthy object", (): void => {
    expect(criteriaType(CriteriaTypeId.Asset)).toBeTruthy();
  });

  it("raise an error when Assessment Type value is not part of enum", (): void => {
    function badCriteriaType(): void {
      criteriaType(42);
    }
    expect(badCriteriaType).toThrow("invalid CriteriaTypeValue");
  });

  it("returns an asset localization", (): void => {
    expect(criteriaType(CriteriaTypeId.Asset).id).toEqual("criteriaType.asset");
  });

  it("returns an essential localization", (): void => {
    expect(criteriaType(CriteriaTypeId.Essential).id).toEqual(
      "criteriaType.essential",
    );
  });
});


1			/* eslint-disable no-undef */
2			import {
3			skillLevelName,
4			skillLevelDescription,
5			assessmentType,
6			criteriaType,
7			} from "./localizedConstants";
8			import {
9			AssessmentTypeId,
10			CriteriaTypeId,
11			SkillLevelId,
12			SkillTypeId,
13			enumToIds,
14			} from "./lookupConstants";
15
16			test("enumToIds works", (): void => {
17			const skillLevelIdValues: number[] = enumToIds(SkillLevelId);
18			expect(skillLevelIdValues).toEqual([1, 2, 3, 4]);
19			});
20
21			describe("skillLevelName", (): void => {
22			it("returns a truthy object", (): void => {
23			expect(skillLevelName(1, 1)).toBeTruthy();
24			});
25
26			it("raise an error when skill level value is not part of enum", (): void => {
27			function badSkillLevel(): void {
28			skillLevelName(42, SkillTypeId.Soft);
29			}
30			expect(badSkillLevel).toThrow("invalid SkillLevelIdValue");
31			});
32
33			it("raise an error when skill type value is not part of enum", (): void => {
34			function badSkillType(): void {
35			skillLevelName(SkillLevelId.Basic, 42);
36			}
37			expect(badSkillType).toThrow("invalid SkillTypeIdValue");
38			});
39
40			it("returns a basic soft localization", (): void => {
41			expect(skillLevelName(SkillLevelId.Basic, SkillTypeId.Soft).id).toEqual(
42			"skillLevel.soft.basic.name",
43			);
44			});
45
46			it("returns a intermediate soft localization", (): void => {
47			expect(
48			skillLevelName(SkillLevelId.Intermediate, SkillTypeId.Soft).id,
49			).toEqual("skillLevel.soft.intermediate.name");
50			});
51
52			it("returns a advanced soft localization", (): void => {
53			expect(skillLevelName(SkillLevelId.Advanced, SkillTypeId.Soft).id).toEqual(
54			"skillLevel.soft.advanced.name",
55			);
56			});
57
58			it("returns a expert soft localization", (): void => {
59			expect(skillLevelName(SkillLevelId.Expert, SkillTypeId.Soft).id).toEqual(
60			"skillLevel.soft.expert.name",
61			);
62			});
63
64			it("returns a basic hard localization", (): void => {
65			expect(skillLevelName(SkillLevelId.Basic, SkillTypeId.Hard).id).toEqual(
66			"skillLevel.hard.basic.name",
67			);
68			});
69
70			it("returns a intermediate hard localization", (): void => {
71			expect(
72			skillLevelName(SkillLevelId.Intermediate, SkillTypeId.Hard).id,
73			).toEqual("skillLevel.hard.intermediate.name");
74			});
75
76			it("returns a advanced hard localization", (): void => {
77			expect(skillLevelName(SkillLevelId.Advanced, SkillTypeId.Hard).id).toEqual(
78			"skillLevel.hard.advanced.name",
79			);
80			});
81
82			it("returns a expert hard localization", (): void => {
83			expect(skillLevelName(SkillLevelId.Expert, SkillTypeId.Hard).id).toEqual(
84			"skillLevel.hard.expert.name",
85			);
86			});
87			});
88
89			describe("skillLevelDescription", (): void => {
90			it("returns a truthy object", (): void => {
91			expect(skillLevelDescription(1, 1)).toBeTruthy();
92			});
93
94			it("raise an error when skill level value is not part of enum", (): void => {
95			function badSkillLevel(): void {
96			skillLevelName(42, SkillTypeId.Soft);
97			}
98			expect(badSkillLevel).toThrow("invalid SkillLevelIdValue");
99			});
100
101			it("raise an error when skill type value is not part of enum", (): void => {
102			function badSkillType(): void {
103			skillLevelName(SkillLevelId.Basic, 42);
104			}
105			expect(badSkillType).toThrow("invalid SkillTypeIdValue");
106			});
107
108			it("returns a basic soft localization", (): void => {
109			expect(
110			skillLevelDescription(SkillLevelId.Basic, SkillTypeId.Soft).id,
111			).toEqual("skillLevel.soft.basic.description");
112			});
113
114			it("returns a intermediate soft localization", (): void => {
115			expect(
116			skillLevelDescription(SkillLevelId.Intermediate, SkillTypeId.Soft).id,
117			).toEqual("skillLevel.soft.intermediate.description");
118			});
119
120			it("returns a advanced soft localization", (): void => {
121			expect(
122			skillLevelDescription(SkillLevelId.Advanced, SkillTypeId.Soft).id,
123			).toEqual("skillLevel.soft.advanced.description");
124			});
125
126			it("returns a expert soft localization", (): void => {
127			expect(
128			skillLevelDescription(SkillLevelId.Expert, SkillTypeId.Soft).id,
129			).toEqual("skillLevel.soft.expert.description");
130			});
131
132			it("returns a basic hard localization", (): void => {
133			expect(
134			skillLevelDescription(SkillLevelId.Basic, SkillTypeId.Hard).id,
135			).toEqual("skillLevel.hard.basic.description");
136			});
137
138			it("returns a intermediate hard localization", (): void => {
139			expect(
140			skillLevelDescription(SkillLevelId.Intermediate, SkillTypeId.Hard).id,
141			).toEqual("skillLevel.hard.intermediate.description");
142			});
143
144			it("returns a advanced hard localization", (): void => {
145			expect(
146			skillLevelDescription(SkillLevelId.Advanced, SkillTypeId.Hard).id,
147			).toEqual("skillLevel.hard.advanced.description");
148			});
149
150			it("returns a expert hard localization", (): void => {
151			expect(
152			skillLevelDescription(SkillLevelId.Expert, SkillTypeId.Hard).id,
153			).toEqual("skillLevel.hard.expert.description");
154			});
155			});
156
157			describe("assessmentType", (): void => {
158			it("returns a truthy object", (): void => {
159			expect(assessmentType(AssessmentTypeId.NarrativeAssessment)).toBeTruthy();
160			});
161
162			it("raise an error when Assessment Type value is not part of enum", (): void => {
163			function badAssessmentType(): void {
164			assessmentType(42);
165			}
166			expect(badAssessmentType).toThrow("invalid AssessmentTypeValue");
167			});
168
169			it("returns a narrative assessment localization", (): void => {
170			expect(assessmentType(AssessmentTypeId.NarrativeAssessment).id).toEqual(
171			"assessmentType.narrativeAssessment",
172			);
173			});
174
175			it("returns a narrative assessment localization", (): void => {
176			expect(assessmentType(AssessmentTypeId.NarrativeAssessment).id).toEqual(
177			"assessmentType.narrativeAssessment",
178			);
179			});
180
181			it("returns a group test localization", (): void => {
182			expect(assessmentType(AssessmentTypeId.GroupTest).id).toEqual(
183			"assessmentType.groupTest",
184			);
185			});
186
187			it("returns an informal phone conversation localization", (): void => {
188			expect(
189			assessmentType(AssessmentTypeId.InformalPhoneConversation).id,
190			).toEqual("assessmentType.informalPhoneConversation");
191			});
192
193			it("returns an interview localization", (): void => {
194			expect(assessmentType(AssessmentTypeId.Interview).id).toEqual(
195			"assessmentType.interview",
196			);
197			});
198
199			it("returns an online exam localization", (): void => {
200			expect(assessmentType(AssessmentTypeId.OnlineExam).id).toEqual(
201			"assessmentType.onlineExam",
202			);
203			});
204
205			it("returns an on site exam localization", (): void => {
206			expect(assessmentType(AssessmentTypeId.OnSiteExam).id).toEqual(
207			"assessmentType.onSiteExam",
208			);
209			});
210
211			it("returns a take home exam localization", (): void => {
212			expect(assessmentType(AssessmentTypeId.TakeHomeExam).id).toEqual(
213			"assessmentType.takeHomeExam",
214			);
215			});
216
217			it("returns a portfolio review localization", (): void => {
218			expect(assessmentType(AssessmentTypeId.PortfolioReview).id).toEqual(
219			"assessmentType.portfolioReview",
220			);
221			});
222
223			it("returns a reference check localization", (): void => {
224			expect(assessmentType(AssessmentTypeId.ReferenceCheck).id).toEqual(
225			"assessmentType.referenceCheck",
226			);
227			});
228
229			it("returns a serious Games localization", (): void => {
230			expect(assessmentType(AssessmentTypeId.SeriousGames).id).toEqual(
231			"assessmentType.seriousGames",
232			);
233			});
234			});
235
236			describe("criteriaType", (): void => {
237			it("returns a truthy object", (): void => {
238			expect(criteriaType(CriteriaTypeId.Asset)).toBeTruthy();
239			});
240
241			it("raise an error when Assessment Type value is not part of enum", (): void => {
242			function badCriteriaType(): void {
243			criteriaType(42);
244			}
245			expect(badCriteriaType).toThrow("invalid CriteriaTypeValue");
246			});
247
248			it("returns an asset localization", (): void => {
249			expect(criteriaType(CriteriaTypeId.Asset).id).toEqual("criteriaType.asset");
250			});
251
252			it("returns an essential localization", (): void => {
253			expect(criteriaType(CriteriaTypeId.Essential).id).toEqual(
254			"criteriaType.essential",
255			);
256			});
257			});
258

GCTC-NTGC / TalentCloud

Push — feature/experience-form-modals ( 7402c2...37703b )

localizedConstants.test.ts ➔ badCriteriaType A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like