rgeo_test.go

/*
Copyright 2020 Sam Smith

Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License.  You may obtain a copy of the
License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.  See the License for the
specific language governing permissions and limitations under the License.
*/

package rgeo

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"math/rand"
	"testing"

	"github.com/go-test/deep"
	"github.com/twpayne/go-geom"
	"github.com/twpayne/go-geom/encoding/geojson"
)

var testdata = []struct {
	name     string
	in       []float64
	err      error
	expected Location
}{
	{
		name: "Algeria",
		in:   []float64{1.880273, 31.787305},
		err:  nil,
		expected: Location{
			Country:      "Algeria",
			CountryLong:  "People's Democratic Republic of Algeria",
			CountryCode2: "DZ",
			CountryCode3: "DZA",
			Continent:    "Africa",
			Region:       "Africa",
			SubRegion:    "Northern Africa",
			Province:     "El Bayadh",
			ProvinceCode: "DZ-32",
		},
	},
	{
		name: "Madagascar",
		in:   []float64{47.523836, -18.905691},
		err:  nil,
		expected: Location{
			Country:      "Madagascar",
			CountryLong:  "Republic of Madagascar",
			CountryCode2: "MG",
			CountryCode3: "MDG",
			Continent:    "Africa",
			Region:       "Africa",
			SubRegion:    "Eastern Africa",
			Province:     "Analamanga",
			ProvinceCode: "MG-T",
			City:         "Antananarivo",
		},
	},
	{
		name: "Zimbabwe",
		in:   []float64{29.832875, -19.948725},
		err:  nil,
		expected: Location{
			Country:      "Zimbabwe",
			CountryLong:  "Republic of Zimbabwe",
			CountryCode2: "ZW",
			CountryCode3: "ZWE",
			Continent:    "Africa",
			Region:       "Africa",
			SubRegion:    "Eastern Africa",
			Province:     "Midlands",
			ProvinceCode: "ZW-MI",
		},
	},
	{
		name:     "Ocean",
		in:       []float64{0, 0},
		err:      ErrLocationNotFound,
		expected: Location{},
	},
	{
		name:     "North Pole",
		in:       []float64{-135, 90},
		err:      ErrLocationNotFound,
		expected: Location{},
	},
	{
		name: "South Pole",
		in:   []float64{44.99, -89.99},
		err:  nil,
		expected: Location{
			Country:      "Antarctica",
			CountryLong:  "",
			CountryCode2: "AQ",
			CountryCode3: "ATA",
			Continent:    "Antarctica",
			Region:       "Antarctica",
			SubRegion:    "Antarctica",
			Province:     "Antarctica",
			ProvinceCode: "AQ-X01~",
		},
	},
	{
		name: "Alaska",
		in:   []float64{-149.901785, 61.199134},
		err:  nil,
		expected: Location{
			Country:      "United States of America",
			CountryLong:  "United States of America",
			CountryCode2: "US",
			CountryCode3: "USA",
			Continent:    "North America",
			Region:       "Americas",
			SubRegion:    "Northern America",
			Province:     "Alaska",
			ProvinceCode: "US-AK",
			City:         "Anchorage",
		},
	},
	{
		name: "UK",
		in:   []float64{0, 51.5045},
		err:  nil,
		expected: Location{
			Country:      "United Kingdom",
			CountryLong:  "United Kingdom of Great Britain and Northern Ireland",
			CountryCode2: "GB",
			CountryCode3: "GBR",
			Continent:    "Europe",
			Region:       "Europe",
			SubRegion:    "Northern Europe",
			Province:     "Tower Hamlets",
			ProvinceCode: "GB-TWH",
			City:         "London",
		},
	},
	{
		name: "Libya",
		in:   []float64{24.98, 25.86},
		err:  nil,
		expected: Location{
			Country:      "Libya",
			CountryLong:  "Libya",
			CountryCode2: "LY",
			CountryCode3: "LBY",
			Continent:    "Africa",
			Region:       "Africa",
			SubRegion:    "Northern Africa",
			Province:     "Al Kufrah",
			ProvinceCode: "LY-KF",
		},
	},
	{
		name: "Egypt",
		in:   []float64{25.005187, 25.855963},
		err:  nil,
		expected: Location{
			Country:      "Egypt",
			CountryLong:  "Arab Republic of Egypt",
			CountryCode2: "EG",
			CountryCode3: "EGY",
			Continent:    "Africa",
			Region:       "Africa",
			SubRegion:    "Northern Africa",
			Province:     "Al Wadi at Jadid",
			ProvinceCode: "EG-WAD",
		},
	},
	{
		name: "US Border",
		in:   []float64{-102.560616, 48.992073},
		err:  nil,
		expected: Location{
			Country:      "United States of America",
			CountryLong:  "United States of America",
			CountryCode2: "US",
			CountryCode3: "USA",
			Continent:    "North America",
			Region:       "Americas",
			SubRegion:    "Northern America",
			Province:     "North Dakota",
			ProvinceCode: "US-ND",
		},
	},
	{
		name: "Canada Border",
		in:   []float64{-102.560616, 49.02},
		err:  nil,
		expected: Location{
			Country:      "Canada",
			CountryLong:  "Canada",
			CountryCode2: "CA",
			CountryCode3: "CAN",
			Continent:    "North America",
			Region:       "Americas",
			SubRegion:    "Northern America",
			Province:     "Saskatchewan",
			ProvinceCode: "CA-SK",
		},
	},
}

