Add more tests, update language

Author: camdecoster

test/jasmine/tests/lib_geo_location_utils_test.js

@@ -4,17 +4,27 @@ const {
     unwrapLonRange,
     doesCrossAntiMeridian
 } = require('../../../src/lib/geo_location_utils');
+const loggers = require('../../../src/lib/loggers');
+
+function extractSingleFeature(geometry) {
+    const trace = {
+        _length: 1,
+        geojson: { type: 'Feature', id: 'Omicron Persei 8', geometry }
+    };
+
+    return extractTraceFeature([{ loc: 'Omicron Persei 8', trace }])[0];
+}
 
 describe('Test geo_location_utils.extractTraceFeature', () => {
-    it('keeps degenerate MultiPolygons without affecting valid features', () => {
+    it('keeps MultiPolygons with no positive-area polygon without affecting valid features', () => {
         const trace = {
             _length: 2,
             geojson: {
                 type: 'FeatureCollection',
                 features: [
                     {
                         type: 'Feature',
-                        id: 'degenerate',
+                        id: 'zero-area',
                         geometry: {
                             type: 'MultiPolygon',
                             coordinates: [
@@ -49,18 +59,71 @@ describe('Test geo_location_utils.extractTraceFeature', () => {
             }
         };
         const calcTrace = [
-            { loc: 'degenerate', trace },
+            { loc: 'zero-area', trace },
             { loc: 'valid', trace }
         ];
 
         const features = extractTraceFeature(calcTrace);
 
         expect(features.length).toBe(2);
-        expect(features[0].id).toBe('degenerate');
+        expect(features[0].id).toBe('zero-area');
         expect(features[0].properties.ct.every(Number.isNaN)).toBe(true);
         expect(features[1].id).toBe('valid');
         expect(features[1].properties.ct.every(Number.isFinite)).toBe(true);
     });
+
+    it('keeps Polygons and MultiPolygons whose rings hold no points', () => {
+        const polygon = extractSingleFeature({ type: 'Polygon', coordinates: [[]] });
+        const multiPolygon = extractSingleFeature({ type: 'MultiPolygon', coordinates: [[[]]] });
+
+        expect(polygon.properties.ct.every(Number.isNaN)).toBe(true);
+        expect(multiPolygon.properties.ct.every(Number.isNaN)).toBe(true);
+    });
+
+    it('logs the locations whose centroid could not be computed', () => {
+        spyOn(loggers, 'log');
+
+        extractSingleFeature({
+            type: 'MultiPolygon',
+            coordinates: [
+                [
+                    [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [0, 0]
+                    ]
+                ]
+            ]
+        });
+
+        expect(loggers.log).toHaveBeenCalledWith(
+            [
+                'Location Omicron Persei 8 has no polygon with positive area.',
+                'Its centroid could not be computed,',
+                'so hover and selection will not work for it.'
+            ].join(' ')
+        );
+    });
+
+    it('does not log for features with a computable centroid', () => {
+        spyOn(loggers, 'log');
+
+        extractSingleFeature({
+            type: 'Polygon',
+            coordinates: [
+                [
+                    [0, 0],
+                    [0, 1],
+                    [1, 1],
+                    [1, 0],
+                    [0, 0]
+                ]
+            ]
+        });
+
+        expect(loggers.log).not.toHaveBeenCalled();
+    });
 });
 
 describe('Test geo_location_utils.getFitboundsLonRange', () => {