assert.throws(
// eslint-disable-next-line no-new
() => { new GitStatusChecker(true); },
TypeError,
/\boptions\b/,
);
assert.throws(
// eslint-disable-next-line no-new
() => { new GitStatusChecker({ in: new stream.Writable() }); },
TypeError,
/\boptions.in\b/,
);
assert.throws(
// eslint-disable-next-line no-new
() => { new GitStatusChecker({ out: new stream.Readable() }); },
TypeError,
/\boptions.out\b/,
);
assert.throws(
// eslint-disable-next-line no-new
() => { new GitStatusChecker({ err: new stream.Readable() }); },
TypeError,
/\boptions.err\b/,
);
const result = GitStatusChecker.checkSlugFormat(slug);
assert.strictEqual(result, slug);
const result = GitStatusChecker.checkSlugFormat(slug);
assert.strictEqual(result, slug);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
assert.throws(
() => { GitStatusChecker.checkSlugFormat(slug); },
InvalidSlugError,
);
const checker = new GitStatusChecker();
return checker.resolveHash('HEAD').then((hash) => {
assert.match(hash, /^[a-fA-F0-9]{40}$/);
headHash = hash;
});
const checker = new GitStatusChecker();
return checker.resolveHash(headHash).then((hash) => {
assert.strictEqual(hash, headHash);
});
const checker = new GitStatusChecker();
return checker.resolveHash('notabranch').then(
sinon.mock().never(),
(err) => {
assert(err);
},
);
const checker = new GitStatusChecker();
const testSlug = 'foo/bar';
return checker.storeSlug(testSlug).then((slug) => {
assert.strictEqual(slug, testSlug);
return git('config', '--get', GitStatusChecker.SLUG_CONFIG_NAME)
.then((result) => {
const configSlug = result[0].trimEnd();
assert.strictEqual(configSlug, testSlug);
});
});
const checker = new GitStatusChecker();
const testSlug = 'foobar';
return checker.storeSlug(testSlug).then(
sinon.mock().never(),
(errStore) => {
assert.instanceOf(errStore, InvalidSlugError);
return git('config', '--get', GitStatusChecker.SLUG_CONFIG_NAME)
.then(
(configSlug) => {
assert.fail(configSlug, null, 'slug should not be stored');
},
(errGit) => (errGit.code === 1 ? null : Promise.reject(errGit)),
);
},
);
const checker = new GitStatusChecker();
const testSlug = 'foo/bar';
return checker.tryStoreSlug(testSlug).then((slug) => {
assert.strictEqual(slug, testSlug);
return git('config', '--get', GitStatusChecker.SLUG_CONFIG_NAME)
.then((result) => {
const configSlug = result[0].trimEnd();
assert.strictEqual(configSlug, testSlug);
});
});
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const checker = new GitStatusChecker({
out: outStream,
err: errStream,
});
const testSlug = 'foobar';
return checker.tryStoreSlug(testSlug).then((slug) => {
assert.strictEqual(slug, testSlug);
assert.strictEqual(outStream.read(), null);
assert.match(String(errStream.read()), /error/i);
return git('config', '--get', GitStatusChecker.SLUG_CONFIG_NAME)
.then(
(configSlug) => {
assert.fail(configSlug, null, 'slug should not be stored');
},
(errGit) => (errGit.code === 1 ? null : Promise.reject(errGit)),
);
});
const inStream = new stream.PassThrough();
const outStream = new stream.PassThrough({ encoding: 'utf8' });
const errStream = new stream.PassThrough({ encoding: 'utf8' });
const checker = new GitStatusChecker({
in: inStream,
out: outStream,
err: errStream,
});
const testSlug = 'foo/bar';
const confirmP = checker.confirmSlug(testSlug);
return read(errStream)
.then((promptMsg) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg, /correct/i);
assert.include(promptMsg, testSlug);
inStream.write('y\n');
return confirmP;
})
.then((slug) => {
assert.strictEqual(slug, testSlug);
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
});
const inStream = new stream.PassThrough();
const outStream = new stream.PassThrough({ encoding: 'utf8' });
const errStream = new stream.PassThrough({ encoding: 'utf8' });
const checker = new GitStatusChecker({
in: inStream,
out: outStream,
err: errStream,
});
const testSlug1 = 'foo/bar';
const testSlug2 = 'baz/quux';
const confirmP = checker.confirmSlug(testSlug1);
return read(errStream)
.then((promptMsg1) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg1, /correct/i);
assert.include(promptMsg1, testSlug1);
inStream.write('n\n');
return read(errStream);
})
.then((promptMsg2) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg2, /repository/i);
assert.include(promptMsg2, testSlug1);
inStream.write(`${testSlug2}\n`);
return confirmP;
}).then((slug) => {
assert.strictEqual(slug, testSlug2);
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
});
const inStream = new stream.PassThrough();
const outStream = new stream.PassThrough({ encoding: 'utf8' });
const errStream = new stream.PassThrough({ encoding: 'utf8' });
const checker = new GitStatusChecker({
in: inStream,
out: outStream,
err: errStream,
});
const testSlug1 = 'foo/bar';
const testSlug2 = 'fred';
const testSlug3 = 'baz/quux';
const confirmP = checker.confirmSlug(testSlug1);
return read(errStream)
.then((promptMsg1) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg1, /correct/i);
assert.include(promptMsg1, testSlug1);
inStream.write('n\n');
return read(errStream);
})
.then((promptMsg2) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg2, /repository/i);
assert.include(promptMsg2, testSlug1);
inStream.write(`${testSlug2}\n`);
return read(errStream);
})
.then((errorMsg) => {
assert.strictEqual(outStream.read(), null);
assert.match(errorMsg, /invalid/i);
// Prompt may be part of error message or not
if (errorMsg.includes(testSlug1)) {
return errorMsg;
}
return read(errStream);
})
.then((promptMsg3) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg3, /repository/i);
assert.include(promptMsg3, testSlug1);
inStream.write(`${testSlug3}\n`);
return confirmP;
})
.then((slug) => {
assert.strictEqual(slug, testSlug3);
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
});
const inStream = new stream.PassThrough();
const outStream = new stream.PassThrough({ encoding: 'utf8' });
const errStream = new stream.PassThrough({ encoding: 'utf8' });
const checker = new GitStatusChecker({
in: inStream,
out: outStream,
err: errStream,
});
const testSlug = 'foo/bar';
const confirmP = checker.confirmSlug(testSlug)
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'EOFError');
// Same message as travis.rb
assert.strictEqual(err.message, 'The input stream is exhausted.');
// Doesn't print error message itself, but calling code will
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
},
);
const promptP = read(errStream)
.then((promptMsg) => {
assert.strictEqual(outStream.read(), null);
assert.match(promptMsg, /correct/i);
assert.include(promptMsg, testSlug);
// End without newline (e.g. user hit ^D before return)
inStream.end('y');
});
return Promise.all([confirmP, promptP]);
const checker = new GitStatusChecker();
return git('checkout', 'master')
.then(() => checker.detectBranch())
.then((branch) => {
assert.strictEqual(branch, 'master');
});
const checker = new GitStatusChecker();
return git('checkout', 'branch1')
.then(() => checker.detectBranch())
.then((branch) => {
assert.strictEqual(branch, 'branch1');
});
const checker = new GitStatusChecker();
return git('checkout', 'HEAD^')
.then(() => checker.detectBranch())
.then(
sinon.mock().never(),
(err) => {
assert.match(err.message, /branch/i);
},
);
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', branchName)
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, remoteSlug);
});
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', branchName)
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, remoteSlug);
});
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', branchName)
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, remoteSlug);
});
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', 'master')
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, REMOTE_SLUGS.origin);
});
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', 'HEAD^')
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, REMOTE_SLUGS.origin);
});
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', 'branchnourl')
.then(() => checker.detectSlug())
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'SlugDetectionError');
assert.match(err.message, /remote/i);
},
);
const checker = new GitStatusChecker({
out: new stream.PassThrough(),
err: new stream.PassThrough(),
});
return git('checkout', 'branchnotslug')
.then(() => checker.detectSlug())
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'SlugDetectionError');
assert.match(err.message, /URL/i);
},
);
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const checker = new GitStatusChecker({
interactive: true,
out: outStream,
err: errStream,
});
const testSlug = 'prompt/slug';
const mock = sinon.mock(checker);
mock.expects('confirmSlug')
.once().withExactArgs(REMOTE_SLUGS.origin).returns(testSlug);
return git('checkout', 'master')
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, testSlug);
// Only output is from prompt (which is mocked)
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
});
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough({ encoding: 'utf8' });
const checker = new GitStatusChecker({
out: outStream,
err: errStream,
});
const mock = sinon.mock(checker);
mock.expects('confirmSlug').never();
return git('checkout', 'master')
.then(() => checker.detectSlug())
.then((slug) => {
assert.strictEqual(slug, REMOTE_SLUGS.origin);
assert.strictEqual(outStream.read(), null);
// From travis.rb
const detectMsg = `detected repository as ${slug}\n`;
assert.strictEqual(errStream.read(), detectMsg);
});
const checker = new GitStatusChecker();
const testSlug = 'foo/bar';
return checker.storeSlug(testSlug)
.then(() => checker.loadSlug().then((slug) => {
assert.strictEqual(slug, testSlug);
}));
const checker = new GitStatusChecker();
return checker.loadSlug().then((slug) => {
assert.strictEqual(slug, null);
});
const checker = new GitStatusChecker();
const testSlug = 'foo/bar';
const mock = sinon.mock(checker);
mock.expects('loadSlug')
.once().withExactArgs().returns(Promise.resolve(testSlug));
mock.expects('detectSlug').never();
return checker.findSlug().then((slug) => {
assert.strictEqual(slug, testSlug);
});
const checker = new GitStatusChecker();
const testSlug = 'foo/bar';
const mock = sinon.mock(checker);
mock.expects('loadSlug')
.once().withExactArgs().returns(Promise.resolve(null));
mock.expects('detectSlug')
.once().withExactArgs().returns(Promise.resolve(testSlug));
return checker.findSlug().then((slug) => {
assert.strictEqual(slug, testSlug);
});
const testSlug = 'foo/bar';
const testBranch = 'branch1';
const testOpts = { slug: testSlug, branch: testBranch };
const testResult = apiResponses.branch(testOpts);
apiMock.expects('branch')
.once().withExactArgs(match(testOpts))
.returns(testResult);
apiMock.expects('build').never();
apiMock.expects('repo').never();
const options = {
apiEndpoint: apiUrl,
branch: testBranch,
repo: testSlug,
};
return travisStatus(options).then((result) => {
assert.deepEqual(result, testResult);
apiMock.verify();
assert.strictEqual(connCount, 1);
});
const testSlug = 'foo/bar';
const testOpts = { slug: testSlug };
const testResult = apiResponses.repo(testOpts);
apiMock.expects('branch').never();
apiMock.expects('build').never();
apiMock.expects('repo')
.once().withExactArgs(match(testOpts))
.returns(testResult);
const options = {
apiEndpoint: apiUrl,
repo: testSlug,
};
return travisStatus(options).then((result) => {
assert.deepEqual(result, testResult);
apiMock.verify();
assert.strictEqual(connCount, 1);
});
const testSlug = 'foo/bar';
const testCommit = '4e2c26acca22601fb54da35485faff7c303084eb';
const testBuildId = 123456;
const testOpts = {
buildId: testBuildId,
sha: testCommit,
slug: testSlug,
};
const testBuild = apiResponses.build(testOpts);
const testRepo = apiResponses.repo(testOpts);
apiMock.expects('branch').never();
apiMock.expects('build')
.once().withExactArgs(match({ buildId: String(testBuildId) }))
.returns(testBuild);
apiMock.expects('repo')
.once().withExactArgs(match({ slug: testSlug }))
.returns(testRepo);
const options = {
apiEndpoint: apiUrl,
commit: testCommit,
repo: testSlug,
};
return travisStatus(options).then((result) => {
assert.deepEqual(result, { ...testRepo, ...testBuild });
apiMock.verify();
// If Agent doesn't have .destroy(), travisStatus can't do keep-alive.
// TODO: Check that travisStatusCmd does.
if (typeof new http.Agent().destroy === 'function') {
assert.strictEqual(connCount, 1);
}
});
const testSlug = 'foo/bar';
const pendingResult =
apiResponses.repo({ slug: testSlug, state: 'started' });
const passedResult = apiResponses.repo({ slug: testSlug });
apiMock.expects('branch').never();
apiMock.expects('build').never();
const expect = apiMock.expects('repo')
.atLeast(2)
.withExactArgs(match({ slug: testSlug }));
// We don't want to over-specify the timeout/backoff values.
// So extra calls are added to ensure it is long enough to exceed the
// keep-alive timeout.
for (let i = 0; i < 5; i += 1) {
expect.onCall(i).returns(pendingResult);
}
expect.onCall(5).returns(passedResult);
const options = {
apiEndpoint: apiUrl,
repo: testSlug,
wait: Infinity,
};
const promise = travisStatus(options).then((result) => {
assert.deepEqual(result, passedResult);
apiMock.verify();
});
return promise;
assert.throws(
// eslint-disable-next-line no-new
() => { new TravisStatusChecker(true); },
TypeError,
/\boptions\b/,
);
TravisMock = sinon.mock()
.once()
.withExactArgs(
match({ pro: true }),
);
// eslint-disable-next-line no-new
new TravisStatusChecker({
apiEndpoint: TravisStatusChecker.PRO_URI,
});
TravisMock.verify();
const testToken = '123456';
travisHttpMock = new TravisStatusHttp();
const mock = sinon.mock(travisHttpMock);
mock.expects('setAccessToken').once().withExactArgs(testToken);
// eslint-disable-next-line no-new
new TravisStatusChecker({
token: testToken,
});
mock.verify();
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise = checker[methodName](...args)
.then((response) => {
assert.deepEqual(response, passedResponse);
});
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, passedResponse);
});
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.twice()
.withArgs(match(/GET/i), match(travisUrlRe));
travisRequestMock.onFirstCall().yields(null, pendingResponse);
travisRequestMock.onSecondCall().yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, passedResponse);
});
for (let i = 1; i < 11; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.atLeast(1)
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, pendingResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, pendingResponse);
});
for (let i = 1; i < 11; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
const errTest = new Error('Test API error');
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(errTest);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 30000 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err, errTest);
},
);
travisRequestMock.verify();
return promise;
const errTest = new Error('Test API error');
travisRequestMock = sinon.mock()
.twice()
.withArgs(match(/GET/i), match(travisUrlRe));
travisRequestMock.onFirstCall().yields(null, pendingResponse);
travisRequestMock.onSecondCall().yields(errTest);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 30000 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err, errTest);
},
);
for (let i = 1; i < 31; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock().never();
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 'hello' }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'TypeError');
assert.match(err.message, /\bwait\b/);
},
);
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock().never();
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: -5 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'RangeError');
assert.match(err.message, /\bwait\b/);
},
);
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise = checker[methodName](...args)
.then((response) => {
assert.deepEqual(response, passedResponse);
});
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, passedResponse);
});
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.twice()
.withArgs(match(/GET/i), match(travisUrlRe));
travisRequestMock.onFirstCall().yields(null, pendingResponse);
travisRequestMock.onSecondCall().yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, passedResponse);
});
for (let i = 1; i < 11; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.atLeast(1)
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, pendingResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, pendingResponse);
});
for (let i = 1; i < 11; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
const errTest = new Error('Test API error');
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(errTest);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 30000 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err, errTest);
},
);
travisRequestMock.verify();
return promise;
const errTest = new Error('Test API error');
travisRequestMock = sinon.mock()
.twice()
.withArgs(match(/GET/i), match(travisUrlRe));
travisRequestMock.onFirstCall().yields(null, pendingResponse);
travisRequestMock.onSecondCall().yields(errTest);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 30000 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err, errTest);
},
);
for (let i = 1; i < 31; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock().never();
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 'hello' }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'TypeError');
assert.match(err.message, /\bwait\b/);
},
);
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock().never();
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: -5 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'RangeError');
assert.match(err.message, /\bwait\b/);
},
);
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise = checker[methodName](...args)
.then((response) => {
assert.deepEqual(response, passedResponse);
});
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, passedResponse);
});
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.twice()
.withArgs(match(/GET/i), match(travisUrlRe));
travisRequestMock.onFirstCall().yields(null, pendingResponse);
travisRequestMock.onSecondCall().yields(null, passedResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, passedResponse);
});
for (let i = 1; i < 11; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock()
.atLeast(1)
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(null, pendingResponse);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 10000 }))
.then((response) => {
assert.deepEqual(response, pendingResponse);
});
for (let i = 1; i < 11; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
const errTest = new Error('Test API error');
travisRequestMock = sinon.mock()
.once()
.withArgs(match(/GET/i), match(travisUrlRe))
.yields(errTest);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 30000 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err, errTest);
},
);
travisRequestMock.verify();
return promise;
const errTest = new Error('Test API error');
travisRequestMock = sinon.mock()
.twice()
.withArgs(match(/GET/i), match(travisUrlRe));
travisRequestMock.onFirstCall().yields(null, pendingResponse);
travisRequestMock.onSecondCall().yields(errTest);
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 30000 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err, errTest);
},
);
for (let i = 1; i < 31; i += 1) {
clock.tick(1000);
}
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock().never();
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: 'hello' }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'TypeError');
assert.match(err.message, /\bwait\b/);
},
);
travisRequestMock.verify();
return promise;
travisRequestMock = sinon.mock().never();
const checker = new TravisStatusChecker();
const promise =
checker[methodName](...args.concat({ wait: -5 }))
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'RangeError');
assert.match(err.message, /\bwait\b/);
},
);
travisRequestMock.verify();
return promise;
travisStatus = sinon.mock()
.once()
.withArgs(
match.any,
match.func,
);
travisStatusCmd([], sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
match.any,
match.func,
);
const result = travisStatusCmd(RUNTIME_ARGS, sinon.mock().never());
travisStatus.verify();
assert.strictEqual(result, undefined);
travisStatus = sinon.mock()
.once()
.withArgs(
match({ interactive: true }),
match.func,
);
const outStream = new stream.PassThrough();
outStream.isTTY = true;
const options = {
out: outStream,
err: new stream.PassThrough(),
};
travisStatusCmd(RUNTIME_ARGS, options, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
travisStatus = sinon.mock()
.once()
.withArgs(
expectObj,
match.func,
);
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, sinon.mock().never());
travisStatus.verify();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
assert.match(String(errStream.read()), expectErrMsg);
done();
});
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
assert.match(String(errStream.read()), expectErrMsg);
done();
});
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
assert.match(String(errStream.read()), expectErrMsg);
done();
});
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const allArgs = RUNTIME_ARGS.concat(args);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, expectCode);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(arg);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state: 'failed' }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(arg);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
assert.strictEqual(outStream.read(), null);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state: 'failed' }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const buildNum = 500;
const state = 'passed';
const allArgs = RUNTIME_ARGS.concat(isBranch ? ['--branch'] : []);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
assert.strictEqual(
String(outStream.read()),
// We are strict about this format since other programs may use it
`build #${buildNum} ${state}\n`,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
isBranch
? apiResponses.branch({ number: buildNum, state })
: apiResponses.repo({ number: buildNum, state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const buildNum = 500;
const state = 'passed';
const allArgs = RUNTIME_ARGS.concat(isBranch ? ['--branch'] : []);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
assert.strictEqual(
String(outStream.read()),
// We are strict about this format since other programs may use it
`build #${buildNum} ${state}\n`,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
isBranch
? apiResponses.branch({ number: buildNum, state })
: apiResponses.repo({ number: buildNum, state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.strictEqual(code, 0);
const outString = String(outStream.read());
assert.include(
outString,
ansiStyles[color].open + state + ansiStyles[color].close,
);
assert.strictEqual(errStream.read(), null);
done();
});
travisStatus.yield(
null,
apiResponses.repo({ state }),
);
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const errMsg = 'super duper test error';
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
const errString = String(errStream.read());
assert.include(errString, ansiStyles.red.open);
assert.include(errString, errMsg);
done();
});
travisStatus.yield(new Error(errMsg));
travisStatusCmd({}, (err) => {
assert.instanceOf(err, TypeError);
assert.match(err.message, /\bargs\b/);
done();
});
travisStatusCmd(['node'], (err) => {
assert.instanceOf(err, RangeError);
assert.match(err.message, /\bargs\b/);
done();
});
assert.throws(
() => { travisStatusCmd(RUNTIME_ARGS, {}, true); },
TypeError,
/\bcallback\b/,
);
travisStatusCmd([], true, (err) => {
assert.instanceOf(err, TypeError);
assert.match(err.message, /\boptions\b/);
done();
});
travisStatusCmd([], { in: new stream.Writable() }, (err) => {
assert.instanceOf(err, TypeError);
assert.match(err.message, /\boptions.in\b/);
done();
});
travisStatusCmd([], { out: new stream.Readable() }, (err) => {
assert.instanceOf(err, TypeError);
assert.match(err.message, /\boptions.out\b/);
done();
});
travisStatusCmd([], { err: new stream.Readable() }, (err) => {
assert.instanceOf(err, TypeError);
assert.match(err.message, /\boptions.err\b/);
done();
});
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const errMsg = 'super duper test error';
const allArgs = RUNTIME_ARGS.concat(['--interactive']);
travisStatusCmd(allArgs, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
const errString = String(errStream.read());
assert.include(errString, ansiStyles.red.open);
assert.include(errString, errMsg);
done();
});
travisStatus.yield(new Error(errMsg));
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
const errMsg = 'super duper test error';
travisStatusCmd(RUNTIME_ARGS, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
const errString = String(errStream.read());
assert(!hasAnsi(errString), 'string has color');
assert.include(errString, errMsg);
done();
});
travisStatus.yield(new Error(errMsg));
travisStatus = sinon.stub();
const outStream = new stream.PassThrough();
const errStream = new stream.PassThrough();
const options = {
out: outStream,
err: errStream,
};
travisStatusCmd(RUNTIME_ARGS, options, (err, code) => {
assert.ifError(err);
assert.isAtLeast(code, 1);
assert.strictEqual(outStream.read(), null);
assert.match(String(errStream.read()), /\brepo name\b.*-r/i);
done();
});
travisStatus.yield(new SlugDetectionError('oops'));
travisStatus = sinon.stub();
const result = travisStatusCmd(RUNTIME_ARGS);
assert(result instanceof Promise);
travisStatus = sinon.stub();
const options = {
out: new stream.PassThrough(),
err: new stream.PassThrough(),
};
const result = travisStatusCmd(RUNTIME_ARGS, options);
travisStatus.yield(
null,
apiResponses.repo(),
);
return result.then((code) => {
assert.strictEqual(code, 0);
});
travisStatus = sinon.stub();
const result = travisStatusCmd(RUNTIME_ARGS, true);
return result.then(
sinon.mock().never(),
(err) => { assert.instanceOf(err, TypeError); },
);
assert.throws(
// eslint-disable-next-line no-new
() => { new TravisStatusHttp(true); },
TypeError,
/\bendpoint\b/,
);
assert.throws(
// eslint-disable-next-line no-new
() => { new TravisStatusHttp(null, true); },
TypeError,
/\boptions\b/,
);
const status = new TravisStatusHttp();
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
Accept: match((accept) => {
const travisRE = /^application\/vnd\.travis-ci\.2\+json(?:,|$)/;
return travisRE.test(accept)
&& / application\/json(?:,|$)/.test(accept);
}, 'match Travis and JSON media types'),
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const testAccept = 'text/plain';
// Note: Testing lower case properly replaces upper
const status =
new TravisStatusHttp(null, { headers: { accept: testAccept } });
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
Accept: undefined,
accept: testAccept,
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const status = new TravisStatusHttp();
request = sinon.mock()
.once()
.withArgs(match({ gzip: true }));
status.request('GET', '/repos', () => {});
request.verify();
const uaVersionRE = new RegExp(`node-travis-status/${
packageJson.version.replace(/\./g, '\\.')}`);
const status = new TravisStatusHttp();
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
'User-Agent': match(uaVersionRE),
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const testUA = 'Test Agent';
// Note: Testing lower case properly replaces upper
const status =
new TravisStatusHttp(null, { headers: { 'user-agent': testUA } });
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
'User-Agent': undefined,
'user-agent': testUA,
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const testToken = '12345';
const status = new TravisStatusHttp();
status.setAccessToken(testToken);
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
Authorization: `token ${testToken}`,
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const testToken = '12345"67\\89';
const quotedToken = '"12345\\"67\\\\89"';
const status = new TravisStatusHttp();
status.setAccessToken(testToken);
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
Authorization: `token ${quotedToken}`,
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const testToken = '12345';
const status =
new TravisStatusHttp(null, { headers: { Authorization: 'foo' } });
status.setAccessToken(testToken);
request = sinon.mock()
.once()
.withArgs(match({
headers: match({
Authorization: `token ${testToken}`,
}),
}));
status.request('GET', '/repos', () => {});
request.verify();
const errTest = new Error('Test request error');
const status = new TravisStatusHttp();
request = sinon.mock().once().yields(errTest);
status.request('GET', '/repos', (err) => {
assert.strictEqual(err, errTest);
});
request.verify();
const status = new TravisStatusHttp();
const errProps = {
statusCode: 400,
statusMessage: 'Test Message',
headers: {
'Content-Type': 'application/json',
test: 'ok',
},
};
const testBody = { test: 'stuff' };
const testBodyStr = JSON.stringify(testBody);
const response = new http.IncomingMessage();
Object.assign(response, errProps);
request = sinon.mock().once().yields(null, response, testBodyStr);
status.request('GET', '/repos', (err) => {
assert.strictEqual(err.message, errProps.statusMessage);
assert.deepEqual(
{ ...err },
{ body: testBody, ...errProps },
);
});
request.verify();
const status = new TravisStatusHttp();
const errProps = {
statusCode: 200,
statusMessage: 'Test Message',
headers: {
'Content-Type': 'text/plain',
test: 'ok',
},
};
const testBody = 'Body?';
let testErr;
try { JSON.parse(testBody); } catch (errJson) { testErr = errJson; }
const response = new http.IncomingMessage();
Object.assign(response, errProps);
request = sinon.mock().once().yields(null, response, testBody);
status.request('GET', '/repos', (err) => {
assert.strictEqual(err.message, testErr.message);
assert.deepEqual(
{ ...err },
{ body: testBody, ...errProps },
);
});
request.verify();
const status = new TravisStatusHttp();
const errProps = {
statusCode: 400,
statusMessage: 'Test Message',
headers: {
'Content-Type': 'text/plain',
test: 'ok',
},
};
const testBody = 'Body?';
const response = new http.IncomingMessage();
Object.assign(response, errProps);
request = sinon.mock().once().yields(null, response, testBody);
status.request('GET', '/repos', (err) => {
assert.strictEqual(err.message, errProps.statusMessage);
assert.deepEqual(
{ ...err },
{ body: testBody, ...errProps },
);
});
request.verify();
const status = new TravisStatusHttp();
const errProps = {
statusCode: 200,
statusMessage: 'Test Message',
headers: {
'Content-Type': 'application/json',
test: 'ok',
},
};
const testBody = { prop: 'OK' };
const testBodyStr = JSON.stringify(testBody);
const response = new http.IncomingMessage();
Object.assign(response, errProps);
request = sinon.mock().once().yields(null, response, testBodyStr);
status.request('GET', '/repos', (err, body) => {
assert.deepEqual(body, testBody);
});
request.verify();
const testSlug = 'foo/bar';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('findSlug')
.once().withExactArgs().returns(Promise.resolve(testSlug));
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
return travisStatus().then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('findSlug')
.once().withExactArgs().returns(Promise.resolve(testSlug));
gitCheckerMock.expects('storeSlug')
.once().withExactArgs(testSlug).returns(Promise.resolve(testSlug));
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
return travisStatus({ interactive: true }).then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
return travisStatus({ repo: testSlug }).then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('storeSlug')
.once().withExactArgs(testSlug).returns(Promise.resolve(testSlug));
gitCheckerMock.expects('findSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
return travisStatus({ storeRepo: testSlug }).then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testSlug2 = 'baz/quux';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('storeSlug')
.once().withExactArgs(testSlug2).returns(Promise.resolve(testSlug2));
gitCheckerMock.expects('findSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
const options = { repo: testSlug, storeRepo: testSlug2 };
return travisStatus(options).then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testBranch = 'branch1';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('detectBranch').never();
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo').never();
travisCheckerMock.expects('getBranch')
.once().withArgs(testSlug, testBranch)
.returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBuild').never();
const options = { branch: testBranch, repo: testSlug };
return travisStatus(options).then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testBranch = 'branch1';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('detectBranch')
.once().withExactArgs().returns(Promise.resolve(testBranch));
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo').never();
travisCheckerMock.expects('getBranch')
.once().withArgs(testSlug, testBranch)
.returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBuild').never();
const options = { branch: true, repo: testSlug };
return travisStatus(options).then((result) => {
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testHash = '692064aac95441e2dae7f1780fccc536143a0863';
const apiHash = isSameHash ? testHash : `${testHash.slice(0, -1)}0`;
const testCommit = commitIsHash ? testHash : 'v2.0.0';
const testRepo = apiResponses.repo({
slug: testSlug,
});
const testBuild = apiResponses.build({ sha: apiHash });
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('resolveHash')
.once().withExactArgs(testCommit).returns(Promise.resolve(testHash));
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testRepo));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild')
.once().withArgs(testSlug, testRepo.repo.last_build_id)
.returns(Promise.resolve(testBuild));
const statusP = travisStatus({ commit: testCommit, repo: testSlug });
let testP;
if (isSameHash) {
testP = statusP.then((result) => {
assert.deepEqual(result, { ...testRepo, ...testBuild });
});
} else {
testP = statusP.then(
sinon.mock().never(),
(err) => {
assert.match(err.message, /\bcommit\b/i);
assert.include(err.message, testCommit);
assert.include(err.message, testHash);
assert.include(err.message, apiHash);
},
);
}
return testP.then(() => {
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testHash = '692064aac95441e2dae7f1780fccc536143a0863';
const apiHash = isSameHash ? testHash : `${testHash.slice(0, -1)}0`;
const testCommit = commitIsHash ? testHash : 'v2.0.0';
const testRepo = apiResponses.repo({
slug: testSlug,
});
const testBuild = apiResponses.build({ sha: apiHash });
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('resolveHash')
.once().withExactArgs(testCommit).returns(Promise.resolve(testHash));
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testRepo));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild')
.once().withArgs(testSlug, testRepo.repo.last_build_id)
.returns(Promise.resolve(testBuild));
const statusP = travisStatus({ commit: testCommit, repo: testSlug });
let testP;
if (isSameHash) {
testP = statusP.then((result) => {
assert.deepEqual(result, { ...testRepo, ...testBuild });
});
} else {
testP = statusP.then(
sinon.mock().never(),
(err) => {
assert.match(err.message, /\bcommit\b/i);
assert.include(err.message, testCommit);
assert.include(err.message, testHash);
assert.include(err.message, apiHash);
},
);
}
return testP.then(() => {
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testHash = '692064aac95441e2dae7f1780fccc536143a0863';
const apiHash = isSameHash ? testHash : `${testHash.slice(0, -1)}0`;
const testCommit = commitIsHash ? testHash : 'v2.0.0';
const testRepo = apiResponses.repo({
slug: testSlug,
});
const testBuild = apiResponses.build({ sha: apiHash });
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('resolveHash')
.once().withExactArgs(testCommit).returns(Promise.resolve(testHash));
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testRepo));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild')
.once().withArgs(testSlug, testRepo.repo.last_build_id)
.returns(Promise.resolve(testBuild));
const statusP = travisStatus({ commit: testCommit, repo: testSlug });
let testP;
if (isSameHash) {
testP = statusP.then((result) => {
assert.deepEqual(result, { ...testRepo, ...testBuild });
});
} else {
testP = statusP.then(
sinon.mock().never(),
(err) => {
assert.match(err.message, /\bcommit\b/i);
assert.include(err.message, testCommit);
assert.include(err.message, testHash);
assert.include(err.message, apiHash);
},
);
}
return testP.then(() => {
gitCheckerMock.verify();
travisCheckerMock.verify();
});
const testSlug = 'foo/bar';
const testHash = '692064aac95441e2dae7f1780fccc536143a0863';
const apiHash = isSameHash ? testHash : `${testHash.slice(0, -1)}0`;
const testCommit = commitIsHash ? testHash : 'v2.0.0';
const testRepo = apiResponses.repo({
slug: testSlug,
});
const testBuild = apiResponses.build({ sha: apiHash });
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('resolveHash')
.once().withExactArgs(testCommit).returns(Promise.resolve(testHash));
gitCheckerMock.expects('findSlug').never();
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testRepo));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild')
.once().withArgs(testSlug, testRepo.repo.last_build_id)
.returns(Promise.resolve(testBuild));
const statusP = travisStatus({ commit: testCommit, repo: testSlug });
let testP;
if (isSameHash) {
testP = statusP.then((result) => {
assert.deepEqual(result, { ...testRepo, ...testBuild });
});
} else {
testP = statusP.then(
sinon.mock().never(),
(err) => {
assert.match(err.message, /\bcommit\b/i);
assert.include(err.message, testCommit);
assert.include(err.message, testHash);
assert.include(err.message, apiHash);
},
);
}
return testP.then(() => {
gitCheckerMock.verify();
travisCheckerMock.verify();
});
travisStatus(true)
.then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'TypeError');
assert.match(err.message, /\boptions\b/);
},
)
assert.throws(
() => { travisStatus({}, true); },
TypeError,
/\bcallback\b/,
);
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('storeSlug').never();
gitCheckerMock.expects('findSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo').never();
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
return travisStatus({ repo: 'invalid' }).then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'InvalidSlugError');
gitCheckerMock.verify();
travisCheckerMock.verify();
},
);
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('storeSlug').never();
gitCheckerMock.expects('findSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo').never();
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
return travisStatus({ storeRepo: 'invalid' }).then(
sinon.mock().never(),
(err) => {
assert.strictEqual(err.name, 'InvalidSlugError');
gitCheckerMock.verify();
travisCheckerMock.verify();
},
);
const testSlug = 'foo/bar';
const testResult = {};
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('findSlug')
.once().withExactArgs().returns(Promise.resolve(testSlug));
gitCheckerMock.expects('storeSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo')
.once().withArgs(testSlug).returns(Promise.resolve(testResult));
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
const retVal = travisStatus((err, result) => {
assert.strictEqual(err, null);
assert.deepEqual(result, testResult);
gitCheckerMock.verify();
travisCheckerMock.verify();
done();
});
assert.strictEqual(retVal, undefined);
gitChecker = new GitStatusChecker();
const gitCheckerMock = sinon.mock(gitChecker);
gitCheckerMock.expects('storeSlug').never();
gitCheckerMock.expects('findSlug').never();
travisChecker = new TravisStatusChecker();
const travisCheckerMock = sinon.mock(travisChecker);
travisCheckerMock.expects('getRepo').never();
travisCheckerMock.expects('getBranch').never();
travisCheckerMock.expects('getBuild').never();
const retVal = travisStatus({ repo: 'invalid' }, (err) => {
assert.strictEqual(err.name, 'InvalidSlugError');
gitCheckerMock.verify();
travisCheckerMock.verify();
done();
});
assert.strictEqual(retVal, undefined);