func TestReverseGeocode(t *testing.T) {
	testgeo := json.RawMessage(`{
		"type":"FeatureCollection",
			"features":[
				{"type":"Feature",
				"properties":{"ISO_A3_EH":"TST"},
				"geometry":{"type":"Polygon",
					"coordinates":[[[0,52],[1,52],[1,53],[0,53],[0,52]]]}}
			]
		}`)
	var fc geojson.FeatureCollection
	if err := json.Unmarshal(testgeo, &fc); err != nil {
		t.Fatalf("decode GeoJSON: %s", err)
	}
	features, err := LoadGeoJSON(fc)
	if err != nil {
		t.Fatalf("features from GeoJSON: %s", err)
	}

	var testdata = []struct {
		name     string
		in       []float64
		err      error
		expected Location
	}{
		{
			name:     "in",
			in:       []float64{0.5, 52.5},
			err:      nil,
			expected: Location{CountryCode3: "TST"},
		},
		{
			name:     "out",
			in:       []float64{0, 0},
			err:      ErrLocationNotFound,
			expected: Location{},
		},
	}

	r, err := New(func() []Feature { return features })
	if err != nil {
		t.Error(err)
	}

	for _, test := range testdata {
		test := test

		t.Run(test.name, func(t *testing.T) {
			result, err := r.ReverseGeocode(test.in)
			if err != test.err {
				t.Errorf("expected error: %s\n got: %s\n", test.err, err)
			}
			if diff := deep.Equal(test.expected, result); diff != nil {
				t.Error(diff)
			}
		})
	}
}

func TestReverseGeocode_Countries(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test (countries) for short mode")
	}
	t.Parallel()

	for _, dataset := range []Dataset{Countries110, Countries10} {
		r, err := New(dataset)
		if err != nil {
			t.Error(err)
		}

		for _, test := range testdata {
			test := test

			test.expected.Province = ""
			test.expected.ProvinceCode = ""
			test.expected.City = ""

			t.Run(test.name, func(t *testing.T) {
				t.Parallel()

				result, err := r.ReverseGeocode(test.in)
				if err != test.err {
					t.Errorf("expected error: %s\n got: %s\n", test.err, err)
				}
				if diff := deep.Equal(test.expected, result); diff != nil {
					t.Error(diff)
				}
			})
		}
	}
}

func TestReverseGeocode_Provinces(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integraion test (provinces) in short mode")
	}
	t.Parallel()

	r, err := New(Provinces10)
	if err != nil {
		t.Error(err)
	}

	for _, test := range testdata {
		test := test

		test.expected.City = ""

		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			result, err := r.ReverseGeocode(test.in)
			if err != test.err {
				t.Errorf("expected error: %s\n got: %s\n", test.err, err)
			}
			if diff := deep.Equal(test.expected, result); diff != nil {
				t.Error(diff)
			}
		})
	}
}

func TestReverseGeocode_Cities(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test (cities) in short mode.")
	}
	t.Parallel()

	r, err := New(Provinces10, Cities10)
	if err != nil {
		t.Error(err)
	}

	for _, test := range testdata {
		test := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			result, err := r.ReverseGeocode(test.in)
			if err != test.err {
				t.Errorf("expected error: %s\n got: %s\n", test.err, err)
			}
			if diff := deep.Equal(test.expected, result); diff != nil {
				t.Error(diff)
			}
		})
	}
}

