7c1573fb07
* switch from custom eslint config to standard + prettier * fix new standard eslint violations * add editorconfig file * auto-fix all other violations * update lint yarn script * remove jshint comment
1028 lines
23 KiB
JavaScript
1028 lines
23 KiB
JavaScript
var ca = require('../../../src/lib/client_action').factory;
|
|
var proxy = require('../../../src/lib/client_action').proxyFactory;
|
|
var expect = require('expect.js');
|
|
var _ = require('lodash');
|
|
var Promise = require('bluebird');
|
|
|
|
/**
|
|
* Creates a simple mock of the client, whose "transport" has a request
|
|
* function that just calls back with the parameters it received
|
|
*
|
|
* @return {Object}
|
|
*/
|
|
function mockClient() {
|
|
return {
|
|
transport: {
|
|
request: function(params, cb) {
|
|
if (typeof cb === 'function') {
|
|
process.nextTick(function() {
|
|
cb(void 0, params);
|
|
});
|
|
} else {
|
|
return Promise.resolve(params);
|
|
}
|
|
},
|
|
defer: function() {
|
|
return Promise.defer();
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a client action, ensuring that is has some default url specs, and binds it to
|
|
* a mock client.
|
|
*
|
|
* @param {Object} spec - the spec for the client action
|
|
* @return {Function} - the client action
|
|
*/
|
|
function makeClientAction(spec) {
|
|
spec = spec || {};
|
|
|
|
if (!spec.urls && !spec.url) {
|
|
spec.url = {
|
|
fmt: '/',
|
|
};
|
|
}
|
|
|
|
return _.bind(ca(spec), mockClient());
|
|
}
|
|
|
|
/**
|
|
* Calls proxyFactory and binds it to a mock client
|
|
* @param {Function} fn - the function to proxy
|
|
* @param {Object} spec - The spec for the proxy
|
|
* @return {Function} - the clientActionProxy
|
|
*/
|
|
function makeClientActionProxy(fn, spec) {
|
|
return _.bind(proxy(fn, spec || {}), mockClient());
|
|
}
|
|
|
|
describe('Client Action runner', function() {
|
|
var action;
|
|
|
|
// used to check that params are not clobbered
|
|
var params = (function() {
|
|
var _stash = {};
|
|
afterEach(function() {
|
|
_stash = {};
|
|
});
|
|
var make = function(params) {
|
|
_stash.orig = params;
|
|
_stash.copy = _.clone(params);
|
|
return params;
|
|
};
|
|
make.check = function() {
|
|
expect(_stash.orig).to.eql(_stash.copy);
|
|
};
|
|
|
|
return make;
|
|
})();
|
|
|
|
describe('argument juggling', function() {
|
|
it('creates an empty param set when no params are sent', function(done) {
|
|
action = makeClientAction();
|
|
|
|
// note: the first arg is the callback
|
|
action(function(err, params) {
|
|
expect(params.query).to.eql({});
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('clientAction::proxy', function() {
|
|
it('proxies to the passed function', function() {
|
|
var action = makeClientActionProxy(function() {
|
|
throw new Error('proxy function called');
|
|
});
|
|
|
|
expect(function() {
|
|
action({}, function() {});
|
|
}).to.throwError('proxy function called');
|
|
});
|
|
|
|
it('provides the proper context', function(done) {
|
|
var client;
|
|
var action = makeClientActionProxy(function(params, cb) {
|
|
client = this;
|
|
process.nextTick(function() {
|
|
cb(void 0, params);
|
|
});
|
|
});
|
|
|
|
action({}, function() {
|
|
expect(client.transport.request).to.be.a('function');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('handles passing just the callback', function() {
|
|
var action = makeClientActionProxy(function(params, cb) {
|
|
expect(_.isObject(params)).to.be.ok();
|
|
expect(cb).to.be.a('function');
|
|
});
|
|
|
|
action(function() {});
|
|
});
|
|
|
|
it('supports a param transformation function', function() {
|
|
var action = makeClientActionProxy(
|
|
function(params) {
|
|
expect(params).to.have.property('transformed');
|
|
},
|
|
{
|
|
transform: function(params) {
|
|
params.transformed = true;
|
|
},
|
|
}
|
|
);
|
|
|
|
action(function() {});
|
|
});
|
|
|
|
it("returns the proxied function's return value", function() {
|
|
var football = {};
|
|
var action = makeClientActionProxy(function() {
|
|
return football;
|
|
});
|
|
|
|
expect(action()).to.be(football);
|
|
});
|
|
});
|
|
|
|
describe('param casting', function() {
|
|
describe('duration', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: {
|
|
type: 'duration',
|
|
},
|
|
two: {
|
|
type: 'duration',
|
|
},
|
|
three: {
|
|
type: 'duration',
|
|
},
|
|
four: {
|
|
type: 'duration',
|
|
},
|
|
},
|
|
});
|
|
});
|
|
|
|
it('accepts a number, string, or interval', function(done) {
|
|
action(
|
|
{
|
|
one: 1500,
|
|
two: '500',
|
|
three: '15m',
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.eql(1500);
|
|
expect(params.query.two).to.eql('500');
|
|
expect(params.query.three).to.eql('15m');
|
|
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects date values', function(done) {
|
|
action(
|
|
{
|
|
one: new Date(),
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects array', function(done) {
|
|
action(
|
|
{
|
|
one: ['one'],
|
|
two: [1304],
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects object', function(done) {
|
|
action(
|
|
{
|
|
one: { but: 'duration' },
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('list', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: { type: 'list' },
|
|
two: { type: 'list' },
|
|
three: { type: 'list' },
|
|
},
|
|
});
|
|
});
|
|
|
|
it('accepts a string, number, or array', function(done) {
|
|
action(
|
|
{
|
|
one: 'some,strings',
|
|
two: 1430,
|
|
three: ['some', 'strings'],
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query).to.eql({
|
|
one: 'some,strings',
|
|
two: 1430,
|
|
three: 'some,strings',
|
|
});
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('it rejects regexp', function(done) {
|
|
action(
|
|
{
|
|
one: /regexp!/g,
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('it rejects objects', function(done) {
|
|
action(
|
|
{
|
|
one: {
|
|
pasta: 'sauce',
|
|
},
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('enum', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: { type: 'enum', options: ['opt', 'other opt', '150', 'true'] },
|
|
},
|
|
});
|
|
});
|
|
|
|
it('accepts any value in the list', function(done) {
|
|
action(
|
|
{
|
|
one: 'opt',
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.eql('opt');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('accepts any value kind of in the list', function(done) {
|
|
action(
|
|
{
|
|
one: 150,
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be('150');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('accepts string versions of booleans', function(done) {
|
|
action(
|
|
{
|
|
one: true,
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be('true');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('it rejects things not in the list', function(done) {
|
|
action(
|
|
{
|
|
one: 'not an opt',
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('boolean', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: { type: 'boolean' },
|
|
two: { type: 'boolean' },
|
|
three: { type: 'boolean' },
|
|
four: { type: 'boolean' },
|
|
five: { type: 'boolean' },
|
|
six: { type: 'boolean' },
|
|
},
|
|
});
|
|
});
|
|
|
|
it('casts "off", "no", and other falsey things to false', function(done) {
|
|
action(
|
|
{
|
|
one: 'off',
|
|
two: 'no',
|
|
three: false,
|
|
four: '',
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be(false);
|
|
expect(params.query.two).to.be(false);
|
|
expect(params.query.three).to.be(false);
|
|
expect(params.query.four).to.be(false);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('cast most everything else to true', function(done) {
|
|
action(
|
|
{
|
|
one: 'yes',
|
|
two: 'ok',
|
|
three: true,
|
|
four: 1,
|
|
five: new Date(),
|
|
six: {},
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be(true);
|
|
expect(params.query.two).to.be(true);
|
|
expect(params.query.three).to.be(true);
|
|
expect(params.query.four).to.be(true);
|
|
expect(params.query.five).to.be(true);
|
|
expect(params.query.six).to.be(true);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('number', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: { type: 'number' },
|
|
two: { type: 'number' },
|
|
three: { type: 'number' },
|
|
four: { type: 'number' },
|
|
five: { type: 'number' },
|
|
six: { type: 'number' },
|
|
},
|
|
});
|
|
});
|
|
|
|
it('casts integers properly', function(done) {
|
|
action(
|
|
{
|
|
one: '42',
|
|
two: '-69',
|
|
three: 15,
|
|
four: -100,
|
|
five: '0xFF',
|
|
six: 0xfff,
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be(42);
|
|
expect(params.query.two).to.be(-69);
|
|
expect(params.query.three).to.be(15);
|
|
expect(params.query.four).to.be(-100);
|
|
expect(params.query.five).to.be(255);
|
|
expect(params.query.six).to.be(4095);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('casts floats properly', function(done) {
|
|
action(
|
|
{
|
|
one: '-1.6',
|
|
two: '4.536',
|
|
three: -2.6,
|
|
four: 3.1415,
|
|
five: 8e5,
|
|
six: '123e-2',
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be(-1.6);
|
|
expect(params.query.two).to.be(4.536);
|
|
expect(params.query.three).to.be(-2.6);
|
|
expect(params.query.four).to.be(3.1415);
|
|
expect(params.query.five).to.be(800000);
|
|
expect(params.query.six).to.be(1.23);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects dates', function(done) {
|
|
action(
|
|
{
|
|
one: new Date(),
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects objects', function(done) {
|
|
action(
|
|
{
|
|
one: {},
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects arrays', function(done) {
|
|
action(
|
|
{
|
|
one: [],
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects regexp', function(done) {
|
|
action(
|
|
{
|
|
one: /pasta/g,
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('string', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: { type: 'string' },
|
|
two: { type: 'string' },
|
|
three: { type: 'string' },
|
|
four: { type: 'string' },
|
|
five: { type: 'string' },
|
|
six: { type: 'string' },
|
|
},
|
|
});
|
|
});
|
|
|
|
it('accepts numbers and strings', function(done) {
|
|
action(
|
|
{
|
|
one: '42',
|
|
two: '-69',
|
|
three: 15,
|
|
four: -100,
|
|
five: '0xFF',
|
|
six: 0xfff,
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be('42');
|
|
expect(params.query.two).to.be('-69');
|
|
expect(params.query.three).to.be('15');
|
|
expect(params.query.four).to.be('-100');
|
|
expect(params.query.five).to.be('0xFF');
|
|
expect(params.query.six).to.be('4095');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects dates', function(done) {
|
|
action(
|
|
{
|
|
one: new Date(),
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects objects', function(done) {
|
|
action(
|
|
{
|
|
one: {},
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects arrays', function(done) {
|
|
action(
|
|
{
|
|
one: [],
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects regexp', function(done) {
|
|
action(
|
|
{
|
|
one: /pasta/g,
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('time', function() {
|
|
beforeEach(function() {
|
|
action = makeClientAction({
|
|
params: {
|
|
one: { type: 'time' },
|
|
two: { type: 'time' },
|
|
three: { type: 'time' },
|
|
four: { type: 'time' },
|
|
five: { type: 'time' },
|
|
six: { type: 'time' },
|
|
},
|
|
});
|
|
});
|
|
|
|
it('accepts numbers, strings, and dates', function(done) {
|
|
var now = new Date();
|
|
|
|
action(
|
|
{
|
|
one: '42',
|
|
two: '-69',
|
|
three: 15,
|
|
four: now,
|
|
five: new Date('2013-03-01T01:10:00Z'),
|
|
},
|
|
function(err, params) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(params.query.one).to.be('42');
|
|
expect(params.query.two).to.be('-69');
|
|
expect(params.query.three).to.be('15');
|
|
expect(params.query.four).to.be('' + now.getTime());
|
|
expect(params.query.five).to.be('1362100200000');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects objects', function(done) {
|
|
action(
|
|
{
|
|
one: {},
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects arrays', function(done) {
|
|
action(
|
|
{
|
|
one: [],
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('rejects regexp', function(done) {
|
|
action(
|
|
{
|
|
one: /pasta/g,
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('passing of control params from spec', function() {
|
|
it('passes bulkBody', function(done) {
|
|
var action = makeClientAction({
|
|
bulkBody: true,
|
|
});
|
|
|
|
action({}, function(err, params) {
|
|
expect(params.bulkBody).to.be(true);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('sets castExists when the method in the spec is HEAD', function(done) {
|
|
var action = makeClientAction({
|
|
method: 'HEAD',
|
|
});
|
|
|
|
action({}, function(err, params) {
|
|
expect(params.castExists).to.be(true);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('body handling', function() {
|
|
var action = makeClientAction({
|
|
needsBody: true,
|
|
});
|
|
|
|
it('passed the body when it is set', function(done) {
|
|
var body = '{"JSON":"PLEASE"}';
|
|
|
|
action({ body: body }, function(err, params) {
|
|
expect(params.body).to.be(body);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('errors when the body is not set but required', function(done) {
|
|
action().then(
|
|
function() {
|
|
done(new Error('Error should have been raised'));
|
|
},
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('passing of http method', function() {
|
|
it('uppercases and passed the default method', function(done) {
|
|
var action = makeClientAction({
|
|
method: 'POST',
|
|
});
|
|
|
|
action({ method: 'get' }, function(err, params) {
|
|
expect(params.method).to.be('GET');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('uppercases and passed the default method', function(done) {
|
|
var action = makeClientAction({
|
|
method: 'POST',
|
|
});
|
|
|
|
action({}, function(err, params) {
|
|
expect(params.method).to.be('POST');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('passing of ignore param', function() {
|
|
it('passes ignore as an array', function(done) {
|
|
var action = makeClientAction({});
|
|
action({ ignore: 404 }, function(err, params) {
|
|
expect(params.ignore).to.eql([404]);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('passing requestTimeout', function() {
|
|
it('passes passes the spec value by default', function(done) {
|
|
var action = makeClientAction({
|
|
requestTimeout: 100,
|
|
});
|
|
|
|
action({}, function(err, params) {
|
|
expect(params.requestTimeout).to.be(100);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('passes the provided value', function(done) {
|
|
var action = makeClientAction({
|
|
requestTimeout: 100,
|
|
});
|
|
|
|
action({ requestTimeout: 3000 }, function(err, params) {
|
|
expect(params.requestTimeout).to.be(3000);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('passes nothing be default', function(done) {
|
|
var action = makeClientAction({});
|
|
|
|
action({}, function(err, params) {
|
|
expect(params.requestTimeout).be(void 0);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('url resolver', function() {
|
|
var action = makeClientAction({
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>/<%=thing%>',
|
|
req: {
|
|
index: {
|
|
type: 'list',
|
|
},
|
|
id: {
|
|
type: 'any',
|
|
},
|
|
},
|
|
opt: {
|
|
type: {
|
|
type: 'list',
|
|
default: '_all',
|
|
},
|
|
thing: {
|
|
type: 'any',
|
|
default: '',
|
|
},
|
|
},
|
|
},
|
|
],
|
|
});
|
|
|
|
// match a url to the parameters passed in.
|
|
it('rejects a url if it required params that are not present', function(done) {
|
|
action(
|
|
params({
|
|
type: ['type1', 'type2'],
|
|
}),
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('uses the default value for optional params', function(done) {
|
|
action(
|
|
params({
|
|
index: 'index1',
|
|
id: '1',
|
|
}),
|
|
function(err, resp) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(resp.path).to.be('/index1/_all/1/');
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('casts both optional and required args', function(done) {
|
|
action(
|
|
params({
|
|
index: ['index1', 'index2'],
|
|
id: '123',
|
|
type: ['_all', '-pizza'],
|
|
thing: 'poo',
|
|
}),
|
|
function(err, resp) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(resp.path).to.be('/index1%2Cindex2/_all%2C-pizza/123/poo');
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('param collection', function() {
|
|
var action = makeClientAction({
|
|
params: {
|
|
a: { type: 'list', required: true },
|
|
b: { type: 'duration', default: '15m' },
|
|
q: { type: 'any' },
|
|
},
|
|
});
|
|
|
|
it('collects all of the params into params.query', function(done) {
|
|
action(
|
|
params({
|
|
a: 'pizza',
|
|
b: '1M',
|
|
}),
|
|
function(err, resp) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(resp.query).to.eql({
|
|
a: 'pizza',
|
|
b: '1M',
|
|
});
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('includes extra params', function(done) {
|
|
action(
|
|
params({
|
|
a: 'pizza',
|
|
b: '3w',
|
|
c: 'popular',
|
|
}),
|
|
function(err, resp) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(resp.query).to.eql({
|
|
a: 'pizza',
|
|
b: '3w',
|
|
c: 'popular',
|
|
});
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('excludes default values', function(done) {
|
|
action(
|
|
params({
|
|
a: 'pizza',
|
|
b: '15m',
|
|
}),
|
|
function(err, resp) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(resp.query).to.eql({
|
|
a: 'pizza',
|
|
});
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('does not include non-query param keys', function(done) {
|
|
action(
|
|
params({
|
|
a: 'pizza',
|
|
b: '3w',
|
|
q: 'beep',
|
|
body: '{ "mmm": "json" }',
|
|
requestTimeout: 1000,
|
|
method: 'head',
|
|
ignore: 201,
|
|
}),
|
|
function(err, resp) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
expect(resp.query).to.eql({
|
|
a: 'pizza',
|
|
b: '3w',
|
|
q: 'beep',
|
|
});
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('enforces required params', function(done) {
|
|
action(
|
|
params({
|
|
b: '3w',
|
|
}),
|
|
function(err) {
|
|
expect(err).to.be.a(TypeError);
|
|
params.check();
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('does not modify the incoming params object', function() {
|
|
var action = makeClientAction({
|
|
url: {
|
|
req: {
|
|
index: { type: 'string' },
|
|
},
|
|
fmt: '/<%= index %>',
|
|
},
|
|
});
|
|
action(
|
|
params({
|
|
index: 'index',
|
|
}),
|
|
function(err, resp) {
|
|
expect(resp).to.eql({
|
|
method: 'GET',
|
|
path: '/index',
|
|
query: {},
|
|
});
|
|
params.check();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
});
|