added support for non-coarse req.clean.layers

controller/coarse_reverse.js

@@ -22,7 +22,7 @@ function getMostGranularLayer(results) {
 }
 
 function hasResultsAtRequestedLayers(results, layers) {
-  return _.intersection(layers, Object.keys(results)).length > 0;
+  return _.isEmpty(layers) || !_.isEmpty(_.intersection(layers, Object.keys(results)));
 }
 
 function synthesizeDoc(results) {
@@ -110,7 +110,7 @@ function setup(service, should_execute) {
       res.meta = {};
       res.data = [];
       // synthesize a doc from results if there's a result at the request layer(s)
-      if (hasResultsAtRequestedLayers(results, req.clean.layers)) {
+      if (hasResultsAtRequestedLayers(results, _.without(req.clean.layers, 'venue', 'address', 'street'))) {
         res.data.push(synthesizeDoc(results));
       }
 

routes/v1.js

@@ -101,6 +101,10 @@ function addRoutes(app, peliasConfig) {
     not(hasRequestErrors), isPipServiceEnabled, isCoarseReverse
   );
 
+  const coarse_reverse_fallback_should_execute = all(
+    isPipServiceEnabled, not(hasRequestErrors), not(hasResponseData), not(isCoarseReverse)
+  );
+
   const placeholderShouldExecute = all(
     not(hasResponseDataOrRequestErrors), isPlaceholderServiceEnabled, isAdminOnlyAnalysis
   );
@@ -198,6 +202,7 @@ function addRoutes(app, peliasConfig) {
       middleware.calcSize(),
       controllers.coarse_reverse(pipService, coarse_reverse_should_execute),
       controllers.search(peliasConfig.api, esclient, queries.reverse, original_reverse_should_execute),
+      controllers.coarse_reverse(pipService, coarse_reverse_fallback_should_execute),
       postProc.distances('point.'),
       // reverse confidence scoring depends on distance from origin
       //  so it must be calculated first

test/unit/controller/coarse_reverse.js

@@ -465,6 +465,188 @@ module.exports.tests.success_conditions = (test, common) => {
 
   });
 
+  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 = (point, do_not_track, callback) => {
+        t.equals(do_not_track, 'do_not_track value');
+        const results = {
+          neighbourhood: [
+            {
+              id: 10,
+              name: 'neighbourhood name',
+              abbr: 'neighbourhood abbr'
+            }
+          ]
+        };
+
+        callback(undefined, results);
+      };
+
+      const logger = require('pelias-mock-logger')();
+
+      const should_execute = () => { return true; };
+      const controller = proxyquire('../../../controller/coarse_reverse', {
+        'pelias-logger': logger,
+        '../helper/logging': {
+          isDNT: () => {
+            return 'do_not_track value';
+          }
+        }
+      })(service, should_execute);
+
+      const req = {
+        clean: {
+          layers: [non_coarse_layer],
+          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(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 = (point, do_not_track, callback) => {
+        t.equals(do_not_track, 'do_not_track value');
+        const results = {
+          neighbourhood: [
+            {
+              id: 10,
+              name: 'neighbourhood name',
+              abbr: 'neighbourhood abbr'
+            }
+          ]
+        };
+
+        callback(undefined, results);
+      };
+
+      const logger = require('pelias-mock-logger')();
+
+      const should_execute = () => { return true; };
+      const controller = proxyquire('../../../controller/coarse_reverse', {
+        'pelias-logger': logger,
+        '../helper/logging': {
+          isDNT: () => {
+            return 'do_not_track value';
+          }
+        }
+      })(service, should_execute);
+
+      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(res, expected);
+
+      t.notOk(logger.hasErrorMessages());
+
+    });
+
+    t.end();
+
+  });
+
 };
 
 module.exports.tests.failure_conditions = (test, common) => {