Browse Source

Merge pull request #914 from pelias/master

Merge master into staging
pull/916/head
Diana Shkolnikov 8 years ago committed by GitHub
parent
commit
57d2e0407e
  1. 1
      .lgtm
  2. 11
      README.md
  3. 123
      controller/coarse_reverse.js
  4. 2
      controller/predicates/is_coarse_reverse.js
  5. 2
      helper/geojsonify.js
  6. 10
      package.json
  7. 4
      query/reverse.js
  8. 2
      query/reverse_defaults.js
  9. 20
      routes/v1.js
  10. 7
      sanitizer/_geo_reverse.js
  11. 25
      sanitizer/_geonames_deprecation.js
  12. 1
      sanitizer/reverse.js
  13. 11
      schema.js
  14. 2
      service/configurations/PlaceHolder.js
  15. 21
      service/configurations/PointInPolygon.js
  16. 86
      service/pointinpolygon.js
  17. 39
      test/ciao/reverse/boundary_circle_valid_radius_coarse.coffee
  18. 492
      test/unit/controller/coarse_reverse.js
  19. 7
      test/unit/fixture/reverse_null_island.js
  20. 7
      test/unit/fixture/reverse_standard.js
  21. 7
      test/unit/fixture/reverse_with_boundary_country.js
  22. 4
      test/unit/fixture/reverse_with_layer_filtering.js
  23. 41
      test/unit/fixture/reverse_with_layer_filtering_non_coarse_subset.js
  24. 7
      test/unit/fixture/reverse_with_source_filtering.js
  25. 45
      test/unit/query/reverse.js
  26. 3
      test/unit/run.js
  27. 118
      test/unit/sanitizer/_geo_reverse.js
  28. 82
      test/unit/sanitizer/_geonames_deprecation.js
  29. 3
      test/unit/sanitizer/nearby.js
  30. 3
      test/unit/sanitizer/reverse.js
  31. 302
      test/unit/schema.js
  32. 6
      test/unit/service/configurations/PlaceHolder.js
  33. 101
      test/unit/service/configurations/PointInPolygon.js
  34. 323
      test/unit/service/pointinpolygon.js

1
.lgtm

@ -1 +0,0 @@
pattern = "(?i):shipit:|:\\+1:|LGTM"

11
README.md

