pelias
/
api
mirror of https://github.com/pelias/api.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

test reverse, nearby, place sanitizer wrappers w/ proxyquire

pull/942/head
Lily He 8 years ago
parent
80a3a259ef
commit
07c7e7d483
3 changed files with 185 additions and 320 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 74
      test/unit/sanitizer/nearby.js
  2. 137
      test/unit/sanitizer/place.js
  3. 294
      test/unit/sanitizer/reverse.js

74
test/unit/sanitizer/nearby.js
Unescape View File

@ -1,52 +1,36 @@
const _ = require('lodash'),
var nearby = require('../../../sanitizer/nearby'); proxyquire = require('proxyquire').noCallThru();
var defaults = require('../../../query/reverse_defaults');
var sanitize = nearby.sanitize;
var middleware = nearby.middleware;
var sanitizer_list = nearby.sanitizer_list;
var defaultClean = { 'point.lat': 0,
'point.lon': 0,
'boundary.circle.lat': 0,
'boundary.circle.lon': 0,
size: 10,
private: false
};
module.exports.tests = {}; module.exports.tests = {};
module.exports.tests.interface = function(test, common) { module.exports.tests.sanitize = function(test, common) {
test('sanitize interface', function(t) { test('verify that all sanitizers were called as expected', function(t) {
t.equal(typeof sanitize, 'function', 'sanitize is a function'); var called_sanitizers = [];
t.equal(sanitize.length, 3, 'sanitize interface takes three args');
t.end(); // rather than re-verify the functionality of all the sanitizers, this test just verifies that they
}); // were all called correctly
test('middleware interface', function(t) { var nearby = proxyquire('../../../sanitizer/nearby.js', {
t.equal(typeof middleware, 'function', 'middleware is a function'); '../sanitizer/_categories': function () {
t.equal(middleware.length, 3, 'sanitizee has a valid middleware'); return {
t.end(); sanitize: () => {
}); called_sanitizers.push('_categories');
}; return { errors: [], warnings: [] };
}
module.exports.tests.sanitizers = function(test, common) { };
test('check sanitizer list', function (t) { }
var expected = ['singleScalarParameters', 'quattroshapes_deprecation', 'layers', });
'sources', 'sources_and_layers', 'geonames_deprecation', 'size', 'private',
'geo_reverse', 'boundary_country', 'categories']; const expected_sanitizers = [
t.deepEqual(Object.keys(nearby.sanitizer_list), expected); '_categories'
t.end(); ];
});
}; const req = {};
const res = {};
module.exports.tests.middleware_success = function(test, common) {
test('middleware success', function(t) { nearby.middleware(req, res, () => {
var req = { query: { 'point.lat': 0, 'point.lon': 0 }}; t.deepEquals(called_sanitizers, expected_sanitizers);
var next = function(){
t.deepEqual(req.errors, [], 'no error message set');
t.deepEqual(req.clean, defaultClean);
t.end(); t.end();
}; });
middleware( req, undefined, next );
}); });
}; };

137
test/unit/sanitizer/place.js
Unescape View File