func TestLoadGeoJSON_BadData(t *testing.T) {
	testdata := []struct {
		name string
		in   string
		err  string
	}{
		{
			name: "Wrong type",
			in: `{"type":"FeatureCollection","features":
				  [{"type":"Feature","geometry":
				    {"type":"Point","coordinates":[0,0]}}]}`,
			err: "bad polygon in geometry: needs Polygon or MultiPolygon",
		},
		{
			name: "Small polygon",
			in: `{"type":"FeatureCollection","features":
				  [{"type":"Feature","geometry":
				    {"type":"Polygon",
					 "coordinates":[[[1,2],[3,4],[1,2]]]}}]}`,
			err: "bad polygon in geometry: can't convert ring with less than 4 points",
		},
		{
			name: "No repeated end",
			in: `{"type":"FeatureCollection","features":
				  [{"type":"Feature","geometry":
				    {"type":"Polygon",
					 "coordinates":[[[1,2],[3,4],[5,6],[7,8]]]}}]}`,
			err: "bad polygon in geometry: " +
				"last coordinate not same as first for polygon: [1 2 3 4 5 6 7 8]",
		},
		{
			name: "Bad Multipolygon",
			in: `{"type":"FeatureCollection","features":
				  [{"type":"Feature","geometry":
				    {"type":"MultiPolygon",
					 "coordinates":[[[[1,2],[3,4],[5,6],[7,8]]]]}}]}`,
			err: "bad polygon in geometry: " +
				"last coordinate not same as first for polygon: [1 2 3 4 5 6 7 8]",
		},
	}
	for _, test := range testdata {
		test := test
		t.Run(test.name, func(t *testing.T) {
			var fc geojson.FeatureCollection
			if err := json.Unmarshal([]byte(test.in), &fc); err != nil {
				t.Errorf("decode GeoJSON: %s", err)
			} else if _, err := LoadGeoJSON(fc); err != nil && err.Error() != test.err {
				t.Errorf("expected error: %s\n got: %s\n", test.err, err)
			}
		})
	}
}

func TestString(t *testing.T) {
	tests := []struct {
		name     string
		in       Location
		expected string
	}{
		{
			name: "Algeria",
			in: Location{
				Country:      "Algeria",
				CountryCode3: "DZA",
				Continent:    "Africa",
			},
			expected: "<Location> Algeria (DZA), Africa",
		},
		{
			name: "Zimbabwe",
			in: Location{
				CountryLong:  "Republic of Zimbabwe",
				CountryCode2: "ZW",
				Region:       "Africa",
			},
			expected: "<Location> Republic of Zimbabwe (ZW), Africa",
		},
		{
			name: "Northern America",
			in: Location{
				SubRegion: "Northern America",
			},
			expected: "<Location> Northern America",
		},
		{
			name: "London",
			in: Location{
				Country:      "United Kingdom",
				CountryLong:  "United Kingdom of Great Britain and Northern Ireland",
				CountryCode3: "GBR",
				Continent:    "Europe",
				City:         "London",
			},
			expected: "<Location> London, United Kingdom (GBR), Europe",
		},
		{
			name:     "Empty",
			in:       Location{},
			expected: "<Location> Empty Location",
		},
	}

	for _, test := range tests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			result := test.in.String()
			if diff := deep.Equal(test.expected, result); diff != nil {
				t.Error(diff)
			}
		})
	}
}

func ExampleRgeo_ReverseGeocode() {
	r, err := New(Countries110)
	if err != nil {
		// Handle error
	}

	loc, err := r.ReverseGeocode([]float64{0, 52})
	if err != nil {
		// Handle error
	}

	fmt.Printf("%s\n", loc.Country)
	fmt.Printf("%s\n", loc.CountryLong)
	fmt.Printf("%s\n", loc.CountryCode2)
	fmt.Printf("%s\n", loc.CountryCode3)
	fmt.Printf("%s\n", loc.Continent)
	fmt.Printf("%s\n", loc.Region)
	fmt.Printf("%s\n", loc.SubRegion)

	// Output: United Kingdom
	// United Kingdom of Great Britain and Northern Ireland
	// GB
	// GBR
	// Europe
	// Europe
	// Northern Europe
}

func ExampleRgeo_ReverseGeocode_city() {
	r, err := New(Provinces10, Cities10)
	if err != nil {
		// Handle error
	}

	loc, err := r.ReverseGeocode([]float64{141.35, 43.07})
	if err != nil {
		// Handle error
	}

	fmt.Println(loc)
	// Output: <Location> Sapporo, Hokkaidō, Japan (JPN), Asia
}