@ -45,7 +45,7 @@ The API recognizes the following properties under the top-level `api` key in you
|`legacyUrl`|*no*||the url to redirect to in case the user does not specify a version such as `v1` |`legacyUrl`|*no*||the url to redirect to in case the user does not specify a version such as `v1`
|`relativeScores`|*no*|true|if set to true, confidence scores will be normalized, realistically at this point setting this to false is not tested or desirable |`relativeScores`|*no*|true|if set to true, confidence scores will be normalized, realistically at this point setting this to false is not tested or desirable
|`accessLog`|*no*||name of the format to use for access logs; may be any one of the [predefined values](https://github.com/expressjs/morgan#predefined-formats) in the `morgan` package. Defaults to `"common"`; if set to `false`, or an otherwise falsy value, disables access-logging entirely.| |`accessLog`|*no*||name of the format to use for access logs; may be any one of the [predefined values](https://github.com/expressjs/morgan#predefined-formats) in the `morgan` package. Defaults to `"common"`; if set to `false`, or an otherwise falsy value, disables access-logging entirely.|
|`pipService`|*yes*||full url to the pip service to be used for coarse reverse queries. if missing, which is not recommended, the service will default to using nearby lookups instead of point-in-polygon.| |`services`|*no*||service definitions for [point-in-polygon](https://github.com/pelias/pip-service) and [placholder](https://github.com/pelias/placeholder) services. If missing (which is not recommended), the point-in-polygon and placeholder services will not be called.|
Example configuration file would look something like this: Example configuration file would look something like this:
@ -68,7 +68,14 @@ Example configuration file would look something like this:
"legacyUrl": "pelias.mapzen.com", "legacyUrl": "pelias.mapzen.com",
"relativeScores": true, "relativeScores": true,
"textAnalyzer": "libpostal", "textAnalyzer": "libpostal",
"pipService": "http://mypipservice.com/3000" "services": {
"pip": {
"url": "http://mypipservice.com:3000"
},
"placeholder": {
"url": "http://myplaceholderservice.com:5000"
}
}
}, },
"interpolation": { "interpolation": {
"client": { "client": {

123
controller/coarse_reverse.js

@ -1,9 +1,9 @@
const logger = require('pelias-logger').get('coarse_reverse'); const logger = require('pelias-logger').get('coarse_reverse');
const _ = require('lodash'); const _ = require('lodash');
const Document = require('pelias-model').Document; const Document = require('pelias-model').Document;
const isDNT = require('../helper/logging').isDNT;
const granularities = [ // do not change order, other functionality depends on most-to-least granular order
const coarse_granularities = [
'neighbourhood', 'neighbourhood',
'borough', 'borough',
'locality', 'locality',
@ -16,60 +16,79 @@ const granularities = [
'country' 'country'
]; ];
function getMostGranularLayer(results) { // remove non-coarse layers and return what's left (or all if empty)
return granularities.find((granularity) => { function getEffectiveLayers(requested_layers) {
return results.hasOwnProperty(granularity); // remove non-coarse layers
const non_coarse_layers_removed = _.without(requested_layers, 'venue', 'address', 'street');
// if resulting array is empty, use all coarse granularities
if (_.isEmpty(non_coarse_layers_removed)) {
return coarse_granularities;
}
// otherwise use requested layers with non-coarse layers removed
return non_coarse_layers_removed;
}
// drop from coarse_granularities until there's one that was requested
// this depends on coarse_granularities being ordered
function getApplicableRequestedLayers(requested_layers) {
return _.dropWhile(coarse_granularities, (coarse_granularity) => {
return !_.includes(requested_layers, coarse_granularity);
}); });
} }
function hasResultsAtRequestedLayers(results, layers) { // removing non-coarse layers could leave effective_layers empty, so it's
return _.intersection(layers, Object.keys(results)).length > 0; // important to check for empty layers here
function hasResultsAtRequestedLayers(results, requested_layers) {
return !_.isEmpty(_.intersection(_.keys(results), requested_layers));
}
// get the most granular layer from the results by taking the head of the intersection
// of coarse_granularities (which are ordered) and the result layers
// ['neighbourhood', 'borough', 'locality'] - ['locality', 'borough'] = 'borough'
// this depends on coarse_granularities being ordered
function getMostGranularLayerOfResult(result_layers) {
return _.head(_.intersection(coarse_granularities, result_layers));
} }
// create a model.Document from what's left, using the most granular
// result available as the starting point
function synthesizeDoc(results) { function synthesizeDoc(results) {
// now create a model.Document from what's level, using the most granular // find the most granular layer to use as the document layer
// result available as the starting point const most_granular_layer = getMostGranularLayerOfResult(_.keys(results));
// the immediately above cannot be re-used since county may be the most
// granular layer requested but the results may start at region (no county found)
const most_granular_layer = getMostGranularLayer(results);
const id = results[most_granular_layer][0].id; const id = results[most_granular_layer][0].id;
const doc = new Document('whosonfirst', most_granular_layer, id.toString()); const doc = new Document('whosonfirst', most_granular_layer, id.toString());
doc.setName('default', results[most_granular_layer][0].name); doc.setName('default', results[most_granular_layer][0].name);
if (results[most_granular_layer][0].hasOwnProperty('centroid')) { // assign the administrative hierarchy
_.keys(results).forEach((layer) => {
doc.addParent(layer, results[layer][0].name, results[layer][0].id.toString(), results[layer][0].abbr);
});
// set centroid if available
if (_.has(results[most_granular_layer][0], 'centroid')) {
doc.setCentroid( results[most_granular_layer][0].centroid ); doc.setCentroid( results[most_granular_layer][0].centroid );
} }
if (results[most_granular_layer][0].hasOwnProperty('bounding_box')) { // set bounding box if available
const parsedBoundingBox = results[most_granular_layer][0].bounding_box.split(',').map(parseFloat); if (_.has(results[most_granular_layer][0], 'bounding_box')) {
const parsed_bounding_box = results[most_granular_layer][0].bounding_box.split(',').map(parseFloat);
doc.setBoundingBox({ doc.setBoundingBox({
upperLeft: { upperLeft: {
lat: parsedBoundingBox[3], lat: parsed_bounding_box[3],
lon: parsedBoundingBox[0] lon: parsed_bounding_box[0]
}, },
lowerRight: { lowerRight: {
lat: parsedBoundingBox[1], lat: parsed_bounding_box[1],
lon: parsedBoundingBox[2] lon: parsed_bounding_box[2]
} }
}); });
} }
if (_.has(results, 'country[0].abbr')) {
doc.setAlpha3(results.country[0].abbr);
}
// assign the administrative hierarchy
Object.keys(results).forEach((layer) => {
if (results[layer][0].hasOwnProperty('abbr')) {
doc.addParent(layer, results[layer][0].name, results[layer][0].id.toString(), results[layer][0].abbr);
} else {
doc.addParent(layer, results[layer][0].name, results[layer][0].id.toString());
}
});
const esDoc = doc.toESDocument(); const esDoc = doc.toESDocument();
esDoc.data._id = esDoc._id; esDoc.data._id = esDoc._id;
esDoc.data._type = esDoc._type; esDoc.data._type = esDoc._type;
@ -84,12 +103,21 @@ function setup(service, should_execute) {
return next(); return next();
} }
// return a warning to the caller that boundary.circle.radius will be ignored
if (!_.isUndefined(req.clean['boundary.circle.radius'])) {
req.warnings.push('boundary.circle.radius is not applicable for coarse reverse');
}
// because coarse reverse is called when non-coarse reverse didn't return
// anything, treat requested layers as if it didn't contain non-coarse layers
const effective_layers = getEffectiveLayers(req.clean.layers);
const centroid = { const centroid = {
lat: req.clean['point.lat'], lat: req.clean['point.lat'],
lon: req.clean['point.lon'] lon: req.clean['point.lon']
}; };
service(centroid, isDNT(req), (err, results) => { service(req, (err, results) => {
// if there's an error, log it and bail // if there's an error, log it and bail
if (err) { if (err) {
logger.info(`[controller:coarse_reverse][error]`); logger.info(`[controller:coarse_reverse][error]`);
@ -97,27 +125,20 @@ function setup(service, should_execute) {
return next(); return next();
} }
// find the finest granularity requested // log how many results there were
const finest_granularity_requested = granularities.findIndex((granularity) => { logger.info(`[controller:coarse_reverse][queryType:pip][result_count:${_.size(results)}]`);
return req.clean.layers.indexOf(granularity) !== -1;
});
logger.info(`[controller:coarse_reverse][queryType:pip][result_count:${Object.keys(results).length}]`); // now keep everything from the response that is equal to or less granular
// than the most granular layer requested. that is, if effective_layers=['county'],
// now remove everything from the response that is more granular than the // remove neighbourhoods, boroughs, localities, localadmins
// most granular layer requested. that is, if req.clean.layers=['county'], const applicable_results = _.pick(results, getApplicableRequestedLayers(effective_layers));
// remove neighbourhoods, localities, and localadmins
Object.keys(results).forEach((layer) => {
if (granularities.indexOf(layer) < finest_granularity_requested) {
delete results[layer];
}
});
res.meta = {}; res.meta = {};
res.data = []; res.data = [];
// synthesize a doc from results if there's a result at the request layer(s)
if (hasResultsAtRequestedLayers(results, req.clean.layers)) { // if there's a result at the requested layer(s), synthesize a doc from results
res.data.push(synthesizeDoc(results)); if (hasResultsAtRequestedLayers(applicable_results, effective_layers)) {
res.data.push(synthesizeDoc(applicable_results));
} }
return next(); return next();

2
controller/predicates/is_coarse_reverse.js

@ -5,5 +5,5 @@ const non_coarse_layers = ['address', 'street', 'venue'];
module.exports = (req, res) => { module.exports = (req, res) => {
// returns true if layers is undefined, empty, or contains 'address', 'street', or 'venue' // returns true if layers is undefined, empty, or contains 'address', 'street', or 'venue'
return !_.isEmpty(req.clean.layers) && return !_.isEmpty(req.clean.layers) &&
_.intersection(req.clean.layers, non_coarse_layers).length === 0; _.isEmpty(_.intersection(req.clean.layers, non_coarse_layers));
}; };

2
helper/geojsonify.js

@ -1,6 +1,6 @@
var GeoJSON = require('geojson'); var GeoJSON = require('geojson');
var extent = require('geojson-extent'); var extent = require('@mapbox/geojson-extent');
var logger = require('pelias-logger').get('api'); var logger = require('pelias-logger').get('api');
var type_mapping = require('./type_mapping'); var type_mapping = require('./type_mapping');
var _ = require('lodash'); var _ = require('lodash');

10
package.json

@ -46,7 +46,7 @@
"express-http-proxy": "^0.11.0", "express-http-proxy": "^0.11.0",
"extend": "^3.0.1", "extend": "^3.0.1",
"geojson": "^0.4.0", "geojson": "^0.4.0",
"geojson-extent": "^0.3.1", "@mapbox/geojson-extent": "^0.3.1",
"geolib": "^2.0.18", "geolib": "^2.0.18",
"iso-639-3": "^1.0.0", "iso-639-3": "^1.0.0",
"iso3166-1": "^0.3.0", "iso3166-1": "^0.3.0",
@ -55,18 +55,16 @@
"lodash": "^4.17.4", "lodash": "^4.17.4",
"markdown": "0.5.0", "markdown": "0.5.0",
"morgan": "^1.8.2", "morgan": "^1.8.2",
"pelias-config": "2.10.0",
"pelias-categories": "1.2.0", "pelias-categories": "1.2.0",
"pelias-config": "2.10.0", "pelias-config": "2.11.0",
"pelias-labels": "1.6.0", "pelias-labels": "1.6.0",
"pelias-logger": "0.2.0", "pelias-logger": "0.2.0",
"pelias-microservice-wrapper": "1.1.0", "pelias-microservice-wrapper": "1.1.2",
"pelias-model": "4.8.1", "pelias-model": "4.8.1",
"pelias-query": "8.15.0", "pelias-query": "8.15.0",
"pelias-sorting": "1.0.1", "pelias-sorting": "1.0.1",
"pelias-text-analyzer": "1.8.2", "pelias-text-analyzer": "1.8.3",
"predicates": "^1.0.1", "predicates": "^1.0.1",
"request": "^2.81.0",
"retry": "^0.10.1", "retry": "^0.10.1",
"stats-lite": "^2.0.4", "stats-lite": "^2.0.4",
"superagent": "^3.2.1", "superagent": "^3.2.1",

4
query/reverse.js

@ -3,6 +3,7 @@
const peliasQuery = require('pelias-query'); const peliasQuery = require('pelias-query');
const defaults = require('./reverse_defaults'); const defaults = require('./reverse_defaults');
const check = require('check-types'); const check = require('check-types');
const _ = require('lodash');
const logger = require('pelias-logger').get('api'); const logger = require('pelias-logger').get('api');
//------------------------------ //------------------------------
@ -44,7 +45,8 @@ function generateQuery( clean ){
// layers // layers
if( check.array(clean.layers) && clean.layers.length ) { if( check.array(clean.layers) && clean.layers.length ) {
vs.var( 'layers', clean.layers); // only include non-coarse layers
vs.var( 'layers', _.intersection(clean.layers, ['address', 'street', 'venue']));
logStr += '[param:layers] '; logStr += '[param:layers] ';
} }

2
query/reverse_defaults.js

@ -6,6 +6,7 @@ module.exports = _.merge({}, peliasQuery.defaults, {
'size': 1, 'size': 1,
'track_scores': true, 'track_scores': true,
'layers': ['venue', 'address', 'street'],
'centroid:field': 'center_point', 'centroid:field': 'center_point',
@ -13,7 +14,6 @@ module.exports = _.merge({}, peliasQuery.defaults, {
'sort:distance:distance_type': 'plane', 'sort:distance:distance_type': 'plane',
'boundary:circle:radius': '1km', 'boundary:circle:radius': '1km',
'boundary:circle:radius:coarse': '500km',
'boundary:circle:distance_type': 'plane', 'boundary:circle:distance_type': 'plane',
'boundary:circle:optimize_bbox': 'indexed', 'boundary:circle:optimize_bbox': 'indexed',

20
routes/v1.js

@ -78,6 +78,7 @@ const hasAdminOnlyResults = not(hasResultsAtLayers(['venue', 'address', 'street'
const serviceWrapper = require('pelias-microservice-wrapper').service; const serviceWrapper = require('pelias-microservice-wrapper').service;
const PlaceHolder = require('../service/configurations/PlaceHolder'); const PlaceHolder = require('../service/configurations/PlaceHolder');
const PointInPolygon = require('../service/configurations/PointInPolygon');
/** /**
* Append routes to app * Append routes to app
@ -88,16 +89,17 @@ const PlaceHolder = require('../service/configurations/PlaceHolder');
function addRoutes(app, peliasConfig) { function addRoutes(app, peliasConfig) {
const esclient = elasticsearch.Client(peliasConfig.esclient); const esclient = elasticsearch.Client(peliasConfig.esclient);
const isPipServiceEnabled = require('../controller/predicates/is_service_enabled')(peliasConfig.api.pipService); const pipConfiguration = new PointInPolygon(_.defaultTo(peliasConfig.api.services.pip, {}));
const pipService = serviceWrapper(pipConfiguration);
const isPipServiceEnabled = _.constant(pipConfiguration.isEnabled());
const pipService = require('../service/pointinpolygon')(peliasConfig.api.pipService); const placeholderConfiguration = new PlaceHolder(_.defaultTo(peliasConfig.api.services.placeholder, {}));
const placeholderConfiguration = new PlaceHolder(_.get(peliasConfig.api.services, 'placeholder', {}));
const placeholderService = serviceWrapper(placeholderConfiguration); const placeholderService = serviceWrapper(placeholderConfiguration);
const isPlaceholderServiceEnabled = _.constant(placeholderConfiguration.isEnabled()); const isPlaceholderServiceEnabled = _.constant(placeholderConfiguration.isEnabled());
const coarse_reverse_should_execute = all( // fallback to coarse reverse when regular reverse didn't return anything
not(hasRequestErrors), isPipServiceEnabled, isCoarseReverse const coarseReverseShouldExecute = all(
isPipServiceEnabled, not(hasRequestErrors), not(hasResponseData)
); );
const placeholderShouldExecute = all( const placeholderShouldExecute = all(
@ -107,7 +109,7 @@ function addRoutes(app, peliasConfig) {
// execute under the following conditions: // execute under the following conditions:
// - there are no errors or data // - there are no errors or data
// - request is not coarse OR pip service is disabled // - request is not coarse OR pip service is disabled
const original_reverse_should_execute = all( const nonCoarseReverseShouldExecute = all(
not(hasResponseDataOrRequestErrors), not(hasResponseDataOrRequestErrors),
any( any(
not(isCoarseReverse), not(isCoarseReverse),
@ -195,8 +197,8 @@ function addRoutes(app, peliasConfig) {
sanitizers.reverse.middleware, sanitizers.reverse.middleware,
middleware.requestLanguage, middleware.requestLanguage,
middleware.calcSize(), middleware.calcSize(),
controllers.coarse_reverse(pipService, coarse_reverse_should_execute), controllers.search(peliasConfig.api, esclient, queries.reverse, nonCoarseReverseShouldExecute),
controllers.search(peliasConfig.api, esclient, queries.reverse, original_reverse_should_execute), controllers.coarse_reverse(pipService, coarseReverseShouldExecute),
postProc.distances('point.'), postProc.distances('point.'),
// reverse confidence scoring depends on distance from origin // reverse confidence scoring depends on distance from origin
// so it must be calculated first // so it must be calculated first

7
sanitizer/_geo_reverse.js

@ -4,6 +4,8 @@ var defaults = require('../query/reverse_defaults');
var LAT_LON_IS_REQUIRED = true, var LAT_LON_IS_REQUIRED = true,
CIRCLE_IS_REQUIRED = false; CIRCLE_IS_REQUIRED = false;
const non_coarse_layers = ['venue', 'address', 'street'];
// validate inputs, convert types and apply defaults // validate inputs, convert types and apply defaults
module.exports = function sanitize( raw, clean ){ module.exports = function sanitize( raw, clean ){
@ -29,13 +31,8 @@ module.exports = function sanitize( raw, clean ){
// if no radius was passed, set the default // if no radius was passed, set the default
if ( _.isUndefined( raw['boundary.circle.radius'] ) ) { if ( _.isUndefined( raw['boundary.circle.radius'] ) ) {
// the default is small unless layers other than venue or address were explicitly specified
if (clean.layers && clean.layers.length > 0 && !_.includes(clean.layers, 'venue') && !_.includes(clean.layers, 'address')) {
raw['boundary.circle.radius'] = defaults['boundary:circle:radius:coarse'];
} else {
raw['boundary.circle.radius'] = defaults['boundary:circle:radius']; raw['boundary.circle.radius'] = defaults['boundary:circle:radius'];
} }
}
// santize the boundary.circle // santize the boundary.circle
geo_common.sanitize_circle( 'boundary.circle', clean, raw, CIRCLE_IS_REQUIRED ); geo_common.sanitize_circle( 'boundary.circle', clean, raw, CIRCLE_IS_REQUIRED );

25
sanitizer/_geonames_deprecation.js

@ -0,0 +1,25 @@
const _ = require('lodash');
/**
with the release of coarse reverse as a separate thing and ES reverse only
handling venues, addresses, and streets, geonames make no sense in the reverse context
**/
function sanitize( raw, clean, opts ) {
// error & warning messages
const messages = { errors: [], warnings: [] };
if (_.isEqual(clean.sources, ['geonames']) || _.isEqual(clean.sources, ['gn'])) {
messages.errors.push('/reverse does not support geonames');
} else if (_.includes(clean.sources, 'geonames') || _.includes(clean.sources, 'gn')) {
clean.sources = _.without(clean.sources, 'geonames', 'gn');
messages.warnings.push('/reverse does not support geonames');
}
return messages;
}
module.exports = sanitize;

1
sanitizer/reverse.js

@ -8,6 +8,7 @@ var sanitizeAll = require('../sanitizer/sanitizeAll'),
sources: require('../sanitizer/_targets')('sources', type_mapping.source_mapping), sources: require('../sanitizer/_targets')('sources', type_mapping.source_mapping),
// depends on the layers and sources sanitizers, must be run after them // depends on the layers and sources sanitizers, must be run after them
sources_and_layers: require('../sanitizer/_sources_and_layers'), sources_and_layers: require('../sanitizer/_sources_and_layers'),
geonames_deprecation: require('../sanitizer/_geonames_deprecation'),
size: require('../sanitizer/_size')(/* use defaults*/), size: require('../sanitizer/_size')(/* use defaults*/),
private: require('../sanitizer/_flag_bool')('private', false), private: require('../sanitizer/_flag_bool')('private', false),
geo_reverse: require('../sanitizer/_geo_reverse'), geo_reverse: require('../sanitizer/_geo_reverse'),

11
schema.js

@ -26,11 +26,18 @@ module.exports = Joi.object().keys({
localization: Joi.object().keys({ localization: Joi.object().keys({
flipNumberAndStreetCountries: Joi.array().items(Joi.string().regex(/^[A-Z]{3}$/)) flipNumberAndStreetCountries: Joi.array().items(Joi.string().regex(/^[A-Z]{3}$/))
}).unknown(false), }).unknown(false),
pipService: Joi.string().uri({ scheme: /https?/ }), pipService: Joi.any(), // got moved to services, ignored for now
placeholderService: Joi.any().forbidden(), // got moved to services placeholderService: Joi.any().forbidden(), // got moved to services
services: Joi.object().keys({ services: Joi.object().keys({
pip: Joi.object().keys({
url: Joi.string().uri({ scheme: /https?/ }),
timeout: Joi.number().integer().optional().default(250).min(0),
retries: Joi.number().integer().optional().default(3).min(0),
}).unknown(false).requiredKeys('url'),
placeholder: Joi.object().keys({ placeholder: Joi.object().keys({
url: Joi.string().uri({ scheme: /https?/ }) url: Joi.string().uri({ scheme: /https?/ }),
timeout: Joi.number().integer().optional().default(250).min(0),
retries: Joi.number().integer().optional().default(3).min(0),
}).unknown(false).requiredKeys('url') }).unknown(false).requiredKeys('url')
}).unknown(false).default({}) // default api.services to an empty object }).unknown(false).default({}) // default api.services to an empty object

2
service/configurations/PlaceHolder.js

@ -24,7 +24,7 @@ class PlaceHolder extends ServiceConfiguration {
} }
getUrl(req) { getUrl(req) {
return url.resolve(this.baseUrl, 'search'); return url.resolve(this.baseUrl, 'parser/search');
} }
} }

21
service/configurations/PointInPolygon.js

@ -0,0 +1,21 @@
'use strict';
const url = require('url');
const _ = require('lodash');
const ServiceConfiguration = require('pelias-microservice-wrapper').ServiceConfiguration;
class PointInPolygon extends ServiceConfiguration {
constructor(o) {
super('pip', o);
}
getUrl(req) {
// use resolve to eliminate possibility of duplicate /'s in URL
return url.resolve(this.baseUrl, `${req.clean['point.lon']}/${req.clean['point.lat']}`);
}
}
module.exports = PointInPolygon;

86
service/pointinpolygon.js

@ -1,86 +0,0 @@
const logger = require( 'pelias-logger' ).get( 'pointinpolygon' );
const request = require('request');
const _ = require('lodash');
function sanitizeUrl(requestUrl) {
return requestUrl.replace(/^(.+)\/.+\/.+$/, (match, base) => {
return `${base}/[removed]/[removed]`;
});
}
function parseErrorMessage(requestUrl, body, do_not_track) {
if (do_not_track) {
return `${sanitizeUrl(requestUrl)} returned status 200 but with non-JSON response: ${body}`;
}
return `${requestUrl} returned status 200 but with non-JSON response: ${body}`;
}
function serviceErrorMessage(requestUrl, statusCode, body, do_not_track) {
if (do_not_track) {
return `${sanitizeUrl(requestUrl)} returned status ${statusCode}: ${body}`;
} else {
return `${requestUrl} returned status ${statusCode}: ${body}`;
}
}
module.exports = (url) => {
if (!_.isEmpty(url)) {
logger.info(`using point-in-polygon service at ${url}`);
return function pointinpolygon( centroid, do_not_track, callback ) {
const requestUrl = `${url}/${centroid.lon}/${centroid.lat}`;
const options = {
method: 'GET',
url: requestUrl
};
if (do_not_track) {
options.headers = {
dnt: '1'
};
}
request(options, (err, response, body) => {
if (err) {
logger.error(JSON.stringify(err));
callback(err);
}
else if (response.statusCode === 200) {
try {
const parsed = JSON.parse(body);
callback(err, parsed);
}
catch (err) {
const parseMsg = parseErrorMessage(requestUrl, body, do_not_track);
logger.error(parseMsg);
callback(parseMsg);
}
}
else {
const errorMsg = serviceErrorMessage(requestUrl, response.statusCode, body, do_not_track);
logger.error(errorMsg);
callback(errorMsg);
}
});
};
} else {
logger.warn('point-in-polygon service disabled');
return (centroid, do_not_track, callback) => {
callback(`point-in-polygon service disabled, unable to resolve ` +
(do_not_track ? 'centroid' : JSON.stringify(centroid)));
};
}
};

39
test/ciao/reverse/boundary_circle_valid_radius_coarse.coffee

@ -0,0 +1,39 @@
#> bounding circle
path: '/v1/reverse?layers=coarse&point.lat=40.744243&point.lon=-73.990342&boundary.circle.radius=999.9'
#? 200 ok
response.statusCode.should.be.equal 200
response.should.have.header 'charset', 'utf8'
response.should.have.header 'content-type', 'application/json; charset=utf-8'
#? valid geocoding block
should.exist json.geocoding
should.exist json.geocoding.version
should.exist json.geocoding.attribution
should.exist json.geocoding.query
should.exist json.geocoding.engine
should.exist json.geocoding.engine.name
should.exist json.geocoding.engine.author
should.exist json.geocoding.engine.version
should.exist json.geocoding.timestamp
#? valid geojson
json.type.should.be.equal 'FeatureCollection'
json.features.should.be.instanceof Array
#? expected errors
should.not.exist json.geocoding.errors
#? expected warnings
should.exist json.geocoding.warnings
json.geocoding.warnings.should.eql [ 'boundary.circle.radius is not applicable for coarse reverse' ]
#? inputs
json.geocoding.query['size'].should.eql 10
json.geocoding.query['layers'].should.eql 'coarse'
json.geocoding.query['point.lat'].should.eql 40.744243
json.geocoding.query['point.lon'].should.eql -73.990342
json.geocoding.query['boundary.circle.lat'].should.eql 40.744243
json.geocoding.query['boundary.circle.lon'].should.eql -73.990342
json.geocoding.query['boundary.circle.radius'].should.eql 999.9

492
test/unit/controller/coarse_reverse.js

@ -2,6 +2,7 @@
const setup = require('../../../controller/coarse_reverse'); const setup = require('../../../controller/coarse_reverse');
const proxyquire = require('proxyquire').noCallThru(); const proxyquire = require('proxyquire').noCallThru();
const _ = require('lodash');
module.exports.tests = {}; module.exports.tests = {};
@ -15,12 +16,13 @@ module.exports.tests.interface = (test, common) => {
module.exports.tests.early_exit_conditions = (test, common) => { module.exports.tests.early_exit_conditions = (test, common) => {
test('should_execute returning false should not call service', (t) => { test('should_execute returning false should not call service', (t) => {
t.plan(2);
const service = () => { const service = () => {
throw Error('service should not have been called'); throw Error('service should not have been called');
}; };
const should_execute = () => { return false; }; const controller = setup(service, _.constant(false));
const controller = setup(service, should_execute);
const req = { const req = {
clean: { clean: {
@ -30,14 +32,12 @@ module.exports.tests.early_exit_conditions = (test, common) => {
}; };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() was called');
}; };
// passing res=undefined verifies that it wasn't interacted with // passing res=undefined verifies that it wasn't interacted with
t.doesNotThrow(controller.bind(null, req, undefined, next)); t.doesNotThrow(controller.bind(null, req, undefined, next));
t.ok(next_was_called);
t.end(); t.end();
}); });
@ -46,44 +46,108 @@ module.exports.tests.early_exit_conditions = (test, common) => {
module.exports.tests.error_conditions = (test, common) => { module.exports.tests.error_conditions = (test, common) => {
test('service error should log and call next', (t) => { test('service error should log and call next', (t) => {
const service = (point, do_not_track, callback) => { t.plan(3);
t.equals(do_not_track, 'do_not_track value');
const service = (req, callback) => {
t.deepEquals(req, { clean: { layers: ['locality'] } } );
callback('this is an error'); callback('this is an error');
}; };
const logger = require('pelias-mock-logger')(); const logger = require('pelias-mock-logger')();
const should_execute = () => { return true; };
const controller = proxyquire('../../../controller/coarse_reverse', { const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger, 'pelias-logger': logger
'../helper/logging': { })(service, _.constant(true));
isDNT: () => {
return 'do_not_track value';
}
}
})(service, should_execute);
const req = { const req = {
clean: { clean: {
layers: ['locality'], layers: ['locality']
point: {
lat: 12.121212,
lon: 21.212121
}
} }
}; };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() was called');
}; };
// passing res=undefined verifies that it wasn't interacted with // passing res=undefined verifies that it wasn't interacted with
controller(req, undefined, next); controller(req, undefined, next);
t.ok(logger.isErrorMessage('this is an error')); t.ok(logger.isErrorMessage('this is an error'));
t.ok(next_was_called); t.end();
});
};
module.exports.tests.boundary_circle_radius_warnings = (test, common) => {
test('defined clean[boundary.circle.radius] should add a warning', (t) => {
const service = (req, callback) => {
callback(undefined, {});
};
const logger = require('pelias-mock-logger')();
const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger
})(service, _.constant(true));
const req = {
warnings: [],
clean: {
'boundary.circle.radius': 17
}
};
const res = { };
const next = () => {};
controller(req, res, next);
const expected = {
meta: {},
data: []
};
t.deepEquals(req.warnings, ['boundary.circle.radius is not applicable for coarse reverse']);
t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages());
t.end();
});
test('defined clean[boundary.circle.radius] should add a warning', (t) => {
const service = (req, callback) => {
callback(undefined, {});
};
const logger = require('pelias-mock-logger')();
const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger
})(service, _.constant(true));
const req = {
warnings: [],
clean: {}
};
const res = { };
// verify that next was called
const next = () => { };
controller(req, res, next);
const expected = {
meta: {},
data: []
};
t.deepEquals(req.warnings, []);
t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages());
t.end(); t.end();
}); });
@ -92,8 +156,11 @@ module.exports.tests.error_conditions = (test, common) => {
module.exports.tests.success_conditions = (test, common) => { module.exports.tests.success_conditions = (test, common) => {
test('service returning results should use first entry for each layer', (t) => { test('service returning results should use first entry for each layer', (t) => {
const service = (point, do_not_track, callback) => { t.plan(4);
t.equals(do_not_track, 'do_not_track value');
const service = (req, callback) => {
t.deepEquals(req, { clean: { layers: ['neighbourhood'] } } );
const results = { const results = {
neighbourhood: [ neighbourhood: [
{ {
@ -151,32 +218,21 @@ module.exports.tests.success_conditions = (test, common) => {
const logger = require('pelias-mock-logger')(); const logger = require('pelias-mock-logger')();
const should_execute = () => { return true; };
const controller = proxyquire('../../../controller/coarse_reverse', { const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger, 'pelias-logger': logger
'../helper/logging': { })(service, _.constant(true));
isDNT: () => {
return 'do_not_track value';
}
}
})(service, should_execute);
const req = { const req = {
clean: { clean: {
layers: ['neighbourhood'], layers: ['neighbourhood']
point: {
lat: 12.121212,
lon: 21.212121
}
} }
}; };
const res = { }; const res = { };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() was called');
}; };
controller(req, res, next); controller(req, res, next);
@ -228,7 +284,6 @@ module.exports.tests.success_conditions = (test, common) => {
country_id: ['100'], country_id: ['100'],
country_a: ['xyz'] country_a: ['xyz']
}, },
alpha3: 'XYZ',
center_point: { center_point: {
lat: 12.121212, lat: 12.121212,
lon: 21.212121 lon: 21.212121
@ -239,22 +294,22 @@ module.exports.tests.success_conditions = (test, common) => {
}; };
t.deepEquals(res, expected); t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages()); t.notOk(logger.hasErrorMessages());
t.ok(next_was_called);
t.end(); t.end();
}); });
test('layers missing from results should be ignored', (t) => { test('layers missing from results should be ignored', (t) => {
const service = (point, do_not_track, callback) => { t.plan(4);
t.equals(do_not_track, 'do_not_track value');
const service = (req, callback) => {
t.deepEquals(req, { clean: { layers: ['neighbourhood'] } } );
const results = { const results = {
neighbourhood: [ neighbourhood: [
{ {
id: 10, id: 10,
name: 'neighbourhood name', name: 'neighbourhood name',
abbr: 'neighbourhood abbr',
centroid: { centroid: {
lat: 12.121212, lat: 12.121212,
lon: 21.212121 lon: 21.212121
@ -269,32 +324,21 @@ module.exports.tests.success_conditions = (test, common) => {
const logger = require('pelias-mock-logger')(); const logger = require('pelias-mock-logger')();
const should_execute = () => { return true; };
const controller = proxyquire('../../../controller/coarse_reverse', { const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger, 'pelias-logger': logger
'../helper/logging': { })(service, _.constant(true));
isDNT: () => {
return 'do_not_track value';
}
}
})(service, should_execute);
const req = { const req = {
clean: { clean: {
layers: ['neighbourhood'], layers: ['neighbourhood']
point: {
lat: 12.121212,
lon: 21.212121
}
} }
}; };
const res = { }; const res = { };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() was called');
}; };
controller(req, res, next); controller(req, res, next);
@ -317,7 +361,7 @@ module.exports.tests.success_conditions = (test, common) => {
parent: { parent: {
neighbourhood: ['neighbourhood name'], neighbourhood: ['neighbourhood name'],
neighbourhood_id: ['10'], neighbourhood_id: ['10'],
neighbourhood_a: ['neighbourhood abbr'] neighbourhood_a: [null]
}, },
center_point: { center_point: {
lat: 12.121212, lat: 12.121212,
@ -329,16 +373,17 @@ module.exports.tests.success_conditions = (test, common) => {
}; };
t.deepEquals(res, expected); t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages()); t.notOk(logger.hasErrorMessages());
t.ok(next_was_called);
t.end(); t.end();
}); });
test('most granular layer missing centroid should not set', (t) => { test('most granular layer missing centroid should not set', (t) => {
const service = (point, do_not_track, callback) => { t.plan(4);
t.equals(do_not_track, 'do_not_track value');
const service = (req, callback) => {
t.deepEquals(req, { clean: { layers: ['neighbourhood'] } } );
const results = { const results = {
neighbourhood: [ neighbourhood: [
{ {
@ -355,32 +400,21 @@ module.exports.tests.success_conditions = (test, common) => {
const logger = require('pelias-mock-logger')(); const logger = require('pelias-mock-logger')();
const should_execute = () => { return true; };
const controller = proxyquire('../../../controller/coarse_reverse', { const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger, 'pelias-logger': logger
'../helper/logging': { })(service, _.constant(true));
isDNT: () => {
return 'do_not_track value';
}
}
})(service, should_execute);
const req = { const req = {
clean: { clean: {
layers: ['neighbourhood'], layers: ['neighbourhood']
point: {
lat: 12.121212,
lon: 21.212121
}
} }
}; };
const res = { }; const res = { };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() was called');
}; };
controller(req, res, next); controller(req, res, next);
@ -411,16 +445,17 @@ module.exports.tests.success_conditions = (test, common) => {
}; };
t.deepEquals(res, expected); t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages()); t.notOk(logger.hasErrorMessages());
t.ok(next_was_called);
t.end(); t.end();
}); });
test('most granular layer missing bounding_box should not set', (t) => { test('most granular layer missing bounding_box should not set', (t) => {
const service = (point, do_not_track, callback) => { t.plan(4);
t.equals(do_not_track, 'do_not_track value');
const service = (req, callback) => {
t.deepEquals(req, { clean: { layers: ['neighbourhood'] } } );
const results = { const results = {
neighbourhood: [ neighbourhood: [
{ {
@ -440,19 +475,91 @@ module.exports.tests.success_conditions = (test, common) => {
const logger = require('pelias-mock-logger')(); const logger = require('pelias-mock-logger')();
const should_execute = () => { return true; };
const controller = proxyquire('../../../controller/coarse_reverse', { const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger, 'pelias-logger': logger
'../helper/logging': { })(service, _.constant(true));
isDNT: () => {
return 'do_not_track value'; const req = {
clean: {
layers: ['neighbourhood']
}
};
const res = { };
// verify that next was called
const next = () => {
t.pass('next() was called');
};
controller(req, res, next);
const expected = {
meta: {},
data: [
{
_id: '10',
_type: 'neighbourhood',
layer: 'neighbourhood',
source: 'whosonfirst',
source_id: '10',
name: {
'default': 'neighbourhood name'
},
phrase: {
'default': 'neighbourhood name'
},
parent: {
neighbourhood: ['neighbourhood name'],
neighbourhood_id: ['10'],
neighbourhood_a: ['neighbourhood abbr']
},
center_point: {
lat: 12.121212,
lon: 21.212121
}
} }
]
};
t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages());
t.end();
});
test('no requested layers should use everything', (t) => {
// this test is used to test coarse reverse fallback for when non-coarse reverse
// was requested but no non-coarse results were found
// by plan'ing the number of tests, we can verify that next() was called w/o
// additional bookkeeping
t.plan(4);
const service = (req, callback) => {
const results = {
neighbourhood: [
{
id: 10,
name: 'neighbourhood name',
abbr: 'neighbourhood abbr'
} }
})(service, should_execute); ]
};
callback(undefined, results);
};
const logger = require('pelias-mock-logger')();
const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger
})(service, _.constant(true));
const req = { const req = {
clean: { clean: {
layers: ['neighbourhood'], layers: [],
point: { point: {
lat: 12.121212, lat: 12.121212,
lon: 21.212121 lon: 21.212121
@ -463,9 +570,8 @@ module.exports.tests.success_conditions = (test, common) => {
const res = { }; const res = { };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() should have been called');
}; };
controller(req, res, next); controller(req, res, next);
@ -489,19 +595,183 @@ module.exports.tests.success_conditions = (test, common) => {
neighbourhood: ['neighbourhood name'], neighbourhood: ['neighbourhood name'],
neighbourhood_id: ['10'], neighbourhood_id: ['10'],
neighbourhood_a: ['neighbourhood abbr'] neighbourhood_a: ['neighbourhood abbr']
}, }
center_point: { }
]
};
t.deepEquals(req.clean.layers, [], 'req.clean.layers should be unmodified');
t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages());
t.end();
});
test('layers specifying only venue, address, or street should not exclude coarse results', (t) => {
// this test is used to test coarse reverse fallback for when non-coarse reverse
// was requested but no non-coarse results were found
const non_coarse_layers = ['venue', 'address', 'street'];
const tests_per_non_coarse_layer = 4;
// by plan'ing the number of tests, we can verify that next() was called w/o
// additional bookkeeping
t.plan(non_coarse_layers.length * tests_per_non_coarse_layer);
non_coarse_layers.forEach((non_coarse_layer) => {
const service = (req, callback) => {
const results = {
neighbourhood: [
{
id: 10,
name: 'neighbourhood name',
abbr: 'neighbourhood abbr'
}
]
};
callback(undefined, results);
};
const logger = require('pelias-mock-logger')();
const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger
})(service, _.constant(true));
const req = {
clean: {
layers: [non_coarse_layer],
point: {
lat: 12.121212, lat: 12.121212,
lon: 21.212121 lon: 21.212121
} }
} }
};
const res = { };
// verify that next was called
const next = () => {
t.pass('next() should have been called');
};
controller(req, res, next);
const expected = {
meta: {},
data: [
{
_id: '10',
_type: 'neighbourhood',
layer: 'neighbourhood',
source: 'whosonfirst',
source_id: '10',
name: {
'default': 'neighbourhood name'
},
phrase: {
'default': 'neighbourhood name'
},
parent: {
neighbourhood: ['neighbourhood name'],
neighbourhood_id: ['10'],
neighbourhood_a: ['neighbourhood abbr']
}
}
] ]
}; };
t.deepEquals(req.clean.layers, [non_coarse_layer], 'req.clean.layers should be unmodified');
t.deepEquals(res, expected); t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages());
});
t.end();
});
test('layers specifying venue, address, or street AND coarse layer should not exclude coarse results', (t) => {
// this test is used to test coarse reverse fallback for when non-coarse reverse
// was requested but no non-coarse results were found
const non_coarse_layers = ['venue', 'address', 'street'];
const tests_per_non_coarse_layer = 4;
// by plan'ing the number of tests, we can verify that next() was called w/o
// additional bookkeeping
t.plan(non_coarse_layers.length * tests_per_non_coarse_layer);
non_coarse_layers.forEach((non_coarse_layer) => {
const service = (req, callback) => {
const results = {
neighbourhood: [
{
id: 10,
name: 'neighbourhood name',
abbr: 'neighbourhood abbr'
}
]
};
callback(undefined, results);
};
const logger = require('pelias-mock-logger')();
const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger
})(service, _.constant(true));
const req = {
clean: {
layers: [non_coarse_layer, 'neighbourhood'],
point: {
lat: 12.121212,
lon: 21.212121
}
}
};
const res = { };
// verify that next was called
const next = () => {
t.pass('next() should have been called');
};
controller(req, res, next);
const expected = {
meta: {},
data: [
{
_id: '10',
_type: 'neighbourhood',
layer: 'neighbourhood',
source: 'whosonfirst',
source_id: '10',
name: {
'default': 'neighbourhood name'
},
phrase: {
'default': 'neighbourhood name'
},
parent: {
neighbourhood: ['neighbourhood name'],
neighbourhood_id: ['10'],
neighbourhood_a: ['neighbourhood abbr']
}
}
]
};
t.deepEquals(req.clean.layers, [non_coarse_layer, 'neighbourhood'], 'req.clean.layers should be unmodified');
t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages()); t.notOk(logger.hasErrorMessages());
t.ok(next_was_called);
});
t.end(); t.end();
}); });
@ -510,8 +780,11 @@ module.exports.tests.success_conditions = (test, common) => {
module.exports.tests.failure_conditions = (test, common) => { module.exports.tests.failure_conditions = (test, common) => {
test('service returning 0 results at the requested layer should return nothing', (t) => { test('service returning 0 results at the requested layer should return nothing', (t) => {
const service = (point, do_not_track, callback) => { t.plan(4);
t.equals(do_not_track, 'do_not_track value');
const service = (req, callback) => {
t.deepEquals(req, { clean: { layers: ['neighbourhood'] } } );
// response without neighbourhood results // response without neighbourhood results
const results = { const results = {
borough: [ borough: [
@ -557,32 +830,21 @@ module.exports.tests.failure_conditions = (test, common) => {
const logger = require('pelias-mock-logger')(); const logger = require('pelias-mock-logger')();
const should_execute = () => { return true; };
const controller = proxyquire('../../../controller/coarse_reverse', { const controller = proxyquire('../../../controller/coarse_reverse', {
'pelias-logger': logger, 'pelias-logger': logger
'../helper/logging': { })(service, _.constant(true));
isDNT: () => {
return 'do_not_track value';
}
}
})(service, should_execute);
const req = { const req = {
clean: { clean: {
layers: ['neighbourhood'], layers: ['neighbourhood']
point: {
lat: 12.121212,
lon: 21.212121
}
} }
}; };
const res = { }; const res = { };
// verify that next was called // verify that next was called
let next_was_called = false;
const next = () => { const next = () => {
next_was_called = true; t.pass('next() was called');
}; };
controller(req, res, next); controller(req, res, next);
@ -593,9 +855,7 @@ module.exports.tests.failure_conditions = (test, common) => {
}; };
t.deepEquals(res, expected); t.deepEquals(res, expected);
t.notOk(logger.hasErrorMessages()); t.notOk(logger.hasErrorMessages());
t.ok(next_was_called);
t.end(); t.end();
}); });

7
test/unit/fixture/reverse_null_island.js

@ -5,7 +5,7 @@ module.exports = {
'bool': { 'bool': {
'filter': [{ 'filter': [{
'geo_distance': { 'geo_distance': {
'distance': '500km', 'distance': '3km',
'distance_type': 'plane', 'distance_type': 'plane',
'optimize_bbox': 'indexed', 'optimize_bbox': 'indexed',
'center_point': { 'center_point': {
@ -13,6 +13,11 @@ module.exports = {
'lon': 0 'lon': 0
} }
} }
},
{
'terms': {
'layer': ['venue', 'address', 'street']
}
}] }]
} }
}, },

7
test/unit/fixture/reverse_standard.js

@ -5,7 +5,7 @@ module.exports = {
'bool': { 'bool': {
'filter': [{ 'filter': [{
'geo_distance': { 'geo_distance': {
'distance': '500km', 'distance': '3km',
'distance_type': 'plane', 'distance_type': 'plane',
'optimize_bbox': 'indexed', 'optimize_bbox': 'indexed',
'center_point': { 'center_point': {
@ -13,6 +13,11 @@ module.exports = {
'lon': -82.50622 'lon': -82.50622
} }
} }
},
{
'terms': {
'layer': ['venue', 'address', 'street']
}
}] }]
} }
}, },

7
test/unit/fixture/reverse_with_boundary_country.js

@ -15,7 +15,7 @@ module.exports = {
], ],
'filter': [{ 'filter': [{
'geo_distance': { 'geo_distance': {
'distance': '500km', 'distance': '3km',
'distance_type': 'plane', 'distance_type': 'plane',
'optimize_bbox': 'indexed', 'optimize_bbox': 'indexed',
'center_point': { 'center_point': {
@ -23,6 +23,11 @@ module.exports = {
'lon': -82.50622 'lon': -82.50622
} }
} }
},
{
'terms': {
'layer': ['venue', 'address', 'street']
}
}] }]
} }
}, },

4
test/unit/fixture/reverse_with_layer_filtering.js

@ -6,7 +6,7 @@ module.exports = {
'filter': [ 'filter': [
{ {
'geo_distance': { 'geo_distance': {
'distance': '500km', 'distance': '3km',
'distance_type': 'plane', 'distance_type': 'plane',
'optimize_bbox': 'indexed', 'optimize_bbox': 'indexed',
'center_point': { 'center_point': {
@ -17,7 +17,7 @@ module.exports = {
}, },
{ {
'terms': { 'terms': {
'layer': ['country'] 'layer': ['venue', 'address', 'street']
} }
} }
] ]

41
test/unit/fixture/reverse_with_layer_filtering_non_coarse_subset.js

@ -0,0 +1,41 @@
var vs = require('../../../query/reverse_defaults');
module.exports = {
'query': {
'bool': {
'filter': [
{
'geo_distance': {
'distance': '3km',
'distance_type': 'plane',
'optimize_bbox': 'indexed',
'center_point': {
'lat': 29.49136,
'lon': -82.50622
}
}
},
{
'terms': {
'layer': ['venue', 'street']
}
}
]
}
},
'sort': [
'_score',
{
'_geo_distance': {
'center_point': {
'lat': 29.49136,
'lon': -82.50622
},
'order': 'asc',
'distance_type': 'plane'
}
}
],
'size': vs.size,
'track_scores': true
};

7
test/unit/fixture/reverse_with_source_filtering.js

@ -6,7 +6,7 @@ module.exports = {
'filter': [ 'filter': [
{ {
'geo_distance': { 'geo_distance': {
'distance': '500km', 'distance': '3km',
'distance_type': 'plane', 'distance_type': 'plane',
'optimize_bbox': 'indexed', 'optimize_bbox': 'indexed',
'center_point': { 'center_point': {
@ -19,6 +19,11 @@ module.exports = {
'terms': { 'terms': {
'source': ['test'] 'source': ['test']
} }
},
{
'terms': {
'layer': ['venue', 'address', 'street']
}
} }
] ]
} }

45
test/unit/query/reverse.js

@ -16,7 +16,7 @@ module.exports.tests.query = function(test, common) {
'point.lon': -82.50622, 'point.lon': -82.50622,
'boundary.circle.lat': 29.49136, 'boundary.circle.lat': 29.49136,
'boundary.circle.lon': -82.50622, 'boundary.circle.lon': -82.50622,
'boundary.circle.radius': 500 'boundary.circle.radius': 3
}); });
var compiled = JSON.parse( JSON.stringify( query ) ); var compiled = JSON.parse( JSON.stringify( query ) );
@ -33,7 +33,7 @@ module.exports.tests.query = function(test, common) {
'point.lon': 0, 'point.lon': 0,
'boundary.circle.lat': 0, 'boundary.circle.lat': 0,
'boundary.circle.lon': 0, 'boundary.circle.lon': 0,
'boundary.circle.radius': 500 'boundary.circle.radius': 3
}); });
var compiled = JSON.parse( JSON.stringify( query ) ); var compiled = JSON.parse( JSON.stringify( query ) );
@ -67,7 +67,7 @@ module.exports.tests.query = function(test, common) {
'point.lon': -82.50622, 'point.lon': -82.50622,
'boundary.circle.lat': 111, 'boundary.circle.lat': 111,
'boundary.circle.lon': 333, 'boundary.circle.lon': 333,
'boundary.circle.radius': 500 'boundary.circle.radius': 3
}; };
var query = generate(clean); var query = generate(clean);
var compiled = JSON.parse( JSON.stringify( query ) ); var compiled = JSON.parse( JSON.stringify( query ) );
@ -102,7 +102,7 @@ module.exports.tests.query = function(test, common) {
'point.lon': -82.50622, 'point.lon': -82.50622,
'boundary.circle.lat': 29.49136, 'boundary.circle.lat': 29.49136,
'boundary.circle.lon': -82.50622, 'boundary.circle.lon': -82.50622,
'boundary.circle.radius': 500, 'boundary.circle.radius': 3,
'boundary.country': 'ABC' 'boundary.country': 'ABC'
}); });
@ -120,7 +120,7 @@ module.exports.tests.query = function(test, common) {
'point.lon': -82.50622, 'point.lon': -82.50622,
'boundary.circle.lat': 29.49136, 'boundary.circle.lat': 29.49136,
'boundary.circle.lon': -82.50622, 'boundary.circle.lon': -82.50622,
'boundary.circle.radius': 500, 'boundary.circle.radius': 3,
'sources': ['test'] 'sources': ['test']
}); });
@ -132,23 +132,46 @@ module.exports.tests.query = function(test, common) {
t.end(); t.end();
}); });
test('valid layers filter', function(t) { test('valid layers filter', (t) => {
var query = generate({ const query = generate({
'point.lat': 29.49136, 'point.lat': 29.49136,
'point.lon': -82.50622, 'point.lon': -82.50622,
'boundary.circle.lat': 29.49136, 'boundary.circle.lat': 29.49136,
'boundary.circle.lon': -82.50622, 'boundary.circle.lon': -82.50622,
'boundary.circle.radius': 500, 'boundary.circle.radius': 3,
'layers': ['country'] // only venue, address, and street layers should be retained
'layers': ['neighbourhood', 'venue', 'locality', 'address', 'region', 'street', 'country']
}); });
var compiled = JSON.parse( JSON.stringify( query ) ); const compiled = JSON.parse( JSON.stringify( query ) );
var expected = require('../fixture/reverse_with_layer_filtering'); const expected = require('../fixture/reverse_with_layer_filtering');
t.deepEqual(compiled.type, 'reverse', 'query type set'); t.deepEqual(compiled.type, 'reverse', 'query type set');
t.deepEqual(compiled.body, expected, 'valid reverse query with source filtering'); t.deepEqual(compiled.body, expected, 'valid reverse query with source filtering');
t.end(); t.end();
});
test('valid layers filter - subset of non-coarse layers', (t) => {
const query = generate({
'point.lat': 29.49136,
'point.lon': -82.50622,
'boundary.circle.lat': 29.49136,
'boundary.circle.lon': -82.50622,
'boundary.circle.radius': 3,
// only venue, address, and street layers should be retained
'layers': ['neighbourhood', 'venue', 'street', 'locality']
}); });
const compiled = JSON.parse( JSON.stringify( query ) );
const expected = require('../fixture/reverse_with_layer_filtering_non_coarse_subset');
t.deepEqual(compiled.type, 'reverse', 'query type set');
t.deepEqual(compiled.body, expected, 'valid reverse query with source filtering');
t.end();
});
}; };
module.exports.all = function (tape, common) { module.exports.all = function (tape, common) {

3
test/unit/run.js

@ -56,6 +56,7 @@ var tests = [
require('./query/text_parser'), require('./query/text_parser'),
require('./sanitizer/_boundary_country'), require('./sanitizer/_boundary_country'),
require('./sanitizer/_flag_bool'), require('./sanitizer/_flag_bool'),
require('./sanitizer/_geonames_deprecation'),
require('./sanitizer/_geonames_warnings'), require('./sanitizer/_geonames_warnings'),
require('./sanitizer/_geo_common'), require('./sanitizer/_geo_common'),
require('./sanitizer/_geo_reverse'), require('./sanitizer/_geo_reverse'),
@ -84,10 +85,10 @@ var tests = [
require('./sanitizer/search_fallback'), require('./sanitizer/search_fallback'),
require('./sanitizer/wrap'), require('./sanitizer/wrap'),
require('./service/configurations/PlaceHolder'), require('./service/configurations/PlaceHolder'),
require('./service/configurations/PointInPolygon'),
require('./service/mget'), require('./service/mget'),
require('./service/search'), require('./service/search'),
require('./service/interpolation'), require('./service/interpolation'),
require('./service/pointinpolygon'),
require('./service/language') require('./service/language')
]; ];

118
test/unit/sanitizer/_geo_reverse.js

@ -1,17 +1,19 @@
var sanitize = require('../../../sanitizer/_geo_reverse'); 'use strict';
var defaults = require('../../../query/reverse_defaults');
const sanitize = require('../../../sanitizer/_geo_reverse');
const defaults = require('../../../query/reverse_defaults');
module.exports.tests = {}; module.exports.tests = {};
module.exports.tests.sanitize_boundary_country = function(test, common) { module.exports.tests.warning_situations = (test, common) => {
test('raw with boundary.circle.lat should add warning about ignored boundary.circle', function(t) { test('raw with boundary.circle.lat should add warning about ignored boundary.circle', (t) => {
var raw = { const raw = {
'point.lat': '12.121212', 'point.lat': '12.121212',
'point.lon': '21.212121', 'point.lon': '21.212121',
'boundary.circle.lat': '13.131313' 'boundary.circle.lat': '13.131313'
}; };
var clean = {}; const clean = {};
var errorsAndWarnings = sanitize(raw, clean); const errorsAndWarnings = sanitize(raw, clean);
t.equals(clean['boundary.circle.lat'], 12.121212, 'should be set to point.lat'); t.equals(clean['boundary.circle.lat'], 12.121212, 'should be set to point.lat');
t.deepEquals(errorsAndWarnings, { t.deepEquals(errorsAndWarnings, {
@ -19,16 +21,17 @@ module.exports.tests.sanitize_boundary_country = function(test, common) {
warnings: ['boundary.circle.lat/boundary.circle.lon are currently unsupported'] warnings: ['boundary.circle.lat/boundary.circle.lon are currently unsupported']
}, 'no warnings/errors'); }, 'no warnings/errors');
t.end(); t.end();
}); });
test('raw with boundary.circle.lon should add warning about ignored boundary.circle', function(t) { test('raw with boundary.circle.lon should add warning about ignored boundary.circle', (t) => {
var raw = { const raw = {
'point.lat': '12.121212', 'point.lat': '12.121212',
'point.lon': '21.212121', 'point.lon': '21.212121',
'boundary.circle.lon': '31.313131' 'boundary.circle.lon': '31.313131'
}; };
var clean = {}; const clean = {};
var errorsAndWarnings = sanitize(raw, clean); const errorsAndWarnings = sanitize(raw, clean);
t.equals(clean['boundary.circle.lon'], 21.212121, 'should be set to point.lon'); t.equals(clean['boundary.circle.lon'], 21.212121, 'should be set to point.lon');
t.deepEquals(errorsAndWarnings, { t.deepEquals(errorsAndWarnings, {
@ -36,16 +39,17 @@ module.exports.tests.sanitize_boundary_country = function(test, common) {
warnings: ['boundary.circle.lat/boundary.circle.lon are currently unsupported'] warnings: ['boundary.circle.lat/boundary.circle.lon are currently unsupported']
}, 'no warnings/errors'); }, 'no warnings/errors');
t.end(); t.end();
}); });
test('raw with boundary.circle.radius shouldn\'t add warning about ignored boundary.circle', function(t) { test('raw with boundary.circle.radius shouldn\'t add warning about ignored boundary.circle', (t) => {
var raw = { const raw = {
'point.lat': '12.121212', 'point.lat': '12.121212',
'point.lon': '21.212121', 'point.lon': '21.212121',
'boundary.circle.radius': '17' 'boundary.circle.radius': '17'
}; };
var clean = {}; const clean = {};
var errorsAndWarnings = sanitize(raw, clean); const errorsAndWarnings = sanitize(raw, clean);
// t.equals(clean['boundary.circle.radius'], 12.121212, 'should be set to point.lat') // t.equals(clean['boundary.circle.radius'], 12.121212, 'should be set to point.lat')
t.deepEquals(errorsAndWarnings, { t.deepEquals(errorsAndWarnings, {
@ -53,85 +57,61 @@ module.exports.tests.sanitize_boundary_country = function(test, common) {
warnings: [] warnings: []
}, 'no warnings/errors'); }, 'no warnings/errors');
t.end(); t.end();
}); });
test('boundary.circle.lat/lon should be overridden with point.lat/lon', function(t) { };
var raw = {
module.exports.tests.success_conditions = (test, common) => {
test('boundary.circle.radius specified in request should override default', (t) => {
const raw = {
'point.lat': '12.121212', 'point.lat': '12.121212',
'point.lon': '21.212121', 'point.lon': '21.212121',
'boundary.circle.lat': '13.131313', 'boundary.circle.radius': '3248732857km' // this will never be the default
'boundary.circle.lon': '31.313131'
}; };
var clean = {}; const clean = {};
var errorsAndWarnings = sanitize(raw, clean); const errorsAndWarnings = sanitize(raw, clean);
t.equals(raw['boundary.circle.lat'], 12.121212, 'should be set to point.lat'); t.equals(raw['boundary.circle.lat'], 12.121212);
t.equals(raw['boundary.circle.lon'], 21.212121, 'should be set to point.lon'); t.equals(raw['boundary.circle.lon'], 21.212121);
t.equals(clean['boundary.circle.lat'], 12.121212, 'should be set to point.lat'); t.equals(raw['boundary.circle.radius'], '3248732857km');
t.equals(clean['boundary.circle.lon'], 21.212121, 'should be set to point.lon'); t.equals(clean['boundary.circle.lat'], 12.121212);
t.equals(clean['boundary.circle.lon'], 21.212121);
t.equals(clean['boundary.circle.radius'], 3248732857.0);
t.deepEquals(errorsAndWarnings, { errors: [], warnings: [] });
t.end(); t.end();
}); });
test('no boundary.circle.radius and no layers supplied should be set to default', function(t) { test('boundary.circle.radius not specified should use default', (t) => {
var raw = { const raw = {
'point.lat': '12.121212', 'point.lat': '12.121212',
'point.lon': '21.212121' 'point.lon': '21.212121'
}; };
var clean = {}; const clean = {};
var errorsAndWarnings = sanitize(raw, clean); const errorsAndWarnings = sanitize(raw, clean);
t.equals(raw['boundary.circle.lat'], 12.121212);
t.equals(raw['boundary.circle.lon'], 21.212121);
t.equals(raw['boundary.circle.radius'], defaults['boundary:circle:radius'], 'should be from defaults'); t.equals(raw['boundary.circle.radius'], defaults['boundary:circle:radius'], 'should be from defaults');
t.equals(clean['boundary.circle.lat'], 12.121212);
t.equals(clean['boundary.circle.lon'], 21.212121);
t.equals(clean['boundary.circle.radius'], parseFloat(defaults['boundary:circle:radius']), 'should be same as raw'); t.equals(clean['boundary.circle.radius'], parseFloat(defaults['boundary:circle:radius']), 'should be same as raw');
t.end();
});
test('no boundary.circle.radius and coarse layers supplied should be set to coarse default', function(t) { t.deepEquals(errorsAndWarnings, { errors: [], warnings: [] });
var raw = {
'point.lat': '12.121212',
'point.lon': '21.212121'
};
var clean = { layers: 'coarse' };
var errorsAndWarnings = sanitize(raw, clean);
t.equals(raw['boundary.circle.radius'], defaults['boundary:circle:radius:coarse'], 'should be from defaults');
t.equals(clean['boundary.circle.radius'], parseFloat(defaults['boundary:circle:radius:coarse']), 'should be same as raw');
t.end(); t.end();
});
test('no boundary.circle.radius and coarse layer supplied should be set to coarse default', function(t) {
var raw = {
'point.lat': '12.121212',
'point.lon': '21.212121'
};
var clean = { layers: 'locality' };
var errorsAndWarnings = sanitize(raw, clean);
t.equals(raw['boundary.circle.radius'], defaults['boundary:circle:radius:coarse'], 'should be from defaults');
t.equals(clean['boundary.circle.radius'], parseFloat(defaults['boundary:circle:radius:coarse']), 'should be same as raw');
t.end();
}); });
test('explicit boundary.circle.radius should be used instead of default', function(t) {
var raw = {
'point.lat': '12.121212',
'point.lon': '21.212121',
'boundary.circle.radius': '3248732857km' // this will never be the default
};
var clean = {};
var errorsAndWarnings = sanitize(raw, clean);
t.equals(raw['boundary.circle.radius'], '3248732857km', 'should be parsed float');
t.equals(clean['boundary.circle.radius'], 3248732857.0, 'should be copied from raw');
t.end();
});
}; };
module.exports.all = function (tape, common) { module.exports.all = (tape, common) => {
function test(name, testFunction) { function test(name, testFunction) {
return tape('SANTIZE _geo_reverse ' + name, testFunction); return tape(`SANTIZE _geo_reverse ${name}`, testFunction);
} }
for( var testCase in module.exports.tests ){ for( const testCase in module.exports.tests ){
module.exports.tests[testCase](test, common); module.exports.tests[testCase](test, common);
} }
}; };

82
test/unit/sanitizer/_geonames_deprecation.js

@ -0,0 +1,82 @@
const geonames_deprecation = require('../../../sanitizer/_geonames_deprecation');
module.exports.tests = {};
module.exports.tests.no_warnings_or_errors_conditions = (test, common) => {
test('undefined sources should add neither warnings nor errors', (t) => {
const clean = {};
const messages = geonames_deprecation(undefined, clean);
t.deepEquals(clean, {});
t.deepEquals(messages, { errors: [], warnings: [] });
t.end();
});
test('geonames/gn not in sources should add neither warnings nor errors', (t) => {
const clean = {
sources: ['source 1', 'source 2'],
};
const messages = geonames_deprecation(undefined, clean);
t.deepEquals(clean.sources, ['source 1', 'source 2']);
t.deepEquals(messages, { errors: [], warnings: [] });
t.end();
});
};
module.exports.tests.error_conditions = (test, common) => {
test('only geonames in sources should not modify clean.sources and add error message', (t) => {
['gn', 'geonames'].forEach((sources) => {
const clean = {
sources: [sources]
};
const messages = geonames_deprecation(undefined, clean);
t.deepEquals(clean.sources, [sources]);
t.deepEquals(messages.errors, ['/reverse does not support geonames']);
t.deepEquals(messages.warnings, []);
});
t.end();
});
};
module.exports.tests.warning_conditions = (test, common) => {
test('only geonames in sources should not modify clean.sources and add error message', (t) => {
['gn', 'geonames'].forEach((sources) => {
const clean = {
sources: ['another source', sources, 'yet another source']
};
const messages = geonames_deprecation(undefined, clean);
t.deepEquals(clean.sources, ['another source', 'yet another source']);
t.deepEquals(messages.errors, []);
t.deepEquals(messages.warnings, ['/reverse does not support geonames']);
});
t.end();
});
};
module.exports.all = (tape, common) => {
function test(name, testFunction) {
return tape(`SANTIZE _geonames_deprecation ${name}`, testFunction);
}
for( var testCase in module.exports.tests ){
module.exports.tests[testCase](test, common);
}
};

3
test/unit/sanitizer/nearby.js

@ -31,7 +31,8 @@ module.exports.tests.interface = function(test, common) {
module.exports.tests.sanitizers = function(test, common) { module.exports.tests.sanitizers = function(test, common) {
test('check sanitizer list', function (t) { test('check sanitizer list', function (t) {
var expected = ['singleScalarParameters', 'quattroshapes_deprecation', 'layers', var expected = ['singleScalarParameters', 'quattroshapes_deprecation', 'layers',
'sources', 'sources_and_layers', 'size', 'private', 'geo_reverse', 'boundary_country', 'categories']; 'sources', 'sources_and_layers', 'geonames_deprecation', 'size', 'private',
'geo_reverse', 'boundary_country', 'categories'];
t.deepEqual(Object.keys(nearby.sanitizer_list), expected); t.deepEqual(Object.keys(nearby.sanitizer_list), expected);
t.end(); t.end();
}); });

3
test/unit/sanitizer/reverse.js

@ -37,7 +37,8 @@ module.exports.tests.interface = function(test, common) {
module.exports.tests.sanitizers = function(test, common) { module.exports.tests.sanitizers = function(test, common) {
test('check sanitizer list', function (t) { test('check sanitizer list', function (t) {
var expected = ['singleScalarParameters', 'quattroshapes_deprecation', 'layers', var expected = ['singleScalarParameters', 'quattroshapes_deprecation', 'layers',
'sources', 'sources_and_layers', 'size', 'private', 'geo_reverse', 'boundary_country']; 'sources', 'sources_and_layers', 'geonames_deprecation', 'size', 'private',
'geo_reverse', 'boundary_country'];
t.deepEqual(Object.keys(reverse.sanitizer_list), expected); t.deepEqual(Object.keys(reverse.sanitizer_list), expected);
t.end(); t.end();
}); });

302
test/unit/schema.js

@ -20,6 +20,9 @@ module.exports.tests.completely_valid = (test, common) => {
}, },
requestRetries: 19, requestRetries: 19,
services: { services: {
pip: {
url: 'http://locahost'
},
placeholder: { placeholder: {
url: 'http://locahost' url: 'http://locahost'
} }
@ -407,14 +410,15 @@ module.exports.tests.api_validation = (test, common) => {
}); });
test('non-string api.pipService should throw error', (t) => { // api.placeholderService has been moved to api.services.placeholder.url
[null, 17, {}, [], true].forEach((value) => { test('any api.placeholderService value should be disallowed', (t) => {
[null, 17, {}, [], true, 'http://localhost'].forEach((value) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
pipService: value placeholderService: value
}, },
esclient: {} esclient: {}
}; };
@ -422,7 +426,7 @@ module.exports.tests.api_validation = (test, common) => {
const result = Joi.validate(config, schema); const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1); t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"pipService" must be a string'); t.equals(result.error.details[0].message, '"placeholderService" is not allowed');
}); });
@ -430,22 +434,22 @@ module.exports.tests.api_validation = (test, common) => {
}); });
test('non-http/https api.pipService should throw error', (t) => { // api.pipService has been moved to api.services.pip.url
['ftp', 'git', 'unknown'].forEach((scheme) => { test('any api.pipService value should be allowed', (t) => {
[null, 17, {}, [], true, 'http://localhost'].forEach((value) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
pipService: `${scheme}://localhost` pipService: value
}, },
esclient: {} esclient: {}
}; };
const result = Joi.validate(config, schema); const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1); t.notOk(result.error);
t.equals(result.error.details[0].message, '"pipService" must be a valid uri with a scheme matching the https? pattern');
}); });
@ -453,37 +457,66 @@ module.exports.tests.api_validation = (test, common) => {
}); });
test('http/https api.pipService should not throw error', (t) => { };
['http', 'https'].forEach((scheme) => {
module.exports.tests.api_services_validation = (test, common) => {
test('unsupported children of api.services should be disallowed', (t) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
pipService: `${scheme}://localhost` services: {
unknown_property: 'value'
}
}, },
esclient: {} esclient: {}
}; };
const result = Joi.validate(config, schema); const result = Joi.validate(config, schema);
t.notOk(result.error); t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"unknown_property" is not allowed');
t.end();
}); });
};
module.exports.tests.placeholder_service_validation = (test, common) => {
test('timeout and retries not specified should default to 250 and 3', (t) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
placeholder: {
url: 'http://localhost'
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.value.api.services.placeholder.timeout, 250);
t.equals(result.value.api.services.placeholder.retries, 3);
t.end(); t.end();
}); });
// api.placeholderService has been moved to api.services.placeholder.url test('when api.services.placeholder is defined, url is required', (t) => {
test('any api.placeholderService value should be disallowed', (t) => {
[null, 17, {}, [], true, 'http://localhost'].forEach((value) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
placeholderService: value services: {
placeholder: {
}
}
}, },
esclient: {} esclient: {}
}; };
@ -491,25 +524,49 @@ module.exports.tests.api_validation = (test, common) => {
const result = Joi.validate(config, schema); const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1); t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"placeholderService" is not allowed'); t.equals(result.error.details[0].message, '"url" is required');
t.end();
}); });
t.end(); test('non-string api.services.placeholder.url should throw error', (t) => {
[null, 17, {}, [], true].forEach((value) => {
var config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
placeholder: {
url: value
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"url" must be a string');
}); });
}; t.end();
module.exports.tests.api_services_validation = (test, common) => { });
test('unsupported children of api.services should be disallowed', (t) => {
test('non-http/https api.services.placeholder.url should throw error', (t) => {
['ftp', 'git', 'unknown'].forEach((scheme) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
services: { services: {
unknown_property: 'value' placeholder: {
url: `${scheme}://localhost`
}
} }
}, },
esclient: {} esclient: {}
@ -518,7 +575,10 @@ module.exports.tests.api_services_validation = (test, common) => {
const result = Joi.validate(config, schema); const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1); t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"unknown_property" is not allowed'); t.equals(result.error.details[0].message, '"url" must be a valid uri with a scheme matching the https\? pattern');
});
t.end(); t.end();
}); });
@ -547,14 +607,40 @@ module.exports.tests.api_services_validation = (test, common) => {
}); });
test('when api.services.placeholder is defined, url is required', (t) => { };
module.exports.tests.pip_service_validation = (test, common) => {
test('timeout and retries not specified should default to 250 and 3', (t) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost'
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.value.api.services.pip.timeout, 250);
t.equals(result.value.api.services.pip.retries, 3);
t.end();
});
test('when api.services.pip is defined, url is required', (t) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
services: { services: {
placeholder: { pip: {
} }
} }
}, },
@ -569,7 +655,7 @@ module.exports.tests.api_services_validation = (test, common) => {
}); });
test('non-string api.services.placeholder.url should throw error', (t) => { test('non-string api.services.pip.url should throw error', (t) => {
[null, 17, {}, [], true].forEach((value) => { [null, 17, {}, [], true].forEach((value) => {
var config = { var config = {
api: { api: {
@ -577,7 +663,7 @@ module.exports.tests.api_services_validation = (test, common) => {
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
services: { services: {
placeholder: { pip: {
url: value url: value
} }
} }
@ -596,7 +682,7 @@ module.exports.tests.api_services_validation = (test, common) => {
}); });
test('non-http/https api.services.placeholder.url should throw error', (t) => { test('non-http/https api.services.pip.url should throw error', (t) => {
['ftp', 'git', 'unknown'].forEach((scheme) => { ['ftp', 'git', 'unknown'].forEach((scheme) => {
var config = { var config = {
api: { api: {
@ -604,7 +690,7 @@ module.exports.tests.api_services_validation = (test, common) => {
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
services: { services: {
placeholder: { pip: {
url: `${scheme}://localhost` url: `${scheme}://localhost`
} }
} }
@ -623,14 +709,14 @@ module.exports.tests.api_services_validation = (test, common) => {
}); });
test('non-url children of api.services.placeholder should be disallowed', (t) => { test('non-url children of api.services.pip should be disallowed', (t) => {
var config = { var config = {
api: { api: {
version: 'version value', version: 'version value',
indexName: 'index name value', indexName: 'index name value',
host: 'host value', host: 'host value',
services: { services: {
placeholder: { pip: {
url: 'http://localhost', url: 'http://localhost',
unknown_property: 'value' unknown_property: 'value'
} }
@ -647,6 +733,158 @@ module.exports.tests.api_services_validation = (test, common) => {
}); });
test('non-number timeout should throw error', (t) => {
[null, 'string', {}, [], false].forEach((value) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost',
timeout: value
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"timeout" must be a number');
});
t.end();
});
test('non-integer timeout should throw error', (t) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost',
timeout: 17.3
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"timeout" must be an integer');
t.end();
});
test('negative timeout should throw error', (t) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost',
timeout: -1
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"timeout" must be larger than or equal to 0');
t.end();
});
test('non-number retries should throw error', (t) => {
[null, 'string', {}, [], false].forEach((value) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost',
retries: value
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"retries" must be a number');
});
t.end();
});
test('non-integer retries should throw error', (t) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost',
retries: 17.3
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"retries" must be an integer');
t.end();
});
test('negative retries should throw error', (t) => {
const config = {
api: {
version: 'version value',
indexName: 'index name value',
host: 'host value',
services: {
pip: {
url: 'http://localhost',
retries: -1
}
}
},
esclient: {}
};
const result = Joi.validate(config, schema);
t.equals(result.error.details.length, 1);
t.equals(result.error.details[0].message, '"retries" must be larger than or equal to 0');
t.end();
});
}; };
module.exports.tests.esclient_validation = (test, common) => { module.exports.tests.esclient_validation = (test, common) => {

6
test/unit/service/configurations/PlaceHolder.js

@ -29,7 +29,7 @@ module.exports.tests.all = (test, common) => {
const placeholder = new PlaceHolder(configBlob); const placeholder = new PlaceHolder(configBlob);
t.equals(placeholder.getUrl(), 'http://localhost:1234/search'); t.equals(placeholder.getUrl(), 'http://localhost:1234/parser/search');
t.end(); t.end();
}); });
@ -114,14 +114,14 @@ module.exports.tests.all = (test, common) => {
test('baseUrl ending in / should not have double /\'s return by getUrl', (t) => { test('baseUrl ending in / should not have double /\'s return by getUrl', (t) => {
const configBlob = { const configBlob = {
url: 'http://localhost:1234/blah', url: 'http://localhost:1234/',
timeout: 17, timeout: 17,
retries: 19 retries: 19
}; };
const placeholder = new PlaceHolder(configBlob); const placeholder = new PlaceHolder(configBlob);
t.deepEquals(placeholder.getUrl(), 'http://localhost:1234/blah/search'); t.deepEquals(placeholder.getUrl(), 'http://localhost:1234/parser/search');
t.end(); t.end();
}); });

101
test/unit/service/configurations/PointInPolygon.js

@ -0,0 +1,101 @@
module.exports.tests = {};
const PointInPolygon = require('../../../../service/configurations/PointInPolygon');
module.exports.tests.all = (test, common) => {
test('getName should return \'pip\'', (t) => {
const configBlob = {
url: 'http://localhost:1234',
timeout: 17,
retries: 19
};
const pointInPolygon = new PointInPolygon(configBlob);
t.equals(pointInPolygon.getName(), 'pip');
t.equals(pointInPolygon.getBaseUrl(), 'http://localhost:1234/');
t.equals(pointInPolygon.getTimeout(), 17);
t.equals(pointInPolygon.getRetries(), 19);
t.end();
});
test('getUrl should return value formatted with point.lon/lat passed to constructor', (t) => {
const configBlob = {
url: 'http://localhost:1234'
};
const pointInPolygon = new PointInPolygon(configBlob);
const req = {
clean: { }
};
req.clean['point.lon'] = 21.212121;
req.clean['point.lat'] = 12.121212;
t.equals(pointInPolygon.getUrl(req), 'http://localhost:1234/21.212121/12.121212');
t.end();
});
test('getHeaders should return an empty object', (t) => {
const configBlob = {
url: 'http://localhost:1234',
timeout: 17,
retries: 19
};
const pointInPolygon = new PointInPolygon(configBlob);
t.deepEquals(pointInPolygon.getHeaders(), {});
t.end();
});
test('getParameters should return an empty object', (t) => {
const configBlob = {
url: 'http://localhost:1234',
timeout: 17,
retries: 19
};
const pointInPolygon = new PointInPolygon(configBlob);
t.deepEquals(pointInPolygon.getParameters(), {});
t.end();
});
test('baseUrl ending in / should not have double /\'s return by getUrl', (t) => {
const configBlob = {
url: 'http://localhost:1234/',
timeout: 17,
retries: 19
};
const pointInPolygon = new PointInPolygon(configBlob);
const req = {
clean: { }
};
req.clean['point.lon'] = 21.212121;
req.clean['point.lat'] = 12.121212;
t.equals(pointInPolygon.getUrl(req), 'http://localhost:1234/21.212121/12.121212');
t.end();
});
};
module.exports.all = (tape, common) => {
function test(name, testFunction) {
return tape(`SERVICE CONFIGURATION /PointInPolygon ${name}`, testFunction);
}
for( var testCase in module.exports.tests ){
module.exports.tests[testCase](test, common);
}
};

323
test/unit/service/pointinpolygon.js

@ -1,323 +0,0 @@
const proxyquire = require('proxyquire').noCallThru();
const setup = require('../../../service/pointinpolygon');
module.exports.tests = {};
module.exports.tests.interface = (test, common) => {
test('valid interface', (t) => {
const logger = require('pelias-mock-logger')();
var service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
});
t.equal(typeof service, 'function', 'service is a function');
t.end();
});
};
module.exports.tests.do_nothing_service = (test, common) => {
test('undefined PiP uri should return service that logs fact that PiP service is not available', (t) => {
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})();
service({ lat: 12.121212, lon: 21.212121 }, false, (err) => {
t.deepEquals(logger.getWarnMessages(), [
'point-in-polygon service disabled'
]);
t.equals(err, 'point-in-polygon service disabled, unable to resolve {"lat":12.121212,"lon":21.212121}');
t.end();
});
});
test('service unavailable message should not output centroid when do_not_track is true', (t) => {
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})();
service({ lat: 12.121212, lon: 21.212121 }, true, (err) => {
t.deepEquals(logger.getWarnMessages(), [
'point-in-polygon service disabled'
]);
t.equals(err, 'point-in-polygon service disabled, unable to resolve centroid');
t.end();
});
});
};
module.exports.tests.success = (test, common) => {
test('lat and lon should be passed to server', (t) => {
const pipServer = require('express')();
pipServer.get('/:lon/:lat', (req, res, next) => {
t.equals(req.params.lat, '12.121212');
t.equals(req.params.lon, '21.212121');
res.send('{ "field": "value" }');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
service({ lat: 12.121212, lon: 21.212121}, false, (err, results) => {
t.notOk(err);
t.deepEquals(results, { field: 'value' });
t.ok(logger.isInfoMessage(`using point-in-polygon service at http://localhost:${port}`));
t.notOk(logger.hasErrorMessages());
t.end();
server.close();
});
});
test('do_not_track=true should pass DNT header', (t) => {
const pipServer = require('express')();
pipServer.get('/:lon/:lat', (req, res, next) => {
t.ok(req.headers.hasOwnProperty('dnt'));
t.equals(req.params.lat, '12.121212');
t.equals(req.params.lon, '21.212121');
res.send('{ "field": "value" }');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
service({ lat: 12.121212, lon: 21.212121}, true, (err, results) => {
t.notOk(err);
t.deepEquals(results, { field: 'value' });
t.ok(logger.isInfoMessage(`using point-in-polygon service at http://localhost:${port}`));
t.notOk(logger.hasErrorMessages());
t.end();
server.close();
});
});
test('do_not_track=false should not pass DNT header', (t) => {
const pipServer = require('express')();
pipServer.get('/:lon/:lat', (req, res, next) => {
t.notOk(req.headers.hasOwnProperty('dnt'));
t.equals(req.params.lat, '12.121212');
t.equals(req.params.lon, '21.212121');
res.send('{ "field": "value" }');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
service({ lat: 12.121212, lon: 21.212121}, false, (err, results) => {
t.notOk(err);
t.deepEquals(results, { field: 'value' });
t.ok(logger.isInfoMessage(`using point-in-polygon service at http://localhost:${port}`));
t.notOk(logger.hasErrorMessages());
t.end();
server.close();
});
});
};
module.exports.tests.failure = (test, common) => {
test('server returning success but non-JSON body should log error and return no results', (t) => {
const pipServer = require('express')();
pipServer.get('/:lon/:lat', (req, res, next) => {
t.equals(req.params.lat, '12.121212');
t.equals(req.params.lon, '21.212121');
res.send('this is not JSON');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
const expectedErrorMsg = `http://localhost:${port}/21.212121/12.121212 returned ` +
`status 200 but with non-JSON response: this is not JSON`;
service({ lat: 12.121212, lon: 21.212121}, false, (err, results) => {
t.equals(err, expectedErrorMsg);
t.notOk(results);
t.ok(logger.isErrorMessage(expectedErrorMsg));
t.end();
server.close();
});
});
test('server returning 200 & non-JSON body should log sanitized error and return no results when do_not_track', (t) => {
const pipServer = require('express')();
pipServer.get('/:lon/:lat', (req, res, next) => {
t.equals(req.params.lat, '12.121212');
t.equals(req.params.lon, '21.212121');
res.send('this is not JSON');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
const expectedErrorMsg = `http://localhost:${port}/[removed]/[removed] returned ` +
`status 200 but with non-JSON response: this is not JSON`;
service({ lat: 12.121212, lon: 21.212121}, true, (err, results) => {
t.equals(err, expectedErrorMsg);
t.notOk(results);
t.ok(logger.isErrorMessage(expectedErrorMsg));
t.end();
server.close();
});
});
test('server returning error should log it and return no results', (t) => {
const server = require('express')().listen();
const port = server.address().port;
// immediately close the server so to ensure an error response
server.close();
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
service({ lat: 12.121212, lon: 21.212121}, false, (err, results) => {
t.equals(err.code, 'ECONNREFUSED');
t.notOk(results);
t.ok(logger.isErrorMessage(/ECONNREFUSED/), 'there should be a connection refused error message');
t.end();
server.close();
});
});
test('non-OK status should log error and return no results', (t) => {
const pipServer = require('express')();
pipServer.get('/:lat/:lon', (req, res, next) => {
res.status(400).send('a bad request was made');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
const expectedErrorMsg = `http://localhost:${port}/21.212121/12.121212 returned ` +
`status 400: a bad request was made`;
service({ lat: 12.121212, lon: 21.212121}, false, (err, results) => {
t.equals(err, expectedErrorMsg);
t.notOk(results);
t.ok(logger.isErrorMessage(expectedErrorMsg));
t.end();
server.close();
});
});
test('non-OK status should log sanitized error and return no results when do_not_track=true', (t) => {
const pipServer = require('express')();
pipServer.get('/:lat/:lon', (req, res, next) => {
res.status(400).send('a bad request was made');
});
const server = pipServer.listen();
const port = server.address().port;
const logger = require('pelias-mock-logger')();
const service = proxyquire('../../../service/pointinpolygon', {
'pelias-logger': logger
})(`http://localhost:${port}`);
const expectedErrorMsg = `http://localhost:${port}/[removed]/[removed] returned ` +
`status 400: a bad request was made`;
service({ lat: 12.121212, lon: 21.212121}, true, (err, results) => {
t.equals(err, expectedErrorMsg);
t.notOk(results);
t.ok(logger.isErrorMessage(expectedErrorMsg));
t.end();
server.close();
});
});
};
module.exports.all = (tape, common) => {
function test(name, testFunction) {
return tape(`SERVICE /pointinpolygon ${name}`, testFunction);
}
for( var testCase in module.exports.tests ){
module.exports.tests[testCase](test, common);
}
};
Loading…
Cancel
Save