@ -1,108 +1,61 @@
var place = require('../../../sanitizer/place'), const _ = require('lodash'),
sanitize = place.sanitize, proxyquire = require('proxyquire').noCallThru();
middleware = place.middleware,
sanitizer_list = place.sanitizer_list,
defaultClean = { ids: [ { source: 'geonames', layer: 'venue', id: '123' } ], private: false };
// these are the default values you would expect when no input params are specified.
module.exports.tests = {}; module.exports.tests = {};
module.exports.tests.interface = function(test, common) { module.exports.tests.sanitize = function(test, common) {
test('sanitize interface', function(t) { test('verify that all sanitizers were called as expected', function(t) {
t.equal(typeof sanitize, 'function', 'sanitize is a function'); var called_sanitizers = [];
t.equal(sanitize.length, 3, 'sanitize interface takes three args');
t.end();
});
test('middleware interface', function(t) {
t.equal(typeof middleware, 'function', 'middleware is a function');
t.equal(middleware.length, 3, 'sanitize has a valid middleware');
t.end();
});
};
module.exports.tests.sanitizers = function(test, common) {
test('check sanitizer list', function (t) {
var expected = ['singleScalarParameters', 'ids', 'private' ];
t.deepEqual(Object.keys(place.sanitizer_list), expected);
t.end();
});
};
module.exports.tests.sanitize_private = function(test, common) { // rather than re-verify the functionality of all the sanitizers, this test just verifies that they
var invalid_values = [null, -1, 123, NaN, 'abc']; // were all called correctly
invalid_values.forEach(function(value) { var place = proxyquire('../../../sanitizer/place.js', {
test('invalid private param ' + value, function(t) { '../sanitizer/_single_scalar_parameters': function () {
var req = { query: { ids:'geonames:venue:123', 'private': value } }; return {
sanitize(req, sanitizer_list, () => { sanitize: () => {
t.deepEqual( req.errors, [], 'no errors' ); called_sanitizers.push('_single_scalar_parameters');
t.deepEqual( req.warnings, [], 'no warnings' ); return { errors: [], warnings: [] };
t.equal(req.clean.private, false, 'default private set (to false)'); }
t.end(); };
}); },
'../sanitizer/_ids': function () {
return {
sanitize: () => {
called_sanitizers.push('_ids');
return { errors: [], warnings: [] };
}
};
},
'../sanitizer/_flag_bool': function () {
if (arguments[0] === 'private' && arguments[1] === false) {
return {
sanitize: () => {
called_sanitizers.push('_flag_bool');
return { errors: [], warnings: [] };
}
};
} else {
throw new Error('incorrect parameters passed to _flag_bool');
}
}
}); });
});
var valid_values = ['true', true, 1];
valid_values.forEach(function(value) {
test('valid private param ' + value, function(t) {
var req = { query: { ids:'geonames:venue:123', 'private': value } };
sanitize(req, sanitizer_list, () => {
t.deepEqual( req.errors, [], 'no errors' );
t.deepEqual( req.warnings, [], 'no warnings' );
t.equal(req.clean.private, true, 'private set to true');
t.end();
});
});
});
var valid_false_values = ['false', false, 0]; const expected_sanitizers = [
valid_false_values.forEach(function(value) { '_single_scalar_parameters',
test('test setting false explicitly ' + value, function(t) { '_ids',
var req = { query: { ids:'geonames:venue:123', 'private': value } }; '_flag_bool'
sanitize(req, sanitizer_list, () => { ];
t.deepEqual( req.errors, [], 'no errors' );
t.deepEqual( req.warnings, [], 'no warnings' );
t.equal(req.clean.private, false, 'private set to false');
t.end();
});
});
});
test('test default behavior', function(t) { const req = {};
var req = { query: { ids:'geonames:venue:123' } }; const res = {};
sanitize(req, sanitizer_list, () => {
t.deepEqual( req.errors, [], 'no errors' );
t.deepEqual( req.warnings, [], 'no warnings' );
t.equal(req.clean.private, false, 'private set to false');
t.end();
});
});
};
module.exports.tests.invalid_params = function(test, common) { place.middleware(req, res, () => {
test('no params', function(t) { t.deepEquals(called_sanitizers, expected_sanitizers);
var req = { query: {} };
sanitize(req, sanitizer_list, () => {
t.equal( req.errors[0], 'invalid param \'ids\': length must be >0', 'error for missing `ids` param');
t.deepEqual( req.warnings, [], 'no warnings' );
t.end(); t.end();
}); });
}); });
}; };
module.exports.tests.middleware_success = function(test, common) {
test('middleware success', function(t) {
var req = { query: { ids: 'geonames:venue:123' }};
var next = function(){
t.deepEqual( req.errors, [], 'no errors' );
t.deepEqual( req.warnings, [], 'no warnings' );
t.deepEqual(req.clean, defaultClean);
t.end();
};
middleware( req, undefined, next );
});
};
module.exports.all = function (tape, common) { module.exports.all = function (tape, common) {
function test(name, testFunction) { function test(name, testFunction) {

294
test/unit/sanitizer/reverse.js
Unescape View File

@ -1,194 +1,122 @@
const _ = require('lodash'),
// @todo: refactor this test, it's pretty messy, brittle and hard to follow proxyquire = require('proxyquire').noCallThru();
var reverse = require('../../../sanitizer/reverse'),
sanitize = reverse.sanitize,
middleware = reverse.middleware,
sanitizer_list = reverse.sanitizer_list,
defaults = require('../../../query/reverse_defaults'),
defaultError = 'missing param \'lat\'',
defaultClean = { 'point.lat': 0,
'point.lon': 0,
'boundary.circle.lat': 0,
'boundary.circle.lon': 0,
size: 10,
private: false
};
// these are the default values you would expect when no input params are specified.
// @todo: why is this different from $defaultClean?
var emptyClean = { private: false, size: 10 };
module.exports.tests = {}; module.exports.tests = {};
module.exports.tests.interface = function(test, common) { module.exports.tests.sanitize = function(test, common) {
test('sanitize interface', function(t) { test('verify that all sanitizers were called as expected', function(t) {
t.equal(typeof sanitize, 'function', 'sanitize is a function'); var called_sanitizers = [];
t.equal(sanitize.length, 3, 'sanitize interface takes one param: req');
t.end(); // rather than re-verify the functionality of all the sanitizers, this test just verifies that they
}); // were all called correctly
test('middleware interface', function(t) { var reverse = proxyquire('../../../sanitizer/reverse.js', {
t.equal(typeof middleware, 'function', 'middleware is a function'); '../sanitizer/_single_scalar_parameters': function () {
t.equal(middleware.length, 3, 'sanitizee has a valid middleware'); return {
t.end(); sanitize: () => {
}); called_sanitizers.push('_single_scalar_parameters');
}; return { errors: [], warnings: [] };
}
module.exports.tests.sanitizers = function(test, common) { };
test('check sanitizer list', function (t) { },
var expected = ['singleScalarParameters', 'quattroshapes_deprecation', 'layers', '../sanitizer/_deprecate_quattroshapes': function () {
'sources', 'sources_and_layers', 'geonames_deprecation', 'size', 'private', return {
'geo_reverse', 'boundary_country']; sanitize: () => {
t.deepEqual(Object.keys(reverse.sanitizer_list), expected); called_sanitizers.push('_deprecate_quattroshapes');
t.end(); return { errors: [], warnings: [] };
}); }
}; };
},
module.exports.tests.sanitize_lat = function(test, common) { '../sanitizer/_targets': function (type) {
var lats = { if (['layers', 'sources'].indexOf(type) !== -1) {
invalid: [], return {
valid: [ 0, 45, 90, -0, '0', '45', '90', -181, -120, -91, 91, 120, 181 ], sanitize: () => {
missing: ['', undefined, null] called_sanitizers.push(`_targets/${type}`);
}; return { errors: [], warnings: [] };
test('invalid lat', function(t) { }
lats.invalid.forEach( function( lat ){ };
var req = { query: { 'point.lat': lat, 'point.lon': 0 } }; } else {
sanitize(req, sanitizer_list, () => { throw new Error('incorrect parameters passed to _targets');
t.equal(req.errors[0], 'invalid param \'point.lat\': must be >-90 and <90', lat + ' is an invalid latitude'); }
t.deepEqual(req.clean, emptyClean, 'clean only has default values set'); },
}); '../sanitizer/_sources_and_layers': function () {
}); return {
t.end(); sanitize: () => {
}); called_sanitizers.push('_sources_and_layers');
test('valid lat', function(t) { return { errors: [], warnings: [] };
lats.valid.forEach( function( lat ){ }
var req = { query: { 'point.lat': lat, 'point.lon': 0 } }; };
sanitize(req, sanitizer_list, () => { },
var expected_lat = parseFloat( lat ); '../sanitizer/_geonames_deprecation': function () {
t.deepEqual(req.errors, [], 'no errors'); return {
}); sanitize: () => {
}); called_sanitizers.push('_geonames_deprecations');
t.end(); return { errors: [], warnings: [] };
}); }
test('missing lat', function(t) { };
lats.missing.forEach( function( lat ){ },
var req = { query: { 'point.lat': lat, 'point.lon': 0 } }; '../sanitizer/_size': function () {
sanitize(req, sanitizer_list, () => { if (_.isEmpty(arguments)) {
t.equal(req.errors[0], 'missing param \'point.lat\'', 'latitude is a required field'); return {
t.deepEqual(req.clean, emptyClean, 'clean only has default values set'); sanitize: () => {
}); called_sanitizers.push('_size');
}); return { errors: [], warnings: [] };
t.end(); }
}); };
}; } else {
throw new Error('should not have passed any parameters to _size');
module.exports.tests.sanitize_lon = function(test, common) { }
var lons = { },
valid: [ -360, -181, 181, -180, -1, -0, 0, 45, 90, '-180', '0', '180' ], '../sanitizer/_flag_bool': function () {
missing: ['', undefined, null] if (arguments[0] === 'private' && arguments[1] === false) {
}; return {
test('valid lon', function(t) { sanitize: () => {
lons.valid.forEach( function( lon ){ called_sanitizers.push('_flag_bool');
var req = { query: { 'point.lat': 0, 'point.lon': lon } }; return { errors: [], warnings: [] };
sanitize(req, sanitizer_list, () => { }
var expected_lon = parseFloat( lon ); };
t.deepEqual(req.errors, [], 'no errors'); } else {
}); throw new Error('incorrect parameters passed to _flag_bool');
}
},
'../sanitizer/_geo_reverse': function () {
return {
sanitize: () => {
called_sanitizers.push('_geo_reverse');
return { errors: [], warnings: [] };
}
};
},
'../sanitizer/_boundary_country': function () {
return {
sanitize: () => {
called_sanitizers.push('_boundary_country');
return { errors: [], warnings: [] };
}
};
}
}); });
t.end();
});
test('missing lon', function(t) {
lons.missing.forEach( function( lon ){
var req = { query: { 'point.lat': 0, 'point.lon': lon } };
// @todo: why is lat set?
var expected = { 'point.lat': 0, private: false, size: 10 };
sanitize(req, sanitizer_list, () => {
t.equal(req.errors[0], 'missing param \'point.lon\'', 'longitude is a required field');
t.deepEqual(req.clean, expected, 'clean only has default values set');
});
});
t.end();
});
};
module.exports.tests.sanitize_size = function(test, common) { const expected_sanitizers = [
test('invalid size value', function(t) { '_single_scalar_parameters',
var req = { query: { size: 'a', 'point.lat': 0, 'point.lon': 0 } }; '_deprecate_quattroshapes',
sanitize(req, sanitizer_list, () => { '_targets/layers',
t.equal(req.clean.size, 10, 'default size set'); '_targets/sources',
'_sources_and_layers',
'_geonames_deprecations',
'_size',
'_flag_bool',
'_geo_reverse',
'_boundary_country'
];
const req = {};
const res = {};
reverse.middleware(req, res, () => {
t.deepEquals(called_sanitizers, expected_sanitizers);
t.end(); t.end();
}); });
}); });
test('below min size value', function(t) {
var req = { query: { size: -100, 'point.lat': 0, 'point.lon': 0 } };
sanitize(req, sanitizer_list, () => {
t.equal(req.clean.size, 1, 'min size set');
t.end();
});
});
test('above max size value', function(t) {
var req = { query: { size: 9999, 'point.lat': 0, 'point.lon': 0 } };
sanitize(req, sanitizer_list, () => {
t.equal(req.clean.size, 40, 'max size set');
t.end();
});
});
};
module.exports.tests.sanitize_private = function(test, common) {
var invalid_values = [null, -1, 123, NaN, 'abc'];
invalid_values.forEach(function(value) {
test('invalid private param ' + value, function(t) {
var req = { query: { 'point.lat': 0, 'point.lon': 0, 'private': value } };
sanitize(req, sanitizer_list, () => {
t.equal(req.clean.private, false, 'default private set (to false)');
t.end();
});
});
});
var valid_values = ['true', true, 1, '1'];
valid_values.forEach(function(value) {
test('valid private param ' + value, function(t) {
var req = { query: { 'point.lat': 0, 'point.lon': 0, 'private': value } };
sanitize(req, sanitizer_list, () => {
t.equal(req.clean.private, true, 'private set to true');
t.end();
});
});
});
var valid_false_values = ['false', false, 0];
valid_false_values.forEach(function(value) {
test('test setting false explicitly ' + value, function(t) {
var req = { query: { 'point.lat': 0, 'point.lon': 0, 'private': value } };
sanitize(req, sanitizer_list, () => {
t.equal(req.clean.private, false, 'private set to false');
t.end();
});
});
});
test('test default behavior', function(t) {
var req = { query: { 'point.lat': 0, 'point.lon': 0 } };
sanitize(req, sanitizer_list, () => {
t.equal(req.clean.private, false, 'private set to false');
t.end();
});
});
};
module.exports.tests.middleware_success = function(test, common) {
test('middleware success', function(t) {
var req = { query: { 'point.lat': 0, 'point.lon': 0 }};
var next = function(){
t.deepEqual(req.errors, [], 'no error message set');
t.deepEqual(req.clean, defaultClean);
t.end();
};
middleware( req, undefined, next );
});
}; };
module.exports.all = function (tape, common) { module.exports.all = function (tape, common) {

Write Preview
Loading…
Cancel
Save