func ExampleRgeo_ReverseGeocode_snapping() {
	r, err := New(Provinces10)
	if err != nil {
		// Handle error
	}

	loc, err := r.ReverseGeocodeSnapping(geom.Coord{141.5439, 40.5588})
	if err != nil {
		// Handle error
	}

	fmt.Println(loc)
	// Output: <Location> Aomori, Japan (JPN), Asia
}

func TestTable(t *testing.T) {
	type LookupFunc func(geom.Coord) (Location, error)

	coordsFar := geom.Coord{139.0385841, 40.894911} // somewhere in the japanese sea
	coordsClose := geom.Coord{141.5350, 40.5658}    // about 3km outside the country in the sea
	coordsInside := geom.Coord{141.5317, 40.5205}   // inside the country

	locationEmpty := Location{}
	locationFound := Location{Country: "Japan", Province: "Aomori"}

	r, err := New(Provinces10)
	if err != nil {
		// Handle error
	}

	tests := map[string]struct {
		input    geom.Coord
		expected Location
		method   LookupFunc
	}{
		"[reverse] far": {
			input:    coordsFar,
			expected: locationEmpty,
			method:   r.ReverseGeocode,
		},
		"[reverse] close": {
			input:    coordsClose,
			expected: locationEmpty,
			method:   r.ReverseGeocode,
		},
		"[reverse] inside": {
			input:    coordsInside,
			expected: locationFound,
			method:   r.ReverseGeocode,
		},
		"[snapping] far": {
			input:    coordsFar,
			expected: locationEmpty,
			method:   r.ReverseGeocodeSnapping,
		},
		"[snapping] close": {
			input:    coordsClose,
			expected: locationFound,
			method:   r.ReverseGeocodeSnapping,
		},
		"[snapping] inside": {
			input:    coordsInside,
			expected: locationFound,
			method:   r.ReverseGeocodeSnapping,
		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			actual, err := test.method(test.input)
			if err != nil {
				// Handle error
			}

			if actual.Country != test.expected.Country ||
				actual.Province != test.expected.Province ||
				(test.expected == locationEmpty && !errors.Is(err, ErrLocationNotFound)) {
				t.Errorf("expected %q, got %q", test.expected, actual)
			}
		})
	}
}

func BenchmarkReverseGeocode_110(b *testing.B) {
	r, err := New(Countries110)
	if err != nil {
		b.Error(err)
	}

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_, _ = r.ReverseGeocode([]float64{
			(rand.Float64() * 360) - 180,
			(rand.Float64() * 180) - 90,
		})
	}
}

func BenchmarkReverseGeocode_10(b *testing.B) {
	r, err := New(Countries10)
	if err != nil {
		b.Error(err)
	}

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_, _ = r.ReverseGeocode([]float64{
			(rand.Float64() * 360) - 180,
			(rand.Float64() * 180) - 90,
		})
	}
}

func BenchmarkReverseGeocode_Prov10(b *testing.B) {
	r, err := New(Provinces10)
	if err != nil {
		b.Error(err)
	}

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_, _ = r.ReverseGeocode([]float64{
			(rand.Float64() * 360) - 180,
			(rand.Float64() * 180) - 90,
		})
	}
}

func BenchmarkReverseGeocode_City10(b *testing.B) {
	r, err := New(Provinces10, Cities10)
	if err != nil {
		b.Error(err)
	}

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_, _ = r.ReverseGeocode([]float64{
			(rand.Float64() * 360) - 180,
			(rand.Float64() * 180) - 90,
		})
	}
}

func BenchmarkNew(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_, err := New(Countries110)
		if err != nil {
			b.Error(err)
		}
	}
}

func BenchmarkNewCity(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_, err := New(Cities10)
		if err != nil {
			b.Error(err)
		}
	}
}

func testDataset(t *testing.T, text string) Dataset {
	var fc geojson.FeatureCollection
	if err := json.NewDecoder(bytes.NewReader([]byte(text))).Decode(&fc); err != nil {
		t.Fatalf("decode GeoJSON: %s", err)
	}
	features, err := LoadGeoJSON(fc)
	if err != nil {
		t.Fatalf("features from GeoJSON: %s", err)
	}
	return func() []Feature {
		return features
	}
}