├── .gitignore
├── .gitpod.yml
├── README.md
├── package.json
├── public
├── style.css
└── client.js
├── views
└── index.html
├── tests
├── 2_functional-tests.js
└── 1_unit-tests.js
├── test-runner.js
├── server.js
└── assertion-analyser.js
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
--------------------------------------------------------------------------------
/.gitpod.yml:
--------------------------------------------------------------------------------
1 | image: gitpod/workspace-node-lts
2 |
3 | ports:
4 | - port: 3000
5 | onOpen: open-preview
6 | visibility: public
7 |
8 | tasks:
9 | - init: npm install
10 | command: npm run start
11 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Quality Assurance with Chai
2 |
3 | This is the boilerplate for the Quality Assurance with Chai lessons. Instructions for completing these lessons start at https://www.freecodecamp.org/learn/quality-assurance/quality-assurance-and-testing-with-chai/
4 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "automated-testing-app",
3 | "version": "0.0.1",
4 | "description": "Boilerplate for the Quality Assurance and Testing with Chai challenges",
5 | "main": "server.js",
6 | "scripts": {
7 | "start": "node server.js"
8 | },
9 | "dependencies": {
10 | "body-parser": "1.19.0",
11 | "chai": "4.3.4",
12 | "chai-http": "4.3.0",
13 | "cors": "2.8.5",
14 | "express": "4.17.1",
15 | "mocha": "9.0.3",
16 | "zombie": "6.1.4"
17 | },
18 | "license": "MIT"
19 | }
20 |
--------------------------------------------------------------------------------
/public/style.css:
--------------------------------------------------------------------------------
1 | body {
2 | color: #222;
3 | background-color: #eee;
4 | font-family: sans-serif;
5 | text-align: center;
6 | }
7 | #tn {
8 | margin-top:30px;
9 | }
10 | h1 {
11 | margin-bottom: 40px;
12 | }
13 | #tn span {
14 | font-weight: bold;
15 | }
16 | .pane {
17 | border: solid 1px #999;
18 | border-radius: 10px;
19 | max-width: 650px;
20 | margin: 10px auto;
21 | padding: 10px;
22 | box-sizing: border-box;
23 | }
24 | .specs {
25 | font-family: monospace;
26 | font-size: 1.1em;
27 | margin: 10px auto;
28 | text-align: left;
29 | padding-left: 10px;
30 | color: #555;
31 | }
--------------------------------------------------------------------------------
/views/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Quality Assurance with Chai | freeCodeCamp.org
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 | Automated Testing
16 |
17 |
18 |
19 | Functional Tests Example
20 |
21 |
Famous Italian Explorers
22 |
27 |
28 |
30 |
31 | Input form HTML:
32 | ----------------
33 | <input type="text" name="surname">
34 | <button type="submit">submit</button>
35 |
36 | Results div HTML (after Ajax):
37 | ------------------------------
38 | <p>first name:<span id="name">[name]</span></p>
39 | <p>last name:<span id="surname">[surname]</span></p>
40 | <p>dates:<span id="dates">[birth - death]</span></p>
41 |
42 |
Loading...
';
96 | utils.ajax(options, function(err, res) {
97 | if(err) return console.log(err);
98 | div.innerHTML = 'first name: ' + res.name + '
' +
99 | '
last name: ' + res.surname + '
' +
100 | '
dates: ' + res.dates + '
';
101 | });
102 | }
103 | });
104 | });
105 |
--------------------------------------------------------------------------------
/assertion-analyser.js:
--------------------------------------------------------------------------------
1 | function objParser(str, init) {
2 | // finds objects, arrays, strings, and function arguments
3 | // between parens, because they may contain ','
4 | const openSym = ["[", "{", '"', "'", "("];
5 | const closeSym = ["]", "}", '"', "'", ")"];
6 | let type;
7 | for (var i = init || 0; i < str.length; i++) {
8 | type = openSym.indexOf(str[i]);
9 | if (type !== -1) break;
10 | }
11 | if (type === -1) return null;
12 | const open = openSym[type];
13 | const close = closeSym[type];
14 | let count = 1;
15 | for (var k = i + 1; k < str.length; k++) {
16 | if (open === '"' || open === "'") {
17 | if (str[k] === close) count--;
18 | if (str[k] === "\\") k++;
19 | } else {
20 | if (str[k] === open) count++;
21 | if (str[k] === close) count--;
22 | }
23 | if (count === 0) break;
24 | }
25 | if (count !== 0) return null;
26 | const obj = str.slice(i, k + 1);
27 | return {
28 | start: i,
29 | end: k,
30 | obj: obj,
31 | };
32 | }
33 |
34 | function replacer(str) {
35 | // replace objects with a symbol ( __#n)
36 | let obj;
37 | let cnt = 0;
38 | let data = [];
39 | // obj = objParser(str) is not a syntax error
40 | while ((obj = objParser(str))) {
41 | data[cnt] = obj.obj;
42 | str =
43 | str.substring(0, obj.start) + "__#" + cnt++ + str.substring(obj.end + 1);
44 | }
45 | return {
46 | str: str,
47 | dictionary: data,
48 | };
49 | }
50 |
51 | function splitter(str) {
52 | // split on commas, then restore the objects
53 | const strObj = replacer(str);
54 | let args = strObj.str.split(",");
55 | args = args.map(function (a) {
56 | let m = a.match(/__#(\d+)/);
57 | while (m) {
58 | a = a.replace(/__#(\d+)/, strObj.dictionary[m[1]]);
59 | m = a.match(/__#(\d+)/);
60 | }
61 | return a.trim();
62 | });
63 | return args;
64 | }
65 |
66 | function assertionAnalyser(body) {
67 | // already filtered in the test runner
68 | // // remove comments
69 | // body = body.replace(/\/\/.*\n|\/\*.*\*\//g, '');
70 | // // get test function body
71 | // body = body.match(/\{\s*([\s\S]*)\}\s*$/)[1];
72 |
73 | if (!body) return "invalid assertion";
74 | // replace assertions bodies, so that they cannot
75 | // contain the word 'assertion'
76 |
77 | const cleanedBody = body.match(
78 | /(?:browser\s*\.\s*)?assert\s*\.\s*\w*\([\s\S]*\)/
79 | );
80 | if (cleanedBody && Array.isArray(cleanedBody)) {
81 | body = cleanedBody[0];
82 | } else {
83 | // No assertions present
84 | return [];
85 | }
86 | const s = replacer(body);
87 | // split on 'assertion'
88 | const splittedAssertions = s.str.split("assert");
89 | let assertions = splittedAssertions.slice(1);
90 | // match the METHODS
91 |
92 | let assertionBodies = [];
93 | const methods = assertions.map(function (a, i) {
94 | const m = a.match(/^\s*\.\s*(\w+)__#(\d+)/);
95 | assertionBodies.push(parseInt(m[2]));
96 | const pre = splittedAssertions[i].match(/browser\s*\.\s*/)
97 | ? "browser."
98 | : "";
99 | return pre + m[1];
100 | });
101 | if (
102 | methods.some(function (m) {
103 | return !m;
104 | })
105 | )
106 | return "invalid assertion";
107 | // remove parens from the assertions bodies
108 | const bodies = assertionBodies.map(function (b) {
109 | return s.dictionary[b].slice(1, -1).trim();
110 | });
111 | assertions = methods.map(function (m, i) {
112 | return {
113 | method: m,
114 | args: splitter(bodies[i]), //replace objects, split on ',' ,then restore objects
115 | };
116 | });
117 | return assertions;
118 | }
119 |
120 | module.exports = assertionAnalyser;
121 |
--------------------------------------------------------------------------------
/tests/1_unit-tests.js:
--------------------------------------------------------------------------------
1 | const chai = require('chai');
2 | const assert = chai.assert;
3 |
4 | suite('Unit Tests', function () {
5 | suite('Basic Assertions', function () {
6 | // #1
7 | test('#isNull, #isNotNull', function () {
8 | assert.fail(null, 'This is an optional error description - e.g. null is null');
9 | assert.fail(1, '1 is not null');
10 | });
11 | // #2
12 | test('#isDefined, #isUndefined', function () {
13 | assert.fail(null, 'null is not undefined');
14 | assert.fail(undefined, 'undefined IS undefined');
15 | assert.fail('hello', 'A string is not undefined');
16 | });
17 | // #3
18 | test('#isOk, #isNotOk', function () {
19 | assert.fail(null, 'null is falsey');
20 | assert.fail("I'm truthy", 'A string is truthy');
21 | assert.fail(true, 'true is truthy');
22 | });
23 | // #4
24 | test('#isTrue, #isNotTrue', function () {
25 | assert.fail(true, 'true is true');
26 | assert.fail(!!'double negation', 'Double negation of a truthy value is true');
27 | assert.fail({ value: 'truthy' }, 'Objects are truthy, but are not boolean values');
28 | });
29 | });
30 |
31 | // -----------------------------------------------------------------------------
32 |
33 | suite('Equality', function () {
34 | // #5
35 | test('#equal, #notEqual', function () {
36 | assert.fail(12, '12', 'Numbers are coerced into strings with ==');
37 | assert.fail({ value: 1 }, { value: 1 }, '== compares object references');
38 | assert.fail(6 * '2', '12');
39 | assert.fail(6 + '2', '12');
40 | });
41 | // #6
42 | test('#strictEqual, #notStrictEqual', function () {
43 | assert.fail(6, '6');
44 | assert.fail(6, 3 * 2);
45 | assert.fail(6 * '2', 12);
46 | assert.fail([1, 'a', {}], [1, 'a', {}]);
47 | });
48 | // #7
49 | test('#deepEqual, #notDeepEqual', function () {
50 | assert.fail({ a: '1', b: 5 }, { b: 5, a: '1' }, "The order of keys doesn't matter");
51 | assert.fail({ a: [5, 6] }, { a: [6, 5] }, 'The order of array elements does matter');
52 | });
53 | });
54 |
55 | // -----------------------------------------------------------------------------
56 |
57 | function weirdNumbers(delta) {
58 | return 1 + delta - Math.random();
59 | }
60 |
61 | suite('Comparisons', function () {
62 | // #8
63 | test('#isAbove, #isAtMost', function () {
64 | assert.fail('hello'.length, 5);
65 | assert.fail(1, 0);
66 | assert.fail(Math.PI, 3);
67 | assert.fail(1 - Math.random(), 1);
68 | });
69 | // #9
70 | test('#isBelow, #isAtLeast', function () {
71 | assert.fail('world'.length, 5);
72 | assert.fail(2 * Math.random(), 0);
73 | assert.fail(5 % 2, 2);
74 | assert.fail(2 / 3, 1);
75 | });
76 | // #10
77 | test('#approximately', function () {
78 | assert.fail(weirdNumbers(0.5), 1, 0);
79 | assert.fail(weirdNumbers(0.2), 1, 0);
80 | });
81 | });
82 |
83 | // -----------------------------------------------------------------------------
84 |
85 | const winterMonths = ['dec,', 'jan', 'feb', 'mar'];
86 | const backendLanguages = ['php', 'python', 'javascript', 'ruby', 'asp'];
87 | suite('Arrays', function () {
88 | // #11
89 | test('#isArray, #isNotArray', function () {
90 | assert.fail('isThisAnArray?'.split(''), 'String.prototype.split() returns an array');
91 | assert.fail([1, 2, 3].indexOf(2), 'indexOf returns a number');
92 | });
93 | // #12
94 | test('Array #include, #notInclude', function () {
95 | assert.fail(winterMonths, 'jul', "It's summer in july...");
96 | assert.fail(backendLanguages, 'javascript', 'JS is a backend language');
97 | });
98 | });
99 |
100 | // -----------------------------------------------------------------------------
101 |
102 | const formatPeople = function (name, age) {
103 | return '# name: ' + name + ', age: ' + age + '\n';
104 | };
105 | suite('Strings', function () {
106 | // #13
107 | test('#isString, #isNotString', function () {
108 | assert.fail(Math.sin(Math.PI / 4), 'A float is not a string');
109 | assert.fail(process.env.PATH, 'An env variable is a string (or undefined)');
110 | assert.fail(JSON.stringify({ type: 'object' }), 'JSON is a string');
111 | });
112 | // #14
113 | test('String #include, #notInclude', function () {
114 | assert.fail('Arrow', 'row', "'Arrow' contains 'row'");
115 | assert.fail('dart', 'queue', "But 'dart' doesn't contain 'queue'");
116 | });
117 | // #15
118 | test('#match, #notMatch', function () {
119 | const regex = /^#\sname\:\s[\w\s]+,\sage\:\s\d+\s?$/;
120 | assert.fail(formatPeople('John Doe', 35), regex);
121 | assert.fail(formatPeople('Paul Smith III', 'twenty-four'), regex);
122 | });
123 | });
124 |
125 | // -----------------------------------------------------------------------------
126 |
127 | const Car = function () {
128 | this.model = 'sedan';
129 | this.engines = 1;
130 | this.wheels = 4;
131 | };
132 |
133 | const Plane = function () {
134 | this.model = '737';
135 | this.engines = ['left', 'right'];
136 | this.wheels = 6;
137 | this.wings = 2;
138 | };
139 |
140 | const myCar = new Car();
141 | const airlinePlane = new Plane();
142 |
143 | suite('Objects', function () {
144 | // #16
145 | test('#property, #notProperty', function () {
146 | assert.fail(myCar, 'wings', "Cars don't have wings");
147 | assert.fail(airlinePlane, 'engines', 'Planes have engines');
148 | assert.fail(myCar, 'wheels', 'Cars have wheels');
149 | });
150 | // #17
151 | test('#typeOf, #notTypeOf', function () {
152 | assert.fail(myCar, 'object');
153 | assert.fail(myCar.model, 'string');
154 | assert.fail(airlinePlane.wings, 'string');
155 | assert.fail(airlinePlane.engines, 'array');
156 | assert.fail(myCar.wheels, 'number');
157 | });
158 | // #18
159 | test('#instanceOf, #notInstanceOf', function () {
160 | assert.fail(myCar, Plane);
161 | assert.fail(airlinePlane, Plane);
162 | assert.fail(airlinePlane, Object);
163 | assert.fail(myCar.wheels, String);
164 | });
165 | });
166 |
167 | // -----------------------------------------------------------------------------
168 | });
169 |
--------------------------------------------------------------------------------