Remove timestamp snapshot from log when releasing

.github/workflows/main.yml

@@ -17,7 +17,7 @@ jobs:
       - name: install go
         uses: actions/setup-go@v2
         with:
-          go-version: "^1.17"
+          go-version: "^1.18"
 
       - name: Lint
         run: make lint
@@ -51,7 +51,7 @@ jobs:
 
       - name: Prepare release
         run: |
-          git log $(git describe HEAD~ --tags --abbrev=0)..HEAD --pretty='format:%h - %s (%cr) <%an>' --no-merges > changelog.txt
+          git log $(git describe HEAD~ --tags --abbrev=0)..HEAD --pretty='format:%h - %s <%an>' --no-merges > changelog.txt
           tar  zcvf whatismyip-$RELEASE_VERSION-${{matrix.goosarch}}.tar.gz whatismyip LICENSE README.md
           sha256sum whatismyip-$RELEASE_VERSION-${{matrix.goosarch}}.tar.gz > whatismyip-$RELEASE_VERSION-${{matrix.goosarch}}.tar.gz.sha256
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.17-alpine as builder
+FROM golang:1.18-alpine as builder
 
 ARG ARG_VERSION
 ENV VERSION $ARG_VERSION
@@ -7,7 +7,7 @@ WORKDIR /app
 
 COPY . .
 
-RUN apk add make && make build VERSION=$VERSION
+RUN apk add make git && make build VERSION=$VERSION
 
 # Build final image
 FROM scratch

Makefile

@@ -16,14 +16,20 @@ integration-test:
 .PHONY: install-tools
 install-tools:
 	@command golangci-lint > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOPATH)/bin v1.43.0; \
+		curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOPATH)/bin v1.45.0; \
 	fi
 
 	@command $(GOPATH)/shadow > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@v0.1.7; \
+		go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@v0.1.10; \
+	fi
+
+	@command $(GOPATH)/golines > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		go install github.com/segmentio/golines@latest; \
 	fi
 .PHONY: lint
 lint: install-tools
+	gofmt -l . && test -z $$(gofmt -l .)
+	golines -l . && test -z $$(golines -l .)
 	golangci-lint run
 	shadow ./...
 

README.md

@@ -1,5 +1,10 @@
 # What is my IP address
 
+[![CI](https://github.com/dcarrillo/whatismyip/workflows/CI/badge.svg)](https://github.com/dcarrillo/whatismyip/actions)
+[![Go Report Card](https://goreportcard.com/badge/github.com/dcarrillo/whatismyip)](https://goreportcard.com/report/github.com/dcarrillo/whatismyip)
+[![GitHub release](https://img.shields.io/github/release/dcarrillo/whatismyip.svg)](https://github.com/dcarrillo/whatismyip/releases/)
+[![License Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](./LICENSE)
+
 - [What is my IP address](#what-is-my-ip-address)
   - [Features](#features)
   - [Endpoints](#endpoints)
@@ -11,7 +16,7 @@
     - [Run a default TCP server with a custom template and trust a custom header set by an upstream proxy](#run-a-default-tcp-server-with-a-custom-template-and-trust-a-custom-header-set-by-an-upstream-proxy)
   - [Download](#download)
   - [Docker](#docker)
-    - [Running a container locally using test databases](#running-a-container-locally-using-test-databases)
+    - [Run a container locally using test databases](#run-a-container-locally-using-test-databases)
     - [From Docker Hub](#from-docker-hub)
 
 Just another "what is my IP address" service, including geolocation and headers information, written in go with high performance in mind, it uses [gin](https://github.com/gin-gonic/gin) which uses [httprouter](https://github.com/julienschmidt/httprouter) a lightweight high performance HTTP multiplexer.
@@ -99,13 +104,15 @@ Usage of ./whatismyip:
 ### Run a TLS (HTTP/2) server only
 
 ```bash
-./whatismyip -geoip2-city ./test/GeoIP2-City-Test.mmdb -geoip2-asn ./test/GeoLite2-ASN-Test.mmdb -bind "" -tls-bind :8081 -tls-crt ./test/server.pem -tls-key ./test/server.key
+./whatismyip -geoip2-city ./test/GeoIP2-City-Test.mmdb -geoip2-asn ./test/GeoLite2-ASN-Test.mmdb \
+             -bind "" -tls-bind :8081 -tls-crt ./test/server.pem -tls-key ./test/server.key
 ```
 
 ### Run a default TCP server with a custom template and trust a custom header set by an upstream proxy
 
 ```bash
-./whatismyip -geoip2-city ./test/GeoIP2-City-Test.mmdb -geoip2-asn ./test/GeoLite2-ASN-Test.mmdb -trusted-header X-Real-IP -template mytemplate.tmpl
+./whatismyip -geoip2-city ./test/GeoIP2-City-Test.mmdb -geoip2-asn ./test/GeoLite2-ASN-Test.mmdb \
+             -trusted-header X-Real-IP -template mytemplate.tmpl
 ```
 
 ## Download
@@ -116,7 +123,7 @@ Download latest version from https://github.com/dcarrillo/whatismyip/releases
 
 An ultra-light (~9MB) image is available.
 
-### Running a container locally using test databases
+### Run a container locally using test databases
 
 `make docker-run`
 

cmd/whatismyip.go

@@ -3,6 +3,8 @@ package main
 import (
 	"context"
 	"errors"
+	"flag"
+	"fmt"
 	"log"
 	"net/http"
 	"os"
@@ -24,7 +26,15 @@ var (
 )
 
 func main() {
-	setting.Setup()
+	o, err := setting.Setup(os.Args[1:])
+	if err == flag.ErrHelp || err == setting.ErrVersion {
+		fmt.Print(o)
+		os.Exit(0)
+	} else if err != nil {
+		fmt.Print(err)
+		os.Exit(1)
+	}
+
 	models.Setup(setting.App.GeodbPath.City, setting.App.GeodbPath.ASN)
 	setupEngine()
 	router.SetupTemplate(engine)

go.mod

@@ -1,58 +1,58 @@
 module github.com/dcarrillo/whatismyip
 
-go 1.17
+go 1.18
 
 require (
-	github.com/gin-gonic/gin v1.7.2-0.20211103141324-89a159bdd92c
+	github.com/gin-gonic/gin v1.7.7
 	github.com/oschwald/maxminddb-golang v1.8.0
-	github.com/stretchr/testify v1.7.0
+	github.com/stretchr/testify v1.7.1
-	github.com/testcontainers/testcontainers-go v0.11.1
+	github.com/testcontainers/testcontainers-go v0.12.0
 )
 
 require (
-	github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 // indirect
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
-	github.com/Microsoft/go-winio v0.4.17-0.20210211115548-6eac466e5fa3 // indirect
+	github.com/Microsoft/go-winio v0.5.2 // indirect
-	github.com/Microsoft/hcsshim v0.8.16 // indirect
+	github.com/Microsoft/hcsshim v0.9.2 // indirect
 	github.com/cenkalti/backoff v2.2.1+incompatible // indirect
-	github.com/containerd/cgroups v0.0.0-20210114181951-8a68de567b68 // indirect
+	github.com/containerd/cgroups v1.0.3 // indirect
-	github.com/containerd/containerd v1.5.0-beta.4 // indirect
+	github.com/containerd/containerd v1.6.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/docker/distribution v2.7.1+incompatible // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
-	github.com/docker/docker v20.10.7+incompatible // indirect
+	github.com/docker/docker v20.10.13+incompatible // indirect
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.0 // indirect
 	github.com/go-playground/universal-translator v0.18.0 // indirect
-	github.com/go-playground/validator/v10 v10.9.0 // indirect
+	github.com/go-playground/validator/v10 v10.10.1 // indirect
-	github.com/goccy/go-json v0.7.10 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.0 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/uuid v1.2.0 // indirect
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/magiconair/properties v1.8.6 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/moby/sys/mount v0.2.0 // indirect
+	github.com/moby/sys/mount v0.3.1 // indirect
-	github.com/moby/sys/mountinfo v0.4.1 // indirect
+	github.com/moby/sys/mountinfo v0.6.0 // indirect
-	github.com/moby/term v0.0.0-20201216013528-df9cb8a40635 // indirect
+	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/morikuni/aec v0.0.0-20170113033406-39771216ff4c // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.1 // indirect
+	github.com/opencontainers/image-spec v1.0.2 // indirect
-	github.com/opencontainers/runc v1.0.0-rc93 // indirect
+	github.com/opencontainers/runc v1.1.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/sirupsen/logrus v1.7.0 // indirect
+	github.com/sirupsen/logrus v1.8.1 // indirect
-	github.com/ugorji/go/codec v1.2.6 // indirect
+	github.com/ugorji/go/codec v1.2.7 // indirect
-	go.opencensus.io v0.22.3 // indirect
+	go.opencensus.io v0.23.0 // indirect
-	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 // indirect
+	golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd // indirect
-	golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 // indirect
+	golang.org/x/net v0.0.0-20220225172249-27dd8689420f // indirect
-	golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 // indirect
+	golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8 // indirect
 	golang.org/x/text v0.3.7 // indirect
-	google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a // indirect
+	google.golang.org/genproto v0.0.0-20220317150908-0efb43f6373e // indirect
-	google.golang.org/grpc v1.33.2 // indirect
+	google.golang.org/grpc v1.45.0 // indirect
 	google.golang.org/protobuf v1.27.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect

integration-tests/integration_test.go

@@ -19,7 +19,7 @@ import (
 
 func buildContainer() testcontainers.ContainerRequest {
 	_, filename, _, _ := runtime.Caller(0)
-	dirname := filepath.Dir(filename)
+	dir := filepath.Dir(filename)
 
 	req := testcontainers.ContainerRequest{
 		FromDockerfile: testcontainers.FromDockerfile{
@@ -38,10 +38,10 @@ func buildContainer() testcontainers.ContainerRequest {
 		ExposedPorts: []string{"8000:8000", "8001:8001"},
 		WaitingFor:   wait.ForLog("Starting TLS server listening on :8001"),
 		BindMounts: map[string]string{
-			filepath.Join(dirname, "/../test/GeoIP2-City-Test.mmdb"):  "/tmp/GeoIP2-City-Test.mmdb",
+			"/tmp/GeoIP2-City-Test.mmdb":  filepath.Join(dir, "/../test/GeoIP2-City-Test.mmdb"),
-			filepath.Join(dirname, "/../test/GeoLite2-ASN-Test.mmdb"): "/tmp/GeoLite2-ASN-Test.mmdb",
+			"/tmp/GeoLite2-ASN-Test.mmdb": filepath.Join(dir, "/../test/GeoLite2-ASN-Test.mmdb"),
-			filepath.Join(dirname, "/../test/server.pem"):             "/tmp/server.pem",
+			"/tmp/server.pem":             filepath.Join(dir, "/../test/server.pem"),
-			filepath.Join(dirname, "/../test/server.key"):             "/tmp/server.key",
+			"/tmp/server.key":             filepath.Join(dir, "/../test/server.key"),
 		},
 	}
 

internal/core/version.go

@@ -1,3 +1,4 @@
 package core
 
+// Version to be defined at build time
 var Version = "tobedefined"

internal/httputils/http.go

@@ -9,6 +9,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+// HeadersToSortedString shorts and dumps http.Header to a string separated by \n
 func HeadersToSortedString(headers http.Header) string {
 	var output string
 
@@ -31,6 +32,7 @@ func HeadersToSortedString(headers http.Header) string {
 	return output
 }
 
+// GetLogFormatter returns our custom log format
 func GetLogFormatter(param gin.LogFormatterParams) string {
 	return fmt.Sprintf("%s - [%s] \"%s %s %s\" %d %d %d %s \"%s\" \"%s\" \"%s\"\n",
 		param.ClientIP,
@@ -57,9 +59,8 @@ func normalizeLog(log interface{}) interface{} {
 	case []string:
 		if len(v) == 0 {
 			return "-"
-		} else {
-			return strings.Join(v, ", ")
 		}
+		return strings.Join(v, ", ")
 	}
 
 	return log

internal/setting/app.go

@@ -1,6 +1,8 @@
 package setting
 
 import (
+	"bytes"
+	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -26,74 +28,79 @@ type settings struct {
 	TLSKeyPath    string
 	TrustedHeader string
 	Server        serverSettings
+	version       bool
 }
 
 const defaultAddress = ":8080"
 
-var App *settings
+// ErrVersion is the custom error triggered when -version flag is passed
+var ErrVersion = errors.New("setting: version requested")
 
-func Setup() {
+// App is the var with the parsed settings
-	city := flag.String("geoip2-city", "", "Path to GeoIP2 city database")
+var App = settings{
-	asn := flag.String("geoip2-asn", "", "Path to GeoIP2 ASN database")
+	// hard-coded for the time being
-	template := flag.String("template", "", "Path to template file")
-	address := flag.String(
-		"bind",
-		defaultAddress,
-		"Listening address (see https://pkg.go.dev/net?#Listen)",
-	)
-	addressTLS := flag.String(
-		"tls-bind",
-		"",
-		"Listening address for TLS (see https://pkg.go.dev/net?#Listen)",
-	)
-	tlsCrtPath := flag.String("tls-crt", "", "When using TLS, path to certificate file")
-	tlsKeyPath := flag.String("tls-key", "", "When using TLS, path to private key file")
-	trustedHeader := flag.String(
-		"trusted-header",
-		"",
-		"Trusted request header for remote IP (e.g. X-Real-IP)",
-	)
-	ver := flag.Bool("version", false, "Output version information and exit")
-
-	flag.Parse()
-
-	if *ver {
-		fmt.Printf("whatismyip version %s", core.Version)
-		os.Exit(0)
-	}
-
-	if *city == "" || *asn == "" {
-		exitWithError("geoip2-city and geoip2-asn parameters are mandatory")
-	}
-
-	if (*addressTLS != "") && (*tlsCrtPath == "" || *tlsKeyPath == "") {
-		exitWithError("In order to use TLS -tls-crt and -tls-key flags are mandatory")
-	}
-
-	if *template != "" {
-		info, err := os.Stat(*template)
-		if os.IsNotExist(err) || info.IsDir() {
-			exitWithError(*template + " doesn't exist or it's not a file")
-		}
-	}
-
-	App = &settings{
-		GeodbPath:     geodbPath{City: *city, ASN: *asn},
-		TemplatePath:  *template,
-		BindAddress:   *address,
-		TLSAddress:    *addressTLS,
-		TLSCrtPath:    *tlsCrtPath,
-		TLSKeyPath:    *tlsKeyPath,
-		TrustedHeader: *trustedHeader,
 	Server: serverSettings{
 		ReadTimeout:  10 * time.Second,
 		WriteTimeout: 10 * time.Second,
 	},
 }
+
+// Setup initializes the App object parsing the flags
+func Setup(args []string) (output string, err error) {
+	flags := flag.NewFlagSet("whatismyip", flag.ContinueOnError)
+	var buf bytes.Buffer
+	flags.SetOutput(&buf)
+
+	flags.StringVar(&App.GeodbPath.City, "geoip2-city", "", "Path to GeoIP2 city database")
+	flags.StringVar(&App.GeodbPath.ASN, "geoip2-asn", "", "Path to GeoIP2 ASN database")
+	flags.StringVar(&App.TemplatePath, "template", "", "Path to template file")
+	flags.StringVar(
+		&App.BindAddress,
+		"bind",
+		defaultAddress,
+		"Listening address (see https://pkg.go.dev/net?#Listen)",
+	)
+	flags.StringVar(
+		&App.TLSAddress,
+		"tls-bind",
+		"",
+		"Listening address for TLS (see https://pkg.go.dev/net?#Listen)",
+	)
+	flags.StringVar(&App.TLSCrtPath, "tls-crt", "", "When using TLS, path to certificate file")
+	flags.StringVar(&App.TLSKeyPath, "tls-key", "", "When using TLS, path to private key file")
+	flags.StringVar(&App.TrustedHeader,
+		"trusted-header",
+		"",
+		"Trusted request header for remote IP (e.g. X-Real-IP)",
+	)
+	flags.BoolVar(&App.version, "version", false, "Output version information and exit")
+
+	err = flags.Parse(args)
+	if err != nil {
+		return buf.String(), err
 	}
 
-func exitWithError(error string) {
+	if App.version {
-	fmt.Printf("%s\n\n", error)
+		return fmt.Sprintf("whatismyip version %s", core.Version), ErrVersion
-	flag.Usage()
+	}
-	os.Exit(1)
+
+	if App.GeodbPath.City == "" || App.GeodbPath.ASN == "" {
+		return "", fmt.Errorf("geoip2-city and geoip2-asn parameters are mandatory")
+	}
+
+	if (App.TLSAddress != "") && (App.TLSCrtPath == "" || App.TLSKeyPath == "") {
+		return "", fmt.Errorf("In order to use TLS -tls-crt and -tls-key flags are mandatory")
+	}
+
+	if App.TemplatePath != "" {
+		info, err := os.Stat(App.TemplatePath)
+		if os.IsNotExist(err) {
+			return "", fmt.Errorf("%s no such file or directory", App.TemplatePath)
+		}
+		if info.IsDir() {
+			return "", fmt.Errorf("%s must be a file", App.TemplatePath)
+		}
+	}
+
+	return buf.String(), nil
 }

internal/setting/app_test.go

@@ -0,0 +1,193 @@
+package setting
+
+import (
+	"flag"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseMandatoryFlags(t *testing.T) {
+	var mandatoryFlags = []struct {
+		args []string
+		conf settings
+	}{
+		{
+			[]string{},
+			settings{},
+		},
+		{
+			[]string{"-geoip2-city", "/city-path"},
+			settings{},
+		},
+		{
+			[]string{"-geoip2-asn", "/asn-path"},
+			settings{},
+		},
+		{
+			[]string{
+				"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path", "-tls-bind", ":9000",
+			},
+			settings{},
+		},
+		{
+			[]string{
+				"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path", "-tls-bind", ":9000",
+				"-tls-crt", "/crt-path",
+			},
+			settings{},
+		},
+		{
+			[]string{
+				"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path", "-tls-bind", ":9000",
+				"-tls-key", "/key-path",
+			},
+			settings{},
+		},
+	}
+
+	for _, tt := range mandatoryFlags {
+		t.Run(strings.Join(tt.args, " "), func(t *testing.T) {
+			_, err := Setup(tt.args)
+			assert.NotNil(t, err)
+			assert.Contains(t, err.Error(), "mandatory")
+		})
+	}
+}
+
+func TestParseFlags(t *testing.T) {
+	var flags = []struct {
+		args []string
+		conf settings
+	}{
+		{
+			[]string{"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path"},
+			settings{
+				GeodbPath: geodbPath{
+					City: "/city-path",
+					ASN:  "/asn-path",
+				},
+				TemplatePath:  "",
+				BindAddress:   ":8080",
+				TLSAddress:    "",
+				TLSCrtPath:    "",
+				TLSKeyPath:    "",
+				TrustedHeader: "",
+				Server: serverSettings{
+					ReadTimeout:  10 * time.Second,
+					WriteTimeout: 10 * time.Second,
+				},
+			},
+		},
+		{
+			[]string{"-bind", ":8001", "-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path"},
+			settings{
+				GeodbPath: geodbPath{
+					City: "/city-path",
+					ASN:  "/asn-path",
+				},
+				TemplatePath:  "",
+				BindAddress:   ":8001",
+				TLSAddress:    "",
+				TLSCrtPath:    "",
+				TLSKeyPath:    "",
+				TrustedHeader: "",
+				Server: serverSettings{
+					ReadTimeout:  10 * time.Second,
+					WriteTimeout: 10 * time.Second,
+				},
+			},
+		},
+		{
+			[]string{
+				"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path", "-tls-bind", ":9000",
+				"-tls-crt", "/crt-path", "-tls-key", "/key-path",
+			},
+			settings{
+				GeodbPath: geodbPath{
+					City: "/city-path",
+					ASN:  "/asn-path",
+				},
+				TemplatePath:  "",
+				BindAddress:   ":8080",
+				TLSAddress:    ":9000",
+				TLSCrtPath:    "/crt-path",
+				TLSKeyPath:    "/key-path",
+				TrustedHeader: "",
+				Server: serverSettings{
+					ReadTimeout:  10 * time.Second,
+					WriteTimeout: 10 * time.Second,
+				},
+			},
+		},
+		{
+			[]string{
+				"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path",
+				"-trusted-header", "header",
+			},
+			settings{
+				GeodbPath: geodbPath{
+					City: "/city-path",
+					ASN:  "/asn-path",
+				},
+				TemplatePath:  "",
+				BindAddress:   ":8080",
+				TLSAddress:    "",
+				TLSCrtPath:    "",
+				TLSKeyPath:    "",
+				TrustedHeader: "header",
+				Server: serverSettings{
+					ReadTimeout:  10 * time.Second,
+					WriteTimeout: 10 * time.Second,
+				},
+			},
+		},
+	}
+
+	for _, tt := range flags {
+		t.Run(strings.Join(tt.args, " "), func(t *testing.T) {
+			_, err := Setup(tt.args)
+			assert.Nil(t, err)
+			assert.True(t, reflect.DeepEqual(App, tt.conf))
+		})
+	}
+}
+
+func TestParseFlagsUsage(t *testing.T) {
+	var usageArgs = []string{"-help", "-h", "--help"}
+
+	for _, arg := range usageArgs {
+		t.Run(arg, func(t *testing.T) {
+			output, err := Setup([]string{arg})
+			assert.ErrorIs(t, err, flag.ErrHelp)
+			assert.Contains(t, output, "Usage of")
+		})
+	}
+}
+
+func TestParseFlagVersion(t *testing.T) {
+	output, err := Setup([]string{"-version"})
+	assert.ErrorIs(t, err, ErrVersion)
+	assert.Contains(t, output, "whatismyip version")
+}
+
+func TestParseFlagTemplate(t *testing.T) {
+	flags := []string{
+		"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path",
+		"-template", "/template-path",
+	}
+	_, err := Setup(flags)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "no such file or directory")
+
+	flags = []string{
+		"-geoip2-city", "/city-path", "-geoip2-asn", "/asn-path",
+		"-template", "/",
+	}
+	_, err = Setup(flags)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "must be a file")
+}

models/geo.go

@@ -7,10 +7,7 @@ import (
 	"github.com/oschwald/maxminddb-golang"
 )
 
-type Record interface {
+// GeoRecord is the model for City database
-	LookUp(ip net.IP)
-}
-
 type GeoRecord struct {
 	Country struct {
 		ISOCode string            `maxminddb:"iso_code"`
@@ -29,6 +26,7 @@ type GeoRecord struct {
 	} `maxminddb:"postal"`
 }
 
+// ASNRecord is the model for ASN database
 type ASNRecord struct {
 	AutonomousSystemNumber       uint   `maxminddb:"autonomous_system_number"`
 	AutonomousSystemOrganization string `maxminddb:"autonomous_system_organization"`
@@ -51,11 +49,13 @@ func openMMDB(path string) *maxminddb.Reader {
 	return db
 }
 
+// Setup opens all Geolite2 databases
 func Setup(cityPath string, asnPath string) {
 	db.city = openMMDB(cityPath)
 	db.asn = openMMDB(asnPath)
 }
 
+// CloseDBs unmaps from memory and frees resources to the filesystem
 func CloseDBs() {
 	log.Printf("Closing dbs...")
 	if err := db.city.Close(); err != nil {
@@ -66,18 +66,18 @@ func CloseDBs() {
 	}
 }
 
+// LookUp an IP and get city data
 func (record *GeoRecord) LookUp(ip net.IP) error {
-	err := db.city.Lookup(ip, record)
+	if err := db.city.Lookup(ip, record); err != nil {
-	if err != nil {
 		return err
 	}
 
 	return nil
 }
 
+// LookUp an IP and get ASN data
 func (record *ASNRecord) LookUp(ip net.IP) error {
-	err := db.asn.Lookup(ip, record)
+	if err := db.asn.Lookup(ip, record); err != nil {
-	if err != nil {
 		return err
 	}
 

models/geo_test.go

@@ -0,0 +1,77 @@
+package models
+
+import (
+	"net"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestModels(t *testing.T) {
+	expectedCity := &GeoRecord{
+		Country: struct {
+			ISOCode string            "maxminddb:\"iso_code\""
+			Names   map[string]string "maxminddb:\"names\""
+		}{
+			ISOCode: "GB",
+			Names: map[string]string{
+				"de":    "Vereinigtes Königreich",
+				"en":    "United Kingdom",
+				"es":    "Reino Unido",
+				"fr":    "Royaume-Uni",
+				"ja":    "イギリス",
+				"pt-BR": "Reino Unido",
+				"ru":    "Великобритания",
+				"zh-CN": "英国",
+			},
+		},
+		City: struct {
+			Names map[string]string "maxminddb:\"names\""
+		}{
+			Names: map[string]string{
+				"de":    "London",
+				"en":    "London",
+				"es":    "Londres",
+				"fr":    "Londres",
+				"ja":    "ロンドン",
+				"pt-BR": "Londres",
+				"ru":    "Лондон",
+			},
+		},
+		Location: struct {
+			Latitude  float64 "maxminddb:\"latitude\""
+			Longitude float64 "maxminddb:\"longitude\""
+			TimeZone  string  "maxminddb:\"time_zone\""
+		}{
+			Latitude:  51.5142,
+			Longitude: -0.0931,
+			TimeZone:  "Europe/London",
+		},
+		Postal: struct {
+			Code string "maxminddb:\"code\""
+		}{
+			Code: "",
+		},
+	}
+
+	expectedASN := &ASNRecord{
+		AutonomousSystemNumber:       12552,
+		AutonomousSystemOrganization: "IP-Only",
+	}
+
+	Setup("../test/GeoIP2-City-Test.mmdb", "../test/GeoLite2-ASN-Test.mmdb")
+	defer CloseDBs()
+
+	assert.NotNil(t, db.asn)
+	assert.NotNil(t, db.city)
+
+	cityRecord := &GeoRecord{}
+	assert.Nil(t, cityRecord.LookUp(net.ParseIP("81.2.69.192")))
+	assert.Equal(t, expectedCity, cityRecord)
+	assert.Error(t, cityRecord.LookUp(net.ParseIP("error")))
+
+	asnRecord := &ASNRecord{}
+	assert.Nil(t, asnRecord.LookUp(net.ParseIP("82.99.17.64")))
+	assert.Equal(t, expectedASN, asnRecord)
+	assert.Error(t, asnRecord.LookUp(net.ParseIP("error")))
+}

router/generic.go

@@ -14,6 +14,7 @@ import (
 
 const userAgentPattern = `curl|wget|libwww-perl|python|ansible-httpget|HTTPie|WindowsPowerShell|http_request|Go-http-client|^$`
 
+// JSONResponse maps data as json
 type JSONResponse struct {
 	IP              string      `json:"ip"`
 	IPVersion       byte        `json:"ip_version"`

router/headers_test.go

@@ -28,9 +28,11 @@ Host:
 `
 
 	req, _ := http.NewRequest("GET", "/headers", nil)
-	req.Header["Header1"] = []string{"value1"}
+	req.Header = map[string][]string{
-	req.Header["Header2"] = []string{"value21", "value22"}
+		"Header1": {"value1"},
-	req.Header["Header3"] = []string{"value3"}
+		"Header2": {"value21", "value22"},
+		"Header3": {"value3"},
+	}
 
 	w := httptest.NewRecorder()
 	app.ServeHTTP(w, req)

router/setup.go

@@ -8,6 +8,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+// SetupTemplate reads and parses a template from file
 func SetupTemplate(r *gin.Engine) {
 	if setting.App.TemplatePath == "" {
 		t, _ := template.New("home").Parse(home)
@@ -18,6 +19,7 @@ func SetupTemplate(r *gin.Engine) {
 	}
 }
 
+// Setup defines the endpoints
 func Setup(r *gin.Engine) {
 	r.GET("/", getRoot)
 	r.GET("/client-port", getClientPortAsString)

router/templates_test.go

@@ -54,10 +54,11 @@ const expectedHome = `
 
 func TestDefaultTemplate(t *testing.T) {
 	req, _ := http.NewRequest("GET", "/", nil)
-
+	req.Header = map[string][]string{
-	req.Header["Header1"] = []string{"value1"}
+		"Header1": {"value1"},
-	req.Header["Header2"] = []string{"value21", "value22"}
+		"Header2": {"value21", "value22"},
-	req.Header["Header3"] = []string{"value3"}
+		"Header3": {"value3"},
+	}
 
 	tmpl, _ := template.New("home").Parse(home)
 	response := JSONResponse{

service/geo.go

@@ -7,10 +7,12 @@ import (
 	"github.com/dcarrillo/whatismyip/models"
 )
 
+// Geo defines a base type for lookups
 type Geo struct {
 	IP net.IP
 }
 
+// LookUpCity queries the database for city data related to the given IP
 func (g *Geo) LookUpCity() *models.GeoRecord {
 	record := &models.GeoRecord{}
 	err := record.LookUp(g.IP)
@@ -22,6 +24,7 @@ func (g *Geo) LookUpCity() *models.GeoRecord {
 	return record
 }
 
+// LookUpASN queries the database for ASN data related to the given IP
 func (g *Geo) LookUpASN() *models.ASNRecord {
 	record := &models.ASNRecord{}
 	err := record.LookUp(g.IP)