You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
416 lines
16 KiB
JavaScript
416 lines
16 KiB
JavaScript
/**
|
|
* Corrector para la práctica de cmd
|
|
*/
|
|
|
|
// IMPORTS
|
|
const should = require('chai').should();
|
|
const path = require('path');
|
|
const fs = require('fs-extra');
|
|
const Utils = require('./utils');
|
|
const to = require('./to');
|
|
const child_process = require("child_process");
|
|
const spawn = require("child_process").spawn;
|
|
|
|
const path_assignment = path.resolve(path.join(__dirname, "../"));
|
|
|
|
// CRITICAL ERRORS
|
|
let error_critical = null;
|
|
|
|
// CONSTANTS
|
|
const T_WAIT = 2; // Time between commands
|
|
const T_TEST = 2 * 60; // Time between tests (seconds)
|
|
|
|
// HELPERS
|
|
const timeout = ms => new Promise(res => setTimeout(res, ms));
|
|
|
|
//TESTS
|
|
describe("mooc_node-mod5_quiz_cmd", function () {
|
|
|
|
this.timeout(T_TEST * 1000);
|
|
|
|
it(`1: Checking that the assignment directory exists...`, async function () {
|
|
this.score = 0.34;
|
|
this.msg_ok = `Found the directory '${path_assignment}'`;
|
|
this.msg_err = `Couldn't find the directory '${path_assignment}'`;
|
|
const [error_path, path_ok] = await to(fs.pathExists(path_assignment));
|
|
if (error_path) {
|
|
error_critical = this.msg_err;
|
|
}
|
|
path_ok.should.be.equal(true);
|
|
});
|
|
|
|
it(`2: Installing dependencies...`, async function () {
|
|
this.score = 0.33;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
this.msg_ok = "Dependencies installed successfully";
|
|
this.msg_err = "Error installing dependencies";
|
|
|
|
// check that package.json exists
|
|
const path_json = path.join(path_assignment, 'package.json');
|
|
const [json_nok, json_ok] = await to(fs.pathExists(path_json));
|
|
if (json_nok || !json_ok) {
|
|
this.msg_err = `The file '${path_json}' has not been found`;
|
|
error_critical = this.msg_err;
|
|
}
|
|
json_ok.should.be.equal(true);
|
|
|
|
// check package.json format
|
|
const [error_json, contenido] = await to(fs.readFile(path_json, 'utf8'));
|
|
if (error_json) {
|
|
this.msg_err = `The file '${path_json}' doesn't have the right format`;
|
|
error_critical = this.msg_err;
|
|
}
|
|
should.not.exist(error_json);
|
|
const es_json = Utils.isJSON(contenido);
|
|
if (!es_json) {
|
|
error_critical = this.msg_err;
|
|
}
|
|
es_json.should.be.equal(true);
|
|
|
|
// run npm install
|
|
let error_deps;
|
|
try {
|
|
child_process.execSync("npm install", {cwd: path_assignment}).toString();
|
|
} catch (error_deps) {
|
|
this.msg_err = "Error running 'npm install': " + error_deps;
|
|
error_critical = this.msg_err;
|
|
console.log(error_deps);
|
|
}
|
|
should.not.exist(error_deps);
|
|
|
|
// inject local figlet
|
|
try {
|
|
const figdata = "module.exports.textSync = function(text){return text};";
|
|
fs.removeSync(path.join(path_assignment, 'node_modules', 'figlet'));
|
|
fs.mkdirSync(path.join(path_assignment, 'node_modules', 'figlet'));
|
|
fs.writeFileSync(path.join(path_assignment, 'node_modules', 'figlet', 'index.js'), figdata, {
|
|
encoding: 'utf8',
|
|
flag: 'w'
|
|
});
|
|
} catch (error) {
|
|
debug("Error wrapping figlet");
|
|
}
|
|
|
|
// replace answers file
|
|
[_, path_ok] = await to(fs.move(path.join(path_assignment, 'quizzes.json'), path.join(path_assignment, 'quizzes.original.json'), {"overwrite": true}));
|
|
[error_deps, path_ok] = await to(fs.copy(path.join(path_assignment, 'tests', 'quizzes.json'), path.join(path_assignment, 'quizzes.json'), {"overwrite": true}));
|
|
if (error_deps) {
|
|
this.msg_err = "Error copying the answers file: " + error_deps;
|
|
error_critical = this.msg_err;
|
|
}
|
|
should.not.exist(error_deps);
|
|
}
|
|
});
|
|
|
|
|
|
it(`3: Checking that the file 'quizzes.json' is read. Running 'list'...`, async function () {
|
|
this.score = 0.33;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["list"];
|
|
const expected = "Answer Number 1";
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.stdin.write(input[0] + "\n");
|
|
}
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`4: Checking that invalid input parameters are detected. Running 'test'...`, async function () {
|
|
this.score = 1;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["test"];
|
|
const expected = /error/img;
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`5: Checking that right answers are detected. Running 'test 1'...`, async function () {
|
|
this.score = 1;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["test 1", "OK"];
|
|
const expected = /\bcorrect/img;
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[1] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`6: Checking that wrong answers are detected. Running 'test 1'...`, async function () {
|
|
this.score = 1;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["test 1", "NOK"];
|
|
const expected = /incorrect/img;
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[1] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`7: Checking that right answers are detected. Running 'play'...`, async function () {
|
|
this.score = 1;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["play", "OK"];
|
|
const expected = /correct/img;
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[1] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`8: Checking that answers are correctly scored. Running 'play'...`, async function () {
|
|
this.score = 1;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["play", "OK"];
|
|
const expected = /1/;
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[1] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
console.log(expected, "OUT", output);
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`9: Checking that wrong answers are detected. Running 'play'...`, async function () {
|
|
this.score = 2;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["play", "NOK"];
|
|
const expected = /incorrect/img;
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[1] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
it(`10: Checking that the wrong answer ends the game. Running 'play'...`, async function () {
|
|
this.score = 2;
|
|
if (error_critical) {
|
|
this.msg_err = error_critical;
|
|
should.not.exist(error_critical);
|
|
} else {
|
|
const input = ["play", "NOK"];
|
|
const expected = "fin";
|
|
let output = "";
|
|
let error_std = "";
|
|
const client = spawn("node", ["main.js"], {cwd: path_assignment});
|
|
client.on('error', function (data) {
|
|
error_std += data
|
|
});
|
|
client.stdin.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stdout.on('data', function (data) {
|
|
output += data
|
|
});
|
|
client.stderr.on('data', function (data) {
|
|
error_std += data
|
|
});
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[0] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
client.stdin.write(input[1] + "\n");
|
|
await timeout(T_WAIT * 1000);
|
|
if (client) {
|
|
client.kill();
|
|
}
|
|
this.msg_ok = `Found '${expected}' in ${path_assignment}`;
|
|
this.msg_err = `Couldn't find '${expected}' in ${path_assignment}\nError:${error_std}\nReceived:${output}`;
|
|
error_std.should.be.equal("");
|
|
Utils.search(expected, output).should.be.equal(true);
|
|
}
|
|
});
|
|
|
|
after("Restoring the original file", async function () {
|
|
[error_copy, path_ok] = await to(fs.move(path.join(path_assignment, 'quizzes.original.json'), path.join(path_assignment, 'quizzes.json'), {"overwrite": true}));
|
|
});
|
|
});
|