minor: support private ipaddress filtering

Author: circa10a

README.md

@@ -34,6 +34,8 @@ func main() {
 		// Maximum radius of the geofence in kilometers, only clients less than or equal to this distance will return true with isAddressNearby
 		// 1 kilometer
 		Radius: 1.0,
+		// Allow 192.X, 172.X, 10.X and loopback addresses
+		AllowPrivateIPAddresses: true
 		// How long to cache if any ip address is nearby
 		CacheTTL: 7 * (24 * time.Hour), // 1 week
 	})
@@ -48,49 +50,3 @@ func main() {
 	fmt.Println("Address nearby: ", isAddressNearby)
 }
 ```
-
-### Private IP Addresses
-
-Private IP's will always result in `false` since their coordinates will come back as `0.0000`. You can work around these like so:
-
-```go
-package main
-
-import (
-	"fmt"
-	"log"
-	"net"
-	"time"
-
-	"github.com/circa10a/go-geofence"
-)
-
-func main() {
-	// Provide an IP Address to test with
-	ipAddress := "192.168.1.100"
-	geofence, err := geofence.New(&geofence.Config{
-		// Empty string to geofence your current public IP address, or you can monitor a remote address by supplying it as the first parameter
-		IPAddress: ipAddress,
-		// freegeoip.app API token
-		Token: "YOUR_FREEGEOIP_API_TOKEN",
-		// Maximum radius of the geofence in kilometers, only clients less than or equal to this distance will return true with isAddressNearby
-		// 1 kilometer
-		Radius: 1.0,
-		// How long to cache if any ip address is nearby
-		CacheTTL: 7 * (24 * time.Hour), // 1 week
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-	// Skip Private IP analysis as it will always be false
-	ip := net.ParseIP(ipAddress)
-	if !ip.IsPrivate() || !ip.IsLoopback() {
-		isAddressNearby, err := geofence.IsIPAddressNear(ipAddress)
-		if err != nil {
-			log.Fatal(err)
-		}
-		// Address nearby: false
-		fmt.Println("Address nearby: ", isAddressNearby)
-	}
-}
-```

geofence.go

@@ -17,10 +17,11 @@ const (
 
 // Config holds the user configuration to setup a new geofence
 type Config struct {
-	IPAddress string
-	Token     string
-	Radius    float64
-	CacheTTL  time.Duration
+	IPAddress               string
+	Token                   string
+	Radius                  float64
+	AllowPrivateIPAddresses bool
+	CacheTTL                time.Duration
 }
 
 // Geofence holds a freegeoip.app client, cache and user supplied config
@@ -124,6 +125,13 @@ func (g *Geofence) IsIPAddressNear(ipAddress string) (bool, error) {
 		return false, err
 	}
 
+	if g.AllowPrivateIPAddresses {
+		ip := net.ParseIP(ipAddress)
+		if ip.IsPrivate() || ip.IsLoopback() {
+			return true, nil
+		}
+	}
+
 	// Check if ipaddress has been looked up before and is in cache
 	if isIPAddressNear, found := g.Cache.Get(ipAddress); found {
 		return isIPAddressNear.(bool), nil

geofence_test.go

@@ -99,6 +99,61 @@ func TestGeofenceNear(t *testing.T) {
 	assert.Equal(t, info[fmt.Sprintf("GET %s", fakeEndpoint)], 1)
 }
 
+func TestGeofencePrivateIP(t *testing.T) {
+	fakeIPAddress := "192.168.1.1"
+	fakeApiToken := "fakeApiToken"
+	fakeLatitude := 37.751
+	fakeLongitude := -97.822
+	fakeRadius := 0.0
+	fakeEndpoint := fmt.Sprintf("%s/%s?apikey=%s", freeGeoIPBaseURL, fakeIPAddress, fakeApiToken)
+
+	// new geofence
+	geofence, _ := New(&Config{
+		IPAddress:               fakeIPAddress,
+		Token:                   fakeApiToken,
+		Radius:                  fakeRadius,
+		AllowPrivateIPAddresses: true,
+		CacheTTL:                7 * (24 * time.Hour), // 1 week
+	})
+	geofence.Latitude = fakeLatitude
+	geofence.Longitude = fakeLongitude
+
+	httpmock.ActivateNonDefault(geofence.FreeGeoIPClient.GetClient())
+	defer httpmock.DeactivateAndReset()
+
+	// mock json rsponse
+	response := &FreeGeoIPResponse{
+		IP:          fakeIPAddress,
+		CountryCode: "US",
+		CountryName: "United States",
+		TimeZone:    "America/Chicago",
+		Latitude:    fakeLatitude,
+		Longitude:   fakeLongitude,
+	}
+
+	// mock freegeoip.app response
+	httpmock.RegisterResponder("GET", fakeEndpoint,
+		func(req *http.Request) (*http.Response, error) {
+			resp, err := httpmock.NewJsonResponse(200, response)
+			if err != nil {
+				return httpmock.NewStringResponse(500, ""), nil
+			}
+			return resp, nil
+		})
+
+	// check that addresses is nearby
+	isAddressNearby, err := geofence.IsIPAddressNear(fakeIPAddress)
+	assert.NoError(t, err)
+	assert.True(t, isAddressNearby)
+
+	// get count info
+	httpmock.GetTotalCallCount()
+	// get the amount of calls for the registered responder
+	info := httpmock.GetCallCountInfo()
+	// Check total calls
+	assert.Equal(t, info[fmt.Sprintf("GET %s", fakeEndpoint)], 0)
+}
+
 func TestGeofenceNotNear(t *testing.T) {
 	fakeIPAddress := "8.8.8.8"
 	fakeApiToken := "fakeApiToken"