test: run yaml load in before hook

Author: azech-hqs

tests/utils/yaml.combine.tests.ts

@@ -12,15 +12,16 @@ const combineSchema = yaml.DEFAULT_SCHEMA.extend([combineType, esseType]);
 
 describe("YAML tag: !combine", () => {
     let yamlFixture;
+    let parsed;
 
     // eslint-disable-next-line func-names
     before(function () {
         this.timeout(5000);
         yamlFixture = fs.readFileSync(YAML_COMBINE_FILE, "utf8");
+        parsed = yaml.load(yamlFixture, { schema: combineSchema });
     });
 
     it("should correctly parse a custom !combine tag with forEach and config keys", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "mytest", a: 1, b: 3, c: 5 },
             { name: "mytest", a: 1, b: 4, c: 5 },
@@ -32,72 +33,57 @@ describe("YAML tag: !combine", () => {
     });
 
     it("should correctly parse a custom !combine tag with only a name key", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [{ name: "mytest" }];
-
         expect(parsed.case2).to.have.deep.members(expectedResult);
     });
 
     it("should correctly parse a custom !combine tag with forEach key and no values", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [{ name: "mytest" }];
-
         expect(parsed.case3).to.have.deep.members(expectedResult);
     });
 
     it("should correctly parse a custom !combine tag with an empty forEach key and a config key", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [{ name: "mytest", c: 5 }];
-
         expect(parsed.case4).to.have.deep.members(expectedResult);
     });
 
     it("should correctly generate name based on template", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "A1 with B2 and C5", a: 1, b: "two", c: 5 },
             { name: "A1 with B4 and C5", a: 1, b: "four", c: 5 },
         ];
-
         expect(parsed.case5).to.have.deep.members(expectedResult);
     });
 
     it("should correctly parse a custom !combine tag with additional property", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "mytest", a: 1, b: 3 },
             { name: "mytest", a: 1, b: 4 },
             { name: "additional property", x: 7 },
         ];
-
         expect(parsed.case6).to.have.deep.members(expectedResult);
     });
 
     it("should correctly parse a custom !combine tag with additional property from !combine tag", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "mytest", a: 1, b: 3 },
             { name: "mytest", a: 1, b: 4 },
             { name: "additional property", x: 7, y: 9 },
             { name: "additional property", x: 8, y: 9 },
         ];
-
         expect(parsed.case7).to.have.deep.members(expectedResult);
     });
 
     it("should create an additional config when falsy parameter is provided", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "A1 with B2", a: 1, b: "two" },
             { name: "A1 with B4", a: 1, b: "four" },
             { name: "A1", a: 1 },
         ];
-
         expect(parsed.case8).to.have.deep.members(expectedResult);
     });
 
     it("should create all combinations of n optional parameters", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "optional params", a: 1 },
             { name: "optional params", a: 1, b: 2 },
@@ -106,19 +92,15 @@ describe("YAML tag: !combine", () => {
             { name: "optional params", a: 1, b: 2, c: 4 },
             { name: "optional params", a: 1, b: 3, c: 4 },
         ];
-
         expect(parsed.case9).to.have.deep.members(expectedResult);
     });
 
     it("should allow to exclude certain parameter-specified combinations", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [{ name: "ignore test", a: { c: 3 }, d: 4 }];
-
         expect(parsed.case10).to.have.deep.members(expectedResult);
     });
 
     it("should use the push action to add value to an array parameter", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const expectedResult = [
             { name: "push test", units: [{ a: 1 }, { b: 4 }] },
             { name: "push test", units: [{ a: 2 }, { b: 4 }] },
@@ -136,7 +118,6 @@ describe("YAML tag: !combine", () => {
     });
 
     it("should use cloned objects when pushing to array", () => {
-        const parsed = yaml.load(yamlFixture, { schema: combineSchema });
         const [config1, config2] = parsed.case12;
 
         // deleting property in one should not affect the other

tests/utils/yaml.esse.tests.ts

@@ -9,10 +9,15 @@ import { YAML_ESSE_FILE } from "../enums";
 const yamlSchema = yaml.DEFAULT_SCHEMA.extend([esseType]);
 
 describe("YAML tag: !esse", () => {
-    const yamlFixture = fs.readFileSync(YAML_ESSE_FILE, "utf8");
+    let yamlFixture;
+    let parsed;
+
+    before(() => {
+        yamlFixture = fs.readFileSync(YAML_ESSE_FILE, "utf8");
+        parsed = yaml.load(yamlFixture, { schema: yamlSchema });
+    });
 
     it("should correctly parse a custom !esse tag and return ESSE schema", () => {
-        const parsed = yaml.load(yamlFixture, { schema: yamlSchema });
         const expected = {
             $id: "core/primitive/scalar",
             $schema: "http://json-schema.org/draft-04/schema#",
@@ -29,24 +34,20 @@ describe("YAML tag: !esse", () => {
     });
 
     it("should return the original data when an error occurs", () => {
-        const parsed = yaml.load(yamlFixture, { schema: yamlSchema });
         expect(parsed.case2).to.be.equal("non-existent-schema-id");
     });
 
     it("should parse a custom !esse tag and return a value from the ESSE schema", () => {
-        const parsed = yaml.load(yamlFixture, { schema: yamlSchema });
         const expected = ["kbar", "pa"];
         expect(parsed.case3).to.have.deep.members(expected);
     });
 
     it("should correctly return nested value from esse schema", () => {
-        const parsed = yaml.load(yamlFixture, { schema: yamlSchema });
         const expected = "array containing values of x Axis";
         expect(parsed.case4).to.be.eql(expected);
     });
 
     it("should correctly return array item from esse schema", () => {
-        const parsed = yaml.load(yamlFixture, { schema: yamlSchema });
         const expected = "yDataSeries";
         expect(parsed.case5).to.be.eql(expected);
     });