Coverage improvements (#30)

* Improve coverage for version_strategy.go

* Some style tweaks according to golangci-lint

* Cover alpine in a slightly different way

* Clear up debug logging

* Rename alpine check

* Add CircleCI build badge and format markdown.

Author: fergusstrange

CONTRIBUTING.md

@@ -1,10 +1,13 @@
 # Contributing to embedded-postgres
 
-Thank you for taking the time to contribute. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
+Thank you for taking the time to contribute. These are mostly guidelines, not rules. Use your best judgment, and feel
+free to propose changes to this document in a pull request.
 
 # Working with forked go repos
 
-If you haven't worked with forked go repos before, take a look at this blog post for some excellent advice about [contributing to go open source git repositories](https://splice.com/blog/contributing-open-source-git-repositories-go/).
+If you haven't worked with forked go repos before, take a look at this blog post for some excellent advice
+about [contributing to go open source git repositories](https://splice.com/blog/contributing-open-source-git-repositories-go/)
+.
 
 # PRs
 
@@ -15,4 +18,5 @@ If you haven't worked with forked go repos before, take a look at this blog post
 
 # Documentation
 
-For simple typo fixes and documentation improvements feel free to raise a PR without raising an issue in github. For anything more complicated please file an issue.
+For simple typo fixes and documentation improvements feel free to raise a PR without raising an issue in github. For
+anything more complicated please file an issue.

README.md

@@ -6,20 +6,27 @@
 <a href="https://godoc.org/github.com/fergusstrange/embedded-postgres"><img src="https://godoc.org/github.com/fergusstrange/embedded-postgres?status.svg" alt="Godoc" /></a>
 <a href='https://coveralls.io/github/fergusstrange/embedded-postgres?branch=master'><img src='https://coveralls.io/repos/github/fergusstrange/embedded-postgres/badge.svg?branch=master' alt='Coverage Status' /></a>
 <a href="https://github.com/fergusstrange/embedded-postgres/actions"><img src="https://github.com/fergusstrange/embedded-postgres/workflows/Embedded%20Postgres/badge.svg" alt="Build Status" /></a>
+<a href="https://app.circleci.com/pipelines/github/fergusstrange/embedded-postgres"><img src="https://circleci.com/gh/fergusstrange/embedded-postgres.svg?style=shield" alt="Build Status" /></a>
 <a href="https://goreportcard.com/report/github.com/fergusstrange/embedded-postgres"><img src="https://goreportcard.com/badge/github.com/fergusstrange/embedded-postgres" alt="Go Report Card" /></a>
 </p>
 
 # embedded-postgres
 
 Run a real Postgres database locally on Linux, OSX or Windows as part of another Go application or test.
 
-When testing this provides a higher level of confidence than using any in memory alternative. It also requires no other external dependencies outside of the Go build ecosystem.
+When testing this provides a higher level of confidence than using any in memory alternative. It also requires no other
+external dependencies outside of the Go build ecosystem.
 
-Heavily inspired by Java projects [zonkyio/embedded-postgres](https://github.com/zonkyio/embedded-postgres) and [opentable/otj-pg-embedded](https://github.com/opentable/otj-pg-embedded) and reliant on the great work being done by [zonkyio/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries) in order to fetch precompiled binaries from [Maven](https://mvnrepository.com/artifact/io.zonky.test.postgres/embedded-postgres-binaries-bom).
+Heavily inspired by Java projects [zonkyio/embedded-postgres](https://github.com/zonkyio/embedded-postgres)
+and [opentable/otj-pg-embedded](https://github.com/opentable/otj-pg-embedded) and reliant on the great work being done
+by [zonkyio/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries) in order to fetch
+precompiled binaries
+from [Maven](https://mvnrepository.com/artifact/io.zonky.test.postgres/embedded-postgres-binaries-bom).
 
 ## Installation
 
-embedded-postgres uses Go modules and as such can be referenced by release version for use as a library. Use the following to add the latest release to your project. 
+embedded-postgres uses Go modules and as such can be referenced by release version for use as a library. Use the
+following to add the latest release to your project.
 
 ```bash
 go get -u github.com/fergusstrange/embedded-postgres
@@ -40,15 +47,15 @@ This library aims to require as little configuration as possible, favouring over
 | Port           | 5432                                            |
 | StartTimeout   | 15 Seconds                                      |
 
-The *RuntimePath* directory is erased and recreated at each `Start()` and therefore not
-suitable for persistent data.
+The *RuntimePath* directory is erased and recreated at each `Start()` and therefore not suitable for persistent data.
 
 If a persistent data location is required, set *DataPath* to a directory outside *RuntimePath*.
 
-If the *RuntimePath* directory is empty or already initialized but with an incompatible postgres version,
-it will be removed and Postgres reinitialized.
+If the *RuntimePath* directory is empty or already initialized but with an incompatible postgres version, it will be
+removed and Postgres reinitialized.
 
 A single Postgres instance can be created, started and stopped as follows
+
 ```go
 postgres := embeddedpostgres.NewDatabase()
 err := postgres.Start()
@@ -57,35 +64,40 @@ err := postgres.Start()
 
 err := postgres.Stop()
 ```
+
 or with created with custom configuration
+
 ```go
 logger := &bytes.Byffer{}
 postgres := NewDatabase(DefaultConfig().
-            Username("beer").
-            Password("wine").
-            Database("gin").
-            Version(V12).
-            RuntimePath("/tmp").
-            Port(9876).
-            StartTimeout(45 * time.Second).
-            Logger(logger))
+Username("beer").
+Password("wine").
+Database("gin").
+Version(V12).
+RuntimePath("/tmp").
+Port(9876).
+StartTimeout(45 * time.Second).
+Logger(logger))
 err := postgres.Start()
 
 // Do test logic
 
 err := postgres.Stop()
 ```
 
-It should be noted that if `postgres.Stop()` is not called then the child Postgres process will not be released and the caller will block.
+It should be noted that if `postgres.Stop()` is not called then the child Postgres process will not be released and the
+caller will block.
 
 ## Examples
 
-There are a number of realistic representations of how to use this library in [examples](https://github.com/fergusstrange/embedded-postgres/tree/master/examples). 
+There are a number of realistic representations of how to use this library
+in [examples](https://github.com/fergusstrange/embedded-postgres/tree/master/examples).
 
 ## Credits
 
 - [Gopherize Me](https://gopherize.me) Thanks for the awesome logo template.
-- [zonkyio/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries) Without which the precompiled Postgres binaries would not exist for this to work. 
+- [zonkyio/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries) Without which the
+  precompiled Postgres binaries would not exist for this to work.
 
 ## Contributing
 

cache_locator.go

@@ -16,16 +16,20 @@ func defaultCacheLocator(versionStrategy VersionStrategy) CacheLocator {
 		if userHome, err := os.UserHomeDir(); err == nil {
 			cacheDirectory = filepath.Join(userHome, ".embedded-postgres-go")
 		}
+
 		operatingSystem, architecture, version := versionStrategy()
 		cacheLocation := filepath.Join(cacheDirectory,
 			fmt.Sprintf("embedded-postgres-binaries-%s-%s-%s.txz",
 				operatingSystem,
 				architecture,
 				version))
+
 		info, err := os.Stat(cacheLocation)
+
 		if err != nil {
 			return cacheLocation, os.IsExist(err) && !info.IsDir()
 		}
+
 		return cacheLocation, !info.IsDir()
 	}
 }

embedded_postgres.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/mholt/archiver/v3"
@@ -36,7 +37,13 @@ func NewDatabase(config ...Config) *EmbeddedPostgres {
 }
 
 func newDatabaseWithConfig(config Config) *EmbeddedPostgres {
-	versionStrategy := defaultVersionStrategy(config)
+	versionStrategy := defaultVersionStrategy(
+		config,
+		runtime.GOOS,
+		runtime.GOARCH,
+		linuxMachineName,
+		shouldUseAlpineLinuxBuild,
+	)
 	cacheLocator := defaultCacheLocator(versionStrategy)
 	remoteFetchStrategy := defaultRemoteFetchStrategy("https://repo1.maven.org", versionStrategy, cacheLocator)
 

embedded_postgres_test.go

@@ -21,7 +21,7 @@ func Test_DefaultConfig(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err := sql.Open("postgres", fmt.Sprintf("host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable"))
+	db, err := sql.Open("postgres", "host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}
@@ -257,7 +257,7 @@ func Test_CustomConfig(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err := sql.Open("postgres", fmt.Sprintf("host=localhost port=9876 user=gin password=wine dbname=beer sslmode=disable"))
+	db, err := sql.Open("postgres", "host=localhost port=9876 user=gin password=wine dbname=beer sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}
@@ -282,7 +282,7 @@ func Test_CustomLocaleConfig(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err := sql.Open("postgres", fmt.Sprintf("host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable"))
+	db, err := sql.Open("postgres", "host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}
@@ -307,7 +307,7 @@ func Test_CanStartAndStopTwice(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err := sql.Open("postgres", fmt.Sprintf("host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable"))
+	db, err := sql.Open("postgres", "host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}
@@ -328,7 +328,7 @@ func Test_CanStartAndStopTwice(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err = sql.Open("postgres", fmt.Sprintf("host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable"))
+	db, err = sql.Open("postgres", "host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}
@@ -365,7 +365,7 @@ func Test_ReuseData(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err := sql.Open("postgres", fmt.Sprintf("host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable"))
+	db, err := sql.Open("postgres", "host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}
@@ -392,7 +392,7 @@ func Test_ReuseData(t *testing.T) {
 		shutdownDBAndFail(t, err, database)
 	}
 
-	db, err = sql.Open("postgres", fmt.Sprintf("host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable"))
+	db, err = sql.Open("postgres", "host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")
 	if err != nil {
 		shutdownDBAndFail(t, err, database)
 	}

prepare_database.go

@@ -34,13 +34,13 @@ func defaultInitDatabase(binaryExtractLocation, pgDataDir, username, password, l
 		args = append(args, fmt.Sprintf("--locale=%s", locale))
 	}
 
-	postgresInitDbBinary := filepath.Join(binaryExtractLocation, "bin/initdb")
-	postgresInitDbProcess := exec.Command(postgresInitDbBinary, args...)
-	postgresInitDbProcess.Stderr = logger
-	postgresInitDbProcess.Stdout = logger
+	postgresInitDBBinary := filepath.Join(binaryExtractLocation, "bin/initdb")
+	postgresInitDBProcess := exec.Command(postgresInitDBBinary, args...)
+	postgresInitDBProcess.Stderr = logger
+	postgresInitDBProcess.Stdout = logger
 
-	if err := postgresInitDbProcess.Run(); err != nil {
-		return fmt.Errorf("unable to init database using: %s", postgresInitDbProcess.String())
+	if err := postgresInitDBProcess.Run(); err != nil {
+		return fmt.Errorf("unable to init database using: %s", postgresInitDBProcess.String())
 	}
 
 	if err = os.Remove(passwordFile); err != nil {
@@ -91,6 +91,7 @@ func healthCheckDatabaseOrTimeout(config Config) error {
 				continue
 			}
 			healthCheckSignal <- true
+
 			break
 		}
 	}()

remote_fetch.go

@@ -17,6 +17,7 @@ import (
 // RemoteFetchStrategy provides a strategy to fetch a Postgres binary so that it is available for use.
 type RemoteFetchStrategy func() error
 
+//nolint:funlen
 func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionStrategy, cacheLocator CacheLocator) RemoteFetchStrategy {
 	return func() error {
 		operatingSystem, architecture, version := versionStrategy()
@@ -28,45 +29,57 @@ func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionS
 			operatingSystem,
 			architecture,
 			version)
+
 		resp, err := http.Get(downloadURL)
 		if err != nil {
 			return fmt.Errorf("unable to connect to %s", remoteFetchHost)
 		}
+
 		if resp.StatusCode != http.StatusOK {
 			return fmt.Errorf("no version found matching %s", version)
 		}
+
 		defer func() {
 			if err := resp.Body.Close(); err != nil {
 				log.Fatal(err)
 			}
 		}()
+
 		bodyBytes, err := ioutil.ReadAll(resp.Body)
 		if err != nil {
 			return errorFetchingPostgres(err)
 		}
+
 		zipFile := archiver.NewZip()
+
 		if err := zipFile.Open(bytes.NewReader(bodyBytes), resp.ContentLength); err != nil {
 			return errorFetchingPostgres(err)
 		}
+
 		defer func() {
 			if err := zipFile.Close(); err != nil {
 				log.Fatal(err)
 			}
 		}()
+
 		for {
 			downloadedArchive, err := zipFile.Read()
 			if err != nil {
 				return errorExtractingBinary(downloadURL)
 			}
+
 			if header, ok := downloadedArchive.Header.(zip.FileHeader); !ok || !strings.HasSuffix(header.Name, ".txz") {
 				continue
 			}
+
 			downloadedArchiveBytes, err := ioutil.ReadAll(downloadedArchive)
 			if err == nil {
 				cacheLocation, _ := cacheLocator()
+
 				if err := createArchiveFile(cacheLocation, downloadedArchiveBytes); err != nil {
 					return fmt.Errorf("unable to extract postgres archive to %s", cacheLocation)
 				}
+
 				break
 			}
 		}

version_strategy.go

@@ -3,18 +3,17 @@ package embeddedpostgres
 import (
 	"os"
 	"os/exec"
-	"runtime"
 	"strings"
 )
 
 // VersionStrategy provides a strategy that can be used to determine which version of Postgres should be used based on
 // the operating system, architecture and desired Postgres version.
 type VersionStrategy func() (operatingSystem string, architecture string, postgresVersion PostgresVersion)
 
-func defaultVersionStrategy(config Config) VersionStrategy {
-	return func() (operatingSystem, architecture string, version PostgresVersion) {
-		goos := runtime.GOOS
-		arch := runtime.GOARCH
+func defaultVersionStrategy(config Config, goos, arch string, linuxMachineName func() string, shouldUseAlpineLinuxBuild func() bool) VersionStrategy {
+	return func() (string, string, PostgresVersion) {
+		goos := goos
+		arch := arch
 
 		if goos == "linux" {
 			// the zonkyio/embedded-postgres-binaries project produces
@@ -24,17 +23,15 @@ func defaultVersionStrategy(config Config) VersionStrategy {
 			if arch == "arm64" {
 				arch += "v8"
 			} else if arch == "arm" {
-				if out, err := exec.Command("uname", "-m").Output(); err == nil {
-					s := string(out)
-					if strings.HasPrefix(s, "armv7") {
-						arch += "32v7"
-					} else if strings.HasPrefix(s, "armv6") {
-						arch += "32v6"
-					}
+				machineName := linuxMachineName()
+				if strings.HasPrefix(machineName, "armv7") {
+					arch += "32v7"
+				} else if strings.HasPrefix(machineName, "armv6") {
+					arch += "32v6"
 				}
 			}
-			// check alpine specific build
-			if _, err := os.Stat("/etc/alpine-release"); err == nil {
+
+			if shouldUseAlpineLinuxBuild() {
 				arch += "-alpine"
 			}
 		}
@@ -47,3 +44,18 @@ func defaultVersionStrategy(config Config) VersionStrategy {
 		return goos, arch, config.version
 	}
 }
+
+func linuxMachineName() string {
+	var uname string
+
+	if output, err := exec.Command("uname", "-m").Output(); err == nil {
+		uname = string(output)
+	}
+
+	return uname
+}
+
+func shouldUseAlpineLinuxBuild() bool {
+	_, err := os.Stat("/etc/alpine-release")
+	return err == nil
+}