passed down peliasConfig.api schema to sanitizers

routes/v1.js

@@ -129,7 +129,7 @@ function addRoutes(app, peliasConfig) {
       controllers.mdToHTML(peliasConfig.api, './public/attribution.md')
     ]),
     search: createRouter([
-      sanitizers.search.middleware,
+      sanitizers.search.middleware(peliasConfig.api),
       middleware.requestLanguage,
       middleware.calcSize(),
       controllers.placeholder(placeholderService, placeholderShouldExecute),
@@ -156,7 +156,7 @@ function addRoutes(app, peliasConfig) {
       postProc.sendJSON
     ]),
     structured: createRouter([
-      sanitizers.structured_geocoding.middleware,
+      sanitizers.structured_geocoding.middleware(peliasConfig.api),
       middleware.requestLanguage,
       middleware.calcSize(),
       controllers.search(peliasConfig.api, esclient, queries.structured_geocoding, not(hasResponseDataOrRequestErrors)),
@@ -177,7 +177,7 @@ function addRoutes(app, peliasConfig) {
       postProc.sendJSON
     ]),
     autocomplete: createRouter([
-      sanitizers.autocomplete.middleware,
+      sanitizers.autocomplete.middleware(peliasConfig.api),
       middleware.requestLanguage,
       controllers.search(peliasConfig.api, esclient, queries.autocomplete, not(hasResponseDataOrRequestErrors)),
       postProc.distances('focus.point.'),

sanitizer/_location_bias.js

@@ -1,18 +1,21 @@
-/*
+const _ = require('lodash');
+/**
 Set a focus.lat and focus.lon if specified in pelias config
+* @param {object} defaultParameters property of pelias config
 */
-var _ = require('lodash');
 
 function setup(defaultParameters){
-  return function setLocationBias(req, res, next){
-    if (_.isUndefined(req.clean) ||
-      _.isUndefined(defaultParameters['focus.point.lat']) ||
-      _.isUndefined(defaultParameters['focus.point.lon'])) {
-      return next();
+
+  return function setLocationBias(raw, clean){
+    if (!_.isUndefined(raw) &&
+      !_.isUndefined(defaultParameters['focus.point.lat']) &&
+      !_.isUndefined(defaultParameters['focus.point.lon'])) {
+
+      raw['focus.point.lat'] = defaultParameters['focus.point.lat'];
+      raw['focus.point.lon'] = defaultParameters['focus.point.lon'];
     }
-    req.clean['focus.point.lat'] = defaultParameters['focus.point.lat'];
-    req.clean['focus.point.lon'] = defaultParameters['focus.point.lon'];
-    next();
+
+    return { errors: [], warnings: [] };
   };
 }
 

sanitizer/autocomplete.js

@@ -1,7 +1,9 @@
 var type_mapping = require('../helper/type_mapping');
+var sanitizeAll = require('../sanitizer/sanitizeAll');
 
-var sanitizeAll = require('../sanitizer/sanitizeAll'),
-    sanitizers = {
+// middleware
+module.exports.middleware = (_api_pelias_config) => {
+  var sanitizers = {
       singleScalarParameters: require('../sanitizer/_single_scalar_parameters'),
       text: require('../sanitizer/_text_addressit'),
       tokenizer: require('../sanitizer/_tokenizer'),
@@ -11,25 +13,21 @@ var sanitizeAll = require('../sanitizer/sanitizeAll'),
       // depends on the layers and sources sanitizers, must be run after them
       sources_and_layers: require('../sanitizer/_sources_and_layers'),
       private: require('../sanitizer/_flag_bool')('private', false),
-      location_bias: require('../sanitizer/_location_bias'),
+      location_bias: require('../sanitizer/_location_bias')(_api_pelias_config.defaultParameters),
       geo_autocomplete: require('../sanitizer/_geo_autocomplete'),
       boundary_country: require('../sanitizer/_boundary_country'),
       categories: require('../sanitizer/_categories')
     };
 
-var sanitize = function(req, cb) { sanitizeAll(req, sanitizers, cb); };
-
-// export sanitize for testing
-module.exports.sanitize = sanitize;
-module.exports.sanitizer_list = sanitizers;
+  var sanitize = function(req, cb) { sanitizeAll(req, sanitizers, cb); };
 
-// middleware
-module.exports.middleware = function( req, res, next ){
-  sanitize( req, function( err, clean ){
-    if( err ){
-      res.status(400); // 400 Bad Request
-      return next(err);
-    }
+  return function( req, res, next ){
+    sanitize( req, function( err, clean ){
+      if( err ){
+        res.status(400); // 400 Bad Request
+        return next(err);
+      }
     next();
-  });
+    });
+  };
 };

sanitizer/search.js

@@ -1,31 +1,33 @@
 var type_mapping = require('../helper/type_mapping');
+var sanitizeAll = require('../sanitizer/sanitizeAll');
+// middleware
+module.exports.middleware = (_api_pelias_config) => {
+  var sanitizers = {
+        singleScalarParameters: require('../sanitizer/_single_scalar_parameters'),
+        quattroshapes_deprecation: require('../sanitizer/_deprecate_quattroshapes'),
+        text: require('../sanitizer/_text'),
+        iso2_to_iso3: require('../sanitizer/_iso2_to_iso3'),
+        city_name_standardizer: require('../sanitizer/_city_name_standardizer'),
+        size: require('../sanitizer/_size')(/* use defaults*/),
+        layers: require('../sanitizer/_targets')('layers', type_mapping.layer_mapping),
+        sources: require('../sanitizer/_targets')('sources', type_mapping.source_mapping),
+        // depends on the layers and sources sanitizers, must be run after them
+        sources_and_layers: require('../sanitizer/_sources_and_layers'),
+        private: require('../sanitizer/_flag_bool')('private', false),
+        location_bias: require('../sanitizer/_location_bias')(_api_pelias_config.defaultParameters),
+        geo_search: require('../sanitizer/_geo_search'),
+        boundary_country: require('../sanitizer/_boundary_country'),
+        categories: require('../sanitizer/_categories'),
+        // this can go away once geonames has been abrogated
+        geonames_warnings: require('../sanitizer/_geonames_warnings')
+      };
 
-var sanitizeAll = require('../sanitizer/sanitizeAll'),
-    sanitizers = {
-      singleScalarParameters: require('../sanitizer/_single_scalar_parameters'),
-      quattroshapes_deprecation: require('../sanitizer/_deprecate_quattroshapes'),
-      text: require('../sanitizer/_text'),
-      iso2_to_iso3: require('../sanitizer/_iso2_to_iso3'),
-      city_name_standardizer: require('../sanitizer/_city_name_standardizer'),
-      size: require('../sanitizer/_size')(/* use defaults*/),
-      layers: require('../sanitizer/_targets')('layers', type_mapping.layer_mapping),
-      sources: require('../sanitizer/_targets')('sources', type_mapping.source_mapping),
-      // depends on the layers and sources sanitizers, must be run after them
-      sources_and_layers: require('../sanitizer/_sources_and_layers'),
-      private: require('../sanitizer/_flag_bool')('private', false),
-      location_bias: require('../sanitizer/_location_bias'),
-      geo_search: require('../sanitizer/_geo_search'),
-      boundary_country: require('../sanitizer/_boundary_country'),
-      categories: require('../sanitizer/_categories'),
-      // this can go away once geonames has been abrogated
-      geonames_warnings: require('../sanitizer/_geonames_warnings')
-    };
+  var sanitize = function(req, cb) { sanitizeAll(req, sanitizers, cb); };
 
-var sanitize = function(req, cb) { sanitizeAll(req, sanitizers, cb); };
+  return function( req, res, next ){
+    sanitize( req, function( err, clean ){
+      next();
+    });
+  };
 
-// middleware
-module.exports.middleware = function( req, res, next ){
-  sanitize( req, function( err, clean ){
-    next();
-  });
 };

sanitizer/structured_geocoding.js

@@ -1,29 +1,30 @@
 var type_mapping = require('../helper/type_mapping');
-
-var sanitizeAll = require('../sanitizer/sanitizeAll'),
-    sanitizers = {
-      singleScalarParameters: require('../sanitizer/_single_scalar_parameters'),
-      quattroshapes_deprecation: require('../sanitizer/_deprecate_quattroshapes'),
-      synthesize_analysis: require('../sanitizer/_synthesize_analysis'),
-      iso2_to_iso3: require('../sanitizer/_iso2_to_iso3'),
-      city_name_standardizer: require('../sanitizer/_city_name_standardizer'),
-      size: require('../sanitizer/_size')(/* use defaults*/),
-      layers: require('../sanitizer/_targets')('layers', type_mapping.layer_mapping),
-      sources: require('../sanitizer/_targets')('sources', type_mapping.source_mapping),
-      // depends on the layers and sources sanitizers, must be run after them
-      sources_and_layers: require('../sanitizer/_sources_and_layers'),
-      private: require('../sanitizer/_flag_bool')('private', false),
-      location_bias: require('../sanitizer/_location_bias'),
-      geo_search: require('../sanitizer/_geo_search'),
-      boundary_country: require('../sanitizer/_boundary_country'),
-      categories: require('../sanitizer/_categories')
-    };
-
-var sanitize = function(req, cb) { sanitizeAll(req, sanitizers, cb); };
+var sanitizeAll = require('../sanitizer/sanitizeAll');
 
 // middleware
-module.exports.middleware = function( req, res, next ){
-  sanitize( req, function( err, clean ){
-    next();
-  });
+module.exports.middleware = (_api_pelias_config) => {
+  var sanitizers = {
+        singleScalarParameters: require('../sanitizer/_single_scalar_parameters'),
+        quattroshapes_deprecation: require('../sanitizer/_deprecate_quattroshapes'),
+        synthesize_analysis: require('../sanitizer/_synthesize_analysis'),
+        iso2_to_iso3: require('../sanitizer/_iso2_to_iso3'),
+        city_name_standardizer: require('../sanitizer/_city_name_standardizer'),
+        size: require('../sanitizer/_size')(/* use defaults*/),
+        layers: require('../sanitizer/_targets')('layers', type_mapping.layer_mapping),
+        sources: require('../sanitizer/_targets')('sources', type_mapping.source_mapping),
+        // depends on the layers and sources sanitizers, must be run after them
+        sources_and_layers: require('../sanitizer/_sources_and_layers'),
+        private: require('../sanitizer/_flag_bool')('private', false),
+        location_bias: require('../sanitizer/_location_bias')(_api_pelias_config.defaultParameters),
+        geo_search: require('../sanitizer/_geo_search'),
+        boundary_country: require('../sanitizer/_boundary_country'),
+        categories: require('../sanitizer/_categories')
+      };
+  var sanitize = function(req, cb) { sanitizeAll(req, sanitizers, cb); };
+
+  return function( req, res, next ){
+    sanitize( req, function( err, clean ){
+      next();
+    });
+  };
 };

test/unit/sanitizer/_location_bias.js

@@ -1,87 +1,70 @@
-var setup = require('../../../sanitizer/_location_bias');
+const setup = require('../../../sanitizer/_location_bias');
 
 module.exports.tests = {};
 
 module.exports.tests.setLocationBias = function(test, common) {
   test('set focus point', t => {
-    var defaultParameters = { // specify focus point latitude and longitude
+    const defaultParameters = { // specify focus point latitude and longitude
       'focus.point.lat': 12.12121212,
       'focus.point.lon': 21.21212121
     };
-    var locationBias = setup(defaultParameters);
-    var req = {
-      clean: {}
-    };
-    var expected = {
-      clean: {
+    const locationBias = setup(defaultParameters);
+    const raw = {};
+    const expected = {
           'focus.point.lat': 12.12121212,
           'focus.point.lon': 21.21212121
-      }
     };
 
-    locationBias(req, undefined, () => {
-      t.deepEqual(req, expected, 'focus point should be set');
-      t.end();
-    });
+    locationBias(raw, undefined);
+    t.deepEqual(raw, expected, 'focus point should be set');
+    t.end();
+
   });
 
-  test('undefined req.clean', t => {
-    var defaultParameters = {
+  test('undefined raw', t => {
+    const defaultParameters = {
         'focus.point.lat': 12.12121212,
         'focus.point.lon': 21.21212121
     };
-    var locationBias = setup(defaultParameters);
-    var req = {};
-    var expected = {};
+    const locationBias = setup(defaultParameters);
 
-    locationBias(req, undefined, () => {
-      t.deepEqual(req, expected, 'should be unmodified' );
-      t.end();
-    });
+    locationBias(undefined, undefined);
+    t.deepEqual(undefined, undefined, 'should be unmodified' );
+    t.end();
   });
 
   test('focusPointLat is undefined', t => {
-    var defaultParameters = {
+    const defaultParameters = {
       'focus.point.lon': 12.2121212
     };
-    var locationBias = setup(defaultParameters);
-    var req = {
-       clean: {}
-    };
-    var expected = {
-       clean: {}
-    };
+    const locationBias = setup(defaultParameters);
+    const raw = {};
+    const expected = {};
 
-    locationBias(req, undefined, () => {
-      t.deepEqual(req, expected, 'should be unmodified' );
-      t.end();
-    });
+    locationBias(raw, undefined);
+    t.deepEqual(raw, expected, 'should be unmodified' );
+    t.end();
   });
 
   test('focusPointLon is undefined', t => {
-    var defaultParameters = {
+    const defaultParameters = {
       'focus.point.lat': 12.2121212
     };
-    var locationBias = setup(defaultParameters);
-    var req = {
-       clean: {}
-    };
-    var expected = {
-       clean: {}
-    };
+    const locationBias = setup(defaultParameters);
+    const raw = {};
+    const expected = {};
 
-    locationBias(req, undefined, () => {
-      t.deepEqual(req, expected, 'should be unmodified' );
+    locationBias(raw, undefined);
+      t.deepEqual(raw, expected, 'should be unmodified' );
       t.end();
-    });
   });
 
 };
 
-module.exports.all = function (tape, common) {
+module.exports.all = (tape, common) => {
 
   function test(name, testFunction) {
-    return tape('[middleware] locationBias: ' + name, testFunction);
+    return tape(`SANITIZE _location_bias: ${name}`, testFunction);
   }
 
   for( var testCase in module.exports.tests ){

test/unit/sanitizer/autocomplete.js

@@ -1,21 +1,126 @@
-var autocomplete = require('../../../sanitizer/autocomplete');
+const proxyquire =  require('proxyquire').noCallThru();
+const _ = require('lodash');
 
 module.exports.tests = {};
 
 module.exports.tests.sanitizers = function(test, common) {
-  test('check sanitizer list', function (t) {
-    var expected = [
-      'singleScalarParameters', 'text', 'tokenizer', 'size', 'layers', 'sources',
-      'sources_and_layers', 'private', 'location_bias', 'geo_autocomplete', 'boundary_country', 'categories'
+  test('verify that all sanitizers were called as expected', function(t) {
+    var called_sanitizers = [];
+
+    var autocomplete = proxyquire('../../../sanitizer/autocomplete', {
+      '../sanitizer/_single_scalar_parameters': () => {
+        called_sanitizers.push('_single_scalar_parameters');
+        return { errors: [], warnings: [] };
+      },
+      '../sanitizer/_text_addressit': () => {
+        called_sanitizers.push('_text_addressit');
+        return { errors: [], warnings: [] };
+      },
+      '../sanitizer/_tokenizer': () => {
+        called_sanitizers.push('_tokenizer');
+        return { errors: [], warnings: [] };
+      },
+      '../sanitizer/_size': function() {
+        if (_.isEqual(_.values(arguments), [10, 10, 10])) {
+          return () => {
+            called_sanitizers.push('_size');
+            return { errors: [], warnings: [] };
+          };
+
+        } else {
+          throw new Error('incorrect parameters passed to _size');
+        }
+
+      },
+      '../sanitizer/_targets': (type) => {
+        if (['layers', 'sources'].indexOf(type) !== -1) {
+          return () => {
+            called_sanitizers.push(`_targets/${type}`);
+            return { errors: [], warnings: [] };
+          };
+
+        }
+        else {
+          throw new Error('incorrect parameters passed to _targets');
+        }
+
+      },
+      '../sanitizer/_sources_and_layers': () => {
+        called_sanitizers.push('_sources_and_layers');
+        return { errors: [], warnings: [] };
+      },
+      '../sanitizer/_flag_bool': function() {
+        if (arguments[0] === 'private' && arguments[1] === false) {
+          return () => {
+            called_sanitizers.push('_flag_bool');
+            return { errors: [], warnings: [] };
+          };
+
+        }
+        else {
+          throw new Error('incorrect parameters passed to _flag_bool');
+        }
+
+      },
+      '../sanitizer/_location_bias': (defaultParameters) => {
+        if (defaultParameters.key === 'value'){
+          return () => {
+            called_sanitizers.push('_location_bias');
+            return { errors: [], warnings: [] };
+          };
+        } else {
+            throw new Error('incorrect parameter passed to _location_bias');
+        }
+      },
+      '../sanitizer/_geo_autocomplete': () => {
+        called_sanitizers.push('_geo_autocomplete');
+        return { errors: [], warnings: [] };
+      },
+      '../sanitizer/_boundary_country': () => {
+        called_sanitizers.push('_boundary_country');
+        return { errors: [], warnings: [] };
+      },
+      '../sanitizer/_categories': () => {
+        called_sanitizers.push('_categories');
+        return { errors: [], warnings: [] };
+      },
+    });
+
+    const expected_sanitizers = [
+      '_single_scalar_parameters',
+      '_text_addressit',
+      '_tokenizer',
+      '_size',
+      '_targets/layers',
+      '_targets/sources',
+      '_sources_and_layers',
+      '_flag_bool',
+      '_location_bias',
+      '_geo_autocomplete',
+      '_boundary_country',
+      '_categories'
     ];
-    t.deepEqual(Object.keys(autocomplete.sanitizer_list), expected);
-    t.end();
+
+    const req = {};
+    const res = {};
+
+    const middleware = autocomplete.middleware({
+      defaultParameters: {
+        key: 'value'
+      }
+    });
+
+    middleware(req, res, () => {
+      t.deepEquals(called_sanitizers, expected_sanitizers);
+      t.end();
+    });
+
   });
 };
 
 module.exports.all = function (tape, common) {
   function test(name, testFunction) {
-    return tape('SANTIZE /autocomplete ' + name, testFunction);
+    return tape('SANITIZE /autocomplete ' + name, testFunction);
   }
 
   for( var testCase in module.exports.tests ){

test/unit/sanitizer/search.js

@@ -88,9 +88,15 @@ module.exports.tests.sanitize = (test, common) => {
         called_sanitizers.push('_geonames_warnings');
         return { errors: [], warnings: [] };
       },
-      '../sanitizer/_location_bias': () => {
-        called_sanitizers.push('_location_bias');
-        return { errors: [], warnings: [] };
+      '../sanitizer/_location_bias': (defaultParameters) => {
+        if (defaultParameters.key === 'value'){
+          return () => {
+            called_sanitizers.push('_location_bias');
+            return { errors: [], warnings: [] };
+          };
+        } else {
+            throw new Error('incorrect parameter passed to _location_bias');
+        }
       }
 
     });
@@ -116,17 +122,24 @@ module.exports.tests.sanitize = (test, common) => {
     const req = {};
     const res = {};
 
-    search.middleware(req, res, () => {
+    const middleware = search.middleware({
+      defaultParameters: {
+        key: 'value'
+      }
+    });
+
+    middleware(req, res, () => {
       t.deepEquals(called_sanitizers, expected_sanitizers);
       t.end();
     });
+
   });
 };
 
 module.exports.all = (tape, common) => {
 
   function test(name, testFunction) {
-    return tape(`SANTIZE /search ${name}`, testFunction);
+    return tape(`SANITIZE /search ${name}`, testFunction);
   }
 
   for( const testCase in module.exports.tests ){

test/unit/sanitizer/structured_geocoding.js

@@ -83,9 +83,15 @@ module.exports.tests.sanitize = function(test, common) {
         called_sanitizers.push('_categories');
         return { errors: [], warnings: [] };
       },
-      '../sanitizer/_location_bias': () => {
-        called_sanitizers.push('_location_bias');
-        return { errors: [], warnings: [] };
+      '../sanitizer/_location_bias': function (defaultParameters) {
+        if (defaultParameters.key === 'value'){
+          return () => {
+            called_sanitizers.push('_location_bias');
+            return { errors: [], warnings: [] };
+          };
+        } else {
+            throw new Error('incorrect parameter passed to _location_bias');
+        }
       }
     });
 
@@ -109,17 +115,24 @@ module.exports.tests.sanitize = function(test, common) {
     var req = {};
     var res = {};
 
-    search.middleware(req, res, function(){
+    const middleware = search.middleware({
+      defaultParameters: {
+        key: 'value'
+      }
+    });
+
+    middleware(req, res, function(){
       t.deepEquals(called_sanitizers, expected_sanitizers);
       t.end();
     });
+
   });
 };
 
 module.exports.all = function (tape, common) {
 
   function test(name, testFunction) {
-    return tape('SANTIZE /structured ' + name, testFunction);
+    return tape('SANITIZE /structured ' + name, testFunction);
   }
 
   for( var testCase in module.exports.tests ){