Repository navigation
Expand file tree
/
Copy pathassert.js
More file actions
133 lines (116 loc) · 3.93 KB
/
Copy pathassert.js
File metadata and controls
133 lines (116 loc) · 3.93 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
let core;
const fs = require("fs");
const parseResult = (resultStr, varName) => {
const regex = /\[(.*)\]/; // match the first occurrence of square brackets and capture everything in between
const matches = resultStr.match(regex);
if (matches) {
const jsonStr = matches[0]; // extract the captured string
try {
const jsonObj = JSON.parse(jsonStr); // parse the JSON string into an object
return jsonObj;
} catch (error) {
throw(`Failed to parse ${varName} JSON
\nvalue: ${resultStr}
\nerror: ${error}`);
}
}
return null; // return null if no JSON object was found in the string
};
const getExpectedResult = (expectedResultStr, expectedResultFilePath) => {
let expectedResult;
if (expectedResultStr) {
expectedResult = parseResult(expectedResultStr, "expectedResultStr");
} else if (expectedResultFilePath) {
const fileContent = fs.readFileSync(expectedResultFilePath).toString();
expectedResult = parseResult(fileContent, "expectedResultFilePath");
}
return expectedResult;
};
const checkResult = (expectedResult, expectedRows, actualResult) => {
let equality;
let message;
expectedRows = parseInt(expectedRows);
// if only passed expectedRows, check expectedRows
// if only passed expected result, only check expected result
// if both passed, check both
if (expectedRows) {
equality = actualResult.length === expectedRows;
if(equality) {
message = `============ StackQL Assert Successful (row count) ============ \n
Expected Number of Rows: ${expectedRows} \n
Actual Number of Rows: ${actualResult.length} \n
`;
} else {
message = `============ StackQL Assert Failed (row count) ============ \n
Expected Number of Rows: ${expectedRows} \n
Actual Number of Rows: ${actualResult.length} \n
Execution Result: ${JSON.stringify(actualResult)} \n
`;
}
}
if (expectedResult) {
equality = JSON.stringify(expectedResult) === JSON.stringify(actualResult);
if(equality) {
message = `============ StackQL Assert Successful (expected results) ============`;
} else {
message = `============ StackQL Assert Failed (expected results) ============ \n
Expected: ${JSON.stringify(expectedResult)}\n
Actual: ${JSON.stringify(actualResult)}
`;
}
}
return { equality, message };
};
function checkParameters(expectedResultStr, expectedResultFilePath, expectedRows) {
const params = [
{ name: "expectedResultStr", value: expectedResultStr },
{ name: "expectedResultFilePath", value: expectedResultFilePath },
{ name: "expectedRows", value: expectedRows },
];
const missingParams = params
.filter(param => !param.value || param.value === "undefined")
.map(param => param.name)
if (missingParams.length === 3) {
const errorMessage = "Cannot find expected result, file path or expected rows";
throw errorMessage;
}
}
const assertResult = (coreObj) =>{
core = coreObj;
try {
let [
execResultStr,
expectedResultStr,
expectedResultFilePath,
expectedRows,
] = [
process.env.RESULT,
process.env.EXPECTED_RESULTS_STR,
process.env.EXPECTED_RESULTS_FILE_PATH,
process.env.EXPECTED_ROWS,
];
checkParameters(expectedResultStr, expectedResultFilePath, expectedRows)
let expectedResult = getExpectedResult(
expectedResultStr,
expectedResultFilePath
);
const actualResult = parseResult(execResultStr);
if (!actualResult) {
core.setFailed("No Output from executing query");
}
const {equality, message} = checkResult(expectedResult, expectedRows, actualResult);
if (equality) {
core.info(message);
} else {
core.setFailed(message);
}
} catch (e) {
core.setFailed(e);
}
}
module.exports = {
assertResult,
parseResult,
checkResult,
getExpectedResult
};