import * as should from 'should';
import { PythonShell } from '..';
import { sep, join } from 'path';
import { EOL as newline } from 'os';
import { chdir, cwd } from 'process';
describe('PythonShell', function () {
const pythonFolder = 'test/python';
PythonShell.defaultOptions = {
scriptPath: pythonFolder,
};
describe('#ctor(script, options)', function () {
it('should spawn a Python process', function (done) {
// spawning python might take a while for the first time
// after this python should be in memory and not need extra time for startup
this.timeout(3000);
let pyshell = new PythonShell('exit-code.py');
pyshell.command.should.eql([
'test' + sep + 'python' + sep + 'exit-code.py',
]);
pyshell.terminated.should.be.false;
pyshell.end(function (err) {
if (err) return done(err);
pyshell.terminated.should.be.true;
done();
});
});
it('should spawn a Python process even if scriptPath option is not specified', function (done) {
let originalDirectory = cwd();
PythonShell.defaultOptions = {};
chdir(join(__dirname, 'python'));
let pyshell = new PythonShell('exit-code.py');
pyshell.command.should.eql(['exit-code.py']);
pyshell.terminated.should.be.false;
pyshell.end(function (err) {
if (err) return done(err);
pyshell.terminated.should.be.true;
done();
});
//reset values to intial status
PythonShell.defaultOptions = {
scriptPath: pythonFolder,
};
chdir(originalDirectory);
});
// executing python-shell with a absolute path is tested in runString suite
it('should spawn a Python process with options', function (done) {
let pyshell = new PythonShell('exit-code.py', {
pythonOptions: ['-u'],
});
pyshell.command.should.eql([
'-u',
'test' + sep + 'python' + sep + 'exit-code.py',
]);
pyshell.end(done);
});
it('should fail to spawn python with bad path', function (done) {
let pyshell = new PythonShell('exit-code.py', {
pythonPath: 'foeisjofseij',
});
pyshell.on('error', (err) => {
err.code.should.eql('ENOENT');
done();
});
});
it('should spawn a Python process with script arguments', function (done) {
let pyshell = new PythonShell('echo_args.py', {
args: ['hello', 'world'],
});
pyshell.command.should.eql([
'test' + sep + 'python' + sep + 'echo_args.py',
'hello',
'world',
]);
pyshell.end(done);
});
});
describe('#checkSyntax(code:string)', function () {
// note checkSyntax is a wrapper around checkSyntaxFile
// so this tests checkSyntaxFile as well
it('should check syntax', function (done) {
PythonShell.checkSyntax('x=1').then(() => {
done();
});
});
it('should invalidate bad syntax', function (done) {
PythonShell.checkSyntax('x=').catch(() => {
done();
});
});
});
// #158 these tests are failing on appveyor windows node 8/10 python 2/3
// but they work locally on my windows machine .....
// these methods are not that important so just commenting out tests untill someone fixes them
// describe("#getVersion", function(){
// it('should return a string', function(done){
// PythonShell.getVersion().then((out)=>{
// const version = out.stdout
// version.should.be.a.String();
// version.length.should.be.greaterThan(0)
// done()
// })
// })
// })
// describe("#getVersionSync", function(){
// it('should return a string', function(){
// const version = PythonShell.getVersionSync()
// version.should.be.a.String();
// version.length.should.be.greaterThan(0)
// })
// })
describe('#runString(script, options)', function () {
before(() => {
PythonShell.defaultOptions = {};
});
it('should be able to execute a string of python code', function (done) {
PythonShell.runString('print("hello");print("world")', null).then(
(results) => {
results.should.be.an.Array().and.have.lengthOf(2);
results.should.eql(['hello', 'world']);
done();
},
);
});
it('should be able to execute a string of python code using promises', async function () {
let results = await PythonShell.runString(
'print("hello");print("world")',
);
results.should.be.an.Array().and.have.lengthOf(2);
results.should.eql(['hello', 'world']);
});
it('should be able to execute a string of python code async', async function () {
let results = await PythonShell.runString(
'print("hello");print("world")',
);
results.should.be.an.Array().and.have.lengthOf(2);
results.should.eql(['hello', 'world']);
});
after(() => {
PythonShell.defaultOptions = {
// reset to match initial value
scriptPath: pythonFolder,
};
});
});
describe('#run(script, options)', function () {
it('should run the script and return output data using callbacks', function (done) {
PythonShell.run('echo_args.py', {
args: ['hello', 'world'],
}).then((results) => {
results.should.be.an.Array().and.have.lengthOf(2);
results.should.eql(['hello', 'world']);
done();
});
});
it('should run the script and return output data async', async function () {
let results = await PythonShell.run('echo_args.py', {
args: ['hello', 'world'],
});
results.should.be.an.Array().and.have.lengthOf(2);
results.should.eql(['hello', 'world']);
});
it('should try to run the script and fail appropriately', function (done) {
PythonShell.run('unknown_script.py', null).catch((err) => {
err.should.be.an.Error;
err.exitCode.should.be.exactly(2);
done();
});
});
it('should try to run the script and fail appropriately - async', async function () {
try {
let results = await PythonShell.run('unknown_script.py');
throw new Error(
`should not get here because the script should fail` + results,
);
} catch (err) {
err.should.be.an.Error;
err.exitCode.should.be.exactly(2);
}
});
it('should include both output and error', function (done) {
PythonShell.run('echo_hi_then_error.py', null)
.then((results) => {
done('Error: This promise should never successfully resolve');
})
.catch((err) => {
err.logs.should.eql(['hi']);
err.should.be.an.Error;
done();
});
});
it('should run the script and fail with an extended stack trace', function (done) {
PythonShell.run('error.py', null).catch((err) => {
err.should.be.an.Error;
err.exitCode.should.be.exactly(1);
err.stack.should.containEql('----- Python Traceback -----');
done();
});
});
it('should run the script and fail with an extended stack trace even when mode is binary', function (done) {
PythonShell.run('error.py', { mode: 'binary' }).catch((err) => {
err.should.be.an.Error;
err.exitCode.should.be.exactly(1);
err.stack.should.containEql('----- Python Traceback -----');
done();
});
});
it('should run multiple scripts and fail with an extended stack trace for each of them', function (done) {
let numberOfTimesToRun = 5;
for (let i = 0; i < numberOfTimesToRun; i++) {
runSingleErrorScript(end);
}
let count = 0;
function end() {
count++;
if (count === numberOfTimesToRun) {
done();
}
}
function runSingleErrorScript(callback) {
PythonShell.run('error.py', null).catch((err) => {
err.should.be.an.Error;
err.exitCode.should.be.exactly(1);
err.stack.should.containEql('----- Python Traceback -----');
callback();
});
}
});
it('should run multiple scripts and return output data for each of them', function (done) {
let numberOfTimesToRun = 5;
for (let i = 0; i < numberOfTimesToRun; i++) {
runSingleScript(end);
}
let count = 0;
function end() {
count++;
if (count === numberOfTimesToRun) {
done();
}
}
function runSingleScript(callback) {
PythonShell.run('echo_args.py', {
args: ['hello', 'world'],
}).then((results) => {
results.should.be.an.Array().and.have.lengthOf(2);
results.should.eql(['hello', 'world']);
callback();
});
}
});
it('should be able to run modules', function (done) {
PythonShell.defaultOptions = {};
PythonShell.run('-m', {
args: ['timeit', '-n 1', `'x=5'`],
}).then((results) => {
PythonShell.defaultOptions = {
// reset to match initial value
scriptPath: pythonFolder,
};
results.should.be.an.Array();
results[0].should.be.an.String();
results[0].slice(0, 6).should.eql('1 loop');
done();
});
});
after(() => {
// should be able to run modules test should theoretically reset this
// but we have this to in case something goes horribly wrong with the test
PythonShell.defaultOptions = {
// reset to match initial value
scriptPath: pythonFolder,
};
});
it('should run PythonShell normally without access to std streams', async function () {
var pyshell = await PythonShell.run('exit-code.py', {
// 3 different ways of assigning values to the std streams in child_process.spawn()
// * ignore - pipe to /dev/null
// * inherit - inherit fd from parent process;
// * process.stderr - pass output directly to that stream.
stdio: ['ignore', 'inherit', process.stderr],
// @ts-expect-error python-shell technically allows a non-array arg,
// although the user shouldn't be doing this. We are just testing for
// increased code coverage
args: '0',
});
should(pyshell).be.eql([]);
});
});
describe('.send(message)', function () {
it('should send string messages when mode is "text"', function (done) {
let pyshell = new PythonShell('echo_text.py', {
mode: 'text',
});
let output = '';
pyshell.stdout.on('data', function (data) {
output += '' + data;
});
pyshell
.send('hello')
.send('world')
.end(function (err) {
if (err) return done(err);
output.should.be.exactly('hello' + newline + 'world' + newline);
done();
});
});
it('should send JSON messages when mode is "json"', function (done) {
let pyshell = new PythonShell('echo_json.py', {
mode: 'json',
});
let output = '';
pyshell.stdout.on('data', function (data) {
output += '' + data;
});
pyshell
.send({ a: 'b' })
.send(null)
.send([1, 2, 3])
.end(function (err) {
if (err) return done(err);
output.should.be.exactly(
'{"a": "b"}' + newline + 'null' + newline + '[1, 2, 3]' + newline,
);
done();
});
});
it('should use a custom formatter', function (done) {
let pyshell = new PythonShell('echo_text.py', {
formatter: function (message) {
return message.toUpperCase();
},
});
let output = '';
pyshell.stdout.on('data', function (data) {
output += '' + data;
});
pyshell
.send('hello')
.send('world')
.end(function (err) {
if (err) return done(err);
output.should.be.exactly('HELLO' + newline + 'WORLD' + newline + '');
done();
});
});
it('should write as-is when mode is "binary"', function (done) {
let pyshell = new PythonShell('echo_binary.py', {
mode: 'binary',
});
let output = '';
pyshell.stdout.on('data', function (data) {
output += '' + data;
});
pyshell.send(Buffer.from('i am not a string')).end(function (err) {
if (err) return done(err);
output.should.be.exactly('i am not a string');
done();
});
});
});
describe('stdout', function () {
it('should emit messages as strings when mode is "text"', function (done) {
let pyshell = new PythonShell('echo_text.py', {
mode: 'text',
});
let count = 0;
pyshell
.on('message', function (message) {
count === 0 && message.should.be.exactly('hello');
count === 1 && message.should.be.exactly('world');
count++;
})
.on('close', function () {
count.should.be.exactly(2);
})
.send('hello')
.send('world')
.end(done);
});
it('should emit messages as JSON when mode is "json"', function (done) {
let pyshell = new PythonShell('echo_json.py', {
mode: 'json',
});
let count = 0;
pyshell.send({ a: 'b' }).send(null).send([1, 2, 3, 4, 5]);
pyshell
.on('message', function (message) {
count === 0 && message.should.eql({ a: 'b' });
count === 1 && should(message).eql(null);
count === 2 && message.should.eql([1, 2, 3, 4, 5]);
count++;
})
.on('close', function () {
count.should.be.exactly(3);
})
.end(done);
});
it('should properly buffer partial messages', function (done) {
// echo_text_with_newline_control echoes text with $'s replaced with newlines
let pyshell = new PythonShell('echo_text_with_newline_control.py', {
mode: 'text',
});
pyshell
.on('message', (message) => {
console.log(message);
let messageObject = JSON.parse(message);
messageObject.should.be.an.Object;
messageObject.should.eql({ a: true });
})
.send('{"a"')
.send(':')
.send('true}${')
.send('"a":true}$')
.end(() => {
done();
});
});
it('should not be invoked when mode is "binary"', function (done) {
let pyshell = new PythonShell('echo_args.py', {
args: ['hello', 'world'],
mode: 'binary',
});
pyshell.on('message', () => {
done('should not emit messages in binary mode');
return undefined;
});
pyshell.end(done);
});
it('should use a custom parser function', function (done) {
let pyshell = new PythonShell('echo_text.py', {
mode: 'text',
parser: function (message) {
return message.toUpperCase();
},
});
let count = 0;
pyshell
.on('message', function (message) {
count === 0 && message.should.be.exactly('HELLO');
count === 1 && message.should.be.exactly('WORLD!');
count++;
})
.on('close', function () {
count.should.be.exactly(2);
})
.send('hello')
.send('world!')
.end(done);
});
});
describe('stderr', function () {
it('should emit stderr logs as strings when mode is "text"', function (done) {
let pyshell = new PythonShell('stderrLogging.py', {
mode: 'text',
});
let count = 0;
pyshell
.on('stderr', function (stderr) {
count === 0 &&
stderr.should.be.exactly(
'INFO:root:Jackdaws love my big sphinx of quartz.',
);
count === 1 &&
stderr.should.be.exactly(
'DEBUG:log1:Quick zephyrs blow, vexing daft Jim.',
);
count++;
})
.on('close', function () {
count.should.be.exactly(5);
})
.send('hello')
.send('world')
.end(done);
});
it('should not be invoked when mode is "binary"', function (done) {
let pyshell = new PythonShell('stderrLogging.py', {
stderrParser: 'binary',
});
pyshell.on('stderr', () => {
done('should not emit stderr in binary mode');
});
pyshell.end(() => {
done();
});
});
it('should use a custom parser function', function (done) {
let pyshell = new PythonShell('stderrLogging.py', {
mode: 'text',
stderrParser: function (stderr) {
return stderr.toUpperCase();
},
});
let count = 0;
pyshell
.on('stderr', function (stderr) {
count === 0 &&
stderr.should.be.exactly(
'INFO:ROOT:JACKDAWS LOVE MY BIG SPHINX OF QUARTZ.',
);
count === 1 &&
stderr.should.be.exactly(
'DEBUG:LOG1:QUICK ZEPHYRS BLOW, VEXING DAFT JIM.',
);
count++;
})
.on('close', function () {
count.should.be.exactly(5);
})
.send('hello')
.send('world!')
.end(done);
});
});
describe('.end(callback)', function () {
it('should end normally when exit code is zero', function (done) {
let pyshell = new PythonShell('exit-code.py');
pyshell.end(function (err, code, signal) {
if (err) return done(err);
code.should.be.exactly(0);
done();
});
});
it('should emit error if exit code is not zero', function (done) {
let pyshell = new PythonShell('exit-code.py', {
args: ['3'],
});
pyshell.on('pythonError', function (err) {
err.should.have.properties({
message: 'process exited with code 3',
exitCode: 3,
});
done();
});
});
it('should emit error when the program exits because of an unhandled exception', function (done) {
let pyshell = new PythonShell('error.py');
pyshell.on('pythonError', function (err) {
err.message.should.be.equalOneOf(
'ZeroDivisionError: integer division or modulo by zero',
'ZeroDivisionError: division by zero',
);
err.should.have.property('traceback');
err.traceback.should.containEql('Traceback (most recent call last)');
done();
});
});
it('should NOT emit error when logging is written to stderr', function (done) {
let pyshell = new PythonShell('stderrLogging.py');
pyshell.on('pythonError', function (err) {
done(new Error('an error should not have been raised'));
});
pyshell.on('close', function () {
done();
});
});
});
describe('.parseError(data)', function () {
it('should extend error with context properties', function (done) {
let pyshell = new PythonShell('exit-code.py', {
args: ['1'],
});
pyshell.on('pythonError', function (err) {
err.should.have.properties(['exitCode', 'script', 'options', 'args']);
done();
});
});
it('should extend err.stack with traceback', function (done) {
let pyshell = new PythonShell('error.py');
pyshell.on('pythonError', function (err) {
err.stack.should.containEql('----- Python Traceback -----');
err.stack.should.containEql(
'test' + sep + 'python' + sep + 'error.py", line 4',
);
err.stack.should.containEql(
'test' + sep + 'python' + sep + 'error.py", line 6',
);
done();
});
});
it('should work in json mode', function (done) {
let pyshell = new PythonShell('error.py', { mode: 'json' });
pyshell.on('pythonError', function (err) {
err.stack.should.containEql('----- Python Traceback -----');
err.stack.should.containEql(
'test' + sep + 'python' + sep + 'error.py", line 4',
);
err.stack.should.containEql(
'test' + sep + 'python' + sep + 'error.py", line 6',
);
done();
});
});
});
describe('.kill()', function () {
it('set terminated to correct value', function (done) {
let pyshell = new PythonShell('infinite_loop.py');
pyshell.kill();
pyshell.terminated.should.be.true;
done();
});
it('run the end callback if specified', function (done) {
let pyshell = new PythonShell('infinite_loop.py');
pyshell.end(() => {
done();
});
pyshell.kill();
});
it('kill with correct signal', function (done) {
let pyshell = new PythonShell('infinite_loop.py');
pyshell.terminated.should.be.false;
pyshell.kill('SIGKILL');
pyshell.terminated.should.be.true;
setTimeout(() => {
pyshell.exitSignal.should.be.exactly('SIGKILL');
done();
}, 500);
});
});
});