Refactor setting module and add tests (#4)

This commit is contained in:
Daniel Carrillo 2021-11-29 18:16:27 +01:00 committed by GitHub
parent 2571e22843
commit 8b5cccd744
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 250 additions and 44 deletions

View File

@ -3,6 +3,8 @@ package main
import ( import (
"context" "context"
"errors" "errors"
"flag"
"fmt"
"log" "log"
"net/http" "net/http"
"os" "os"
@ -24,7 +26,15 @@ var (
) )
func main() { 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) models.Setup(setting.App.GeodbPath.City, setting.App.GeodbPath.ASN)
setupEngine() setupEngine()
router.SetupTemplate(engine) router.SetupTemplate(engine)

View File

@ -1,6 +1,8 @@
package setting package setting
import ( import (
"bytes"
"errors"
"flag" "flag"
"fmt" "fmt"
"os" "os"
@ -26,74 +28,75 @@ type settings struct {
TLSKeyPath string TLSKeyPath string
TrustedHeader string TrustedHeader string
Server serverSettings Server serverSettings
version bool
} }
const defaultAddress = ":8080" const defaultAddress = ":8080"
var App *settings var ErrVersion = errors.New("setting: version requested")
var App = settings{
func Setup() { // hard-coded for the time being
city := flag.String("geoip2-city", "", "Path to GeoIP2 city database")
asn := flag.String("geoip2-asn", "", "Path to GeoIP2 ASN database")
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{ Server: serverSettings{
ReadTimeout: 10 * time.Second, ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second,
}, },
} }
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
} }

View File

@ -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")
}