fix(*): creating and using interfaces for system tasks

Everywhere they’re used can (and will in a subsequent commit) now be
unit tested

Author: Aaron Schlesinger

boot.go

@@ -14,6 +14,7 @@ import (
 	"github.com/deis/builder/pkg/gitreceive/storage"
 	"github.com/deis/builder/pkg/healthsrv"
 	"github.com/deis/builder/pkg/sshd"
+	"github.com/deis/builder/pkg/sys"
 	pkglog "github.com/deis/pkg/log"
 	kcl "k8s.io/kubernetes/pkg/client/unversioned"
 )
@@ -48,10 +49,12 @@ func main() {
 					pkglog.Err("getting config for %s [%s]", serverConfAppName, err)
 					os.Exit(1)
 				}
+				env := sys.RealEnv()
+				fs := sys.RealFS()
 				pushLock := sshd.NewInMemoryRepositoryLock()
 				circ := sshd.NewCircuit()
 
-				s3Client, err := storage.GetClient(cnf.HealthSrvTestStorageRegion)
+				s3Client, err := storage.GetClient(cnf.HealthSrvTestStorageRegion, fs, env)
 				if err != nil {
 					log.Printf("Error getting s3 client (%s)", err)
 					os.Exit(1)
@@ -106,8 +109,10 @@ func main() {
 					os.Exit(1)
 				}
 				cnf.CheckDurations()
+				fs := sys.RealFS()
+				env := sys.RealEnv()
 
-				if err := gitreceive.Run(cnf); err != nil {
+				if err := gitreceive.Run(cnf, fs, env); err != nil {
 					log.Printf("Error running git receive hook [%s]", err)
 					os.Exit(1)
 				}

pkg/gitreceive/build.go

@@ -15,6 +15,7 @@ import (
 	"github.com/deis/builder/pkg"
 	"github.com/deis/builder/pkg/gitreceive/git"
 	"github.com/deis/builder/pkg/gitreceive/storage"
+	"github.com/deis/builder/pkg/sys"
 	"github.com/deis/pkg/log"
 	"gopkg.in/yaml.v2"
 
@@ -41,7 +42,7 @@ func run(cmd *exec.Cmd) error {
 	return cmd.Run()
 }
 
-func build(conf *Config, s3Client *s3.S3, kubeClient *client.Client, builderKey, rawGitSha string) error {
+func build(conf *Config, s3Client *s3.S3, kubeClient *client.Client, env sys.Env, fs sys.FS, builderKey, rawGitSha string) error {
 	repo := conf.Repository
 	gitSha, err := git.NewSha(rawGitSha)
 	if err != nil {
@@ -125,7 +126,7 @@ func build(conf *Config, s3Client *s3.S3, kubeClient *client.Client, builderKey,
 		return fmt.Errorf("uploading %s to %s/%s (%v)", absAppTgz, conf.Bucket, slugBuilderInfo.TarKey(), err)
 	}
 
-	creds := storage.CredsOK()
+	creds := storage.CredsOK(fs)
 
 	var pod *api.Pod
 	var buildPodName string

pkg/gitreceive/run.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/deis/builder/pkg/gitreceive/storage"
+	"github.com/deis/builder/pkg/sys"
 	"github.com/deis/pkg/log"
 
 	builderconf "github.com/deis/builder/pkg/conf"
@@ -22,15 +23,15 @@ func readLine(line string) (string, string, string, error) {
 	return spl[0], spl[1], spl[2], nil
 }
 
-func Run(conf *Config) error {
+func Run(conf *Config, fs sys.FS, env sys.Env) error {
 	log.Debug("Running git hook")
 
 	builderKey, err := builderconf.GetBuilderKey()
 	if err != nil {
 		return err
 	}
 
-	s3Client, err := storage.GetClient(conf.StorageRegion)
+	s3Client, err := storage.GetClient(conf.StorageRegion, fs, env)
 	if err != nil {
 		return fmt.Errorf("configuring S3 client (%s)", err)
 	}
@@ -56,7 +57,7 @@ func Run(conf *Config) error {
 		}
 		// if we're processing a receive-pack on an existing repo, run a build
 		if strings.HasPrefix(conf.SSHOriginalCommand, "git-receive-pack") {
-			if err := build(conf, s3Client, kubeClient, builderKey, newRev); err != nil {
+			if err := build(conf, s3Client, kubeClient, env, fs, builderKey, newRev); err != nil {
 				return err
 			}
 		}

pkg/gitreceive/storage/auth.go

@@ -2,11 +2,11 @@ package storage
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"strings"
 
 	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/deis/builder/pkg/sys"
 )
 
 const (
@@ -24,9 +24,9 @@ var (
 // if a key exists but not a secret, or vice-versa, returns an error.
 // if both don't exist returns emptyAuth.
 // otherwise returns a valid auth
-func getAuth() (*credentials.Credentials, error) {
-	accessKeyIDBytes, accessKeyErr := ioutil.ReadFile(accessKeyIDFile)
-	accessSecretKeyBytes, accessSecretKeyErr := ioutil.ReadFile(accessSecretKeyFile)
+func getAuth(fs sys.FS) (*credentials.Credentials, error) {
+	accessKeyIDBytes, accessKeyErr := fs.ReadFile(accessKeyIDFile)
+	accessSecretKeyBytes, accessSecretKeyErr := fs.ReadFile(accessSecretKeyFile)
 	if accessKeyErr == os.ErrNotExist && accessSecretKeyErr == os.ErrNotExist {
 		return emptyAuth, nil
 	}
@@ -43,8 +43,8 @@ func getAuth() (*credentials.Credentials, error) {
 }
 
 // CredsOK checks if the required credentials to make a request exist
-func CredsOK() bool {
-	cred, err := getAuth()
+func CredsOK(fs sys.FS) bool {
+	cred, err := getAuth(fs)
 	if err != nil {
 		return false
 	}

pkg/gitreceive/storage/client.go

@@ -4,16 +4,17 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/deis/builder/pkg/sys"
 )
 
 // GetClient returns a S3 API compatible storage client
-func GetClient(regionStr string) (*s3.S3, error) {
-	auth, err := getAuth()
+func GetClient(regionStr string, fs sys.FS, env sys.Env) (*s3.S3, error) {
+	auth, err := getAuth(fs)
 	if err != nil {
 		return nil, err
 	}
 
-	endpoint, err := getEndpoint()
+	endpoint, err := getEndpoint(env)
 	if err != nil {
 		return nil, err
 	}

pkg/gitreceive/storage/endpoint.go

@@ -2,7 +2,8 @@ package storage
 
 import (
 	"fmt"
-	"os"
+
+	"github.com/deis/builder/pkg/sys"
 )
 
 const (
@@ -20,10 +21,10 @@ var (
 	)
 )
 
-func getEndpoint() (string, error) {
-	mHost := os.Getenv(minioHostEnvVar)
-	mPort := os.Getenv(minioPortEnvVar)
-	S3EP := os.Getenv(outsideStorageEndpoint)
+func getEndpoint(env sys.Env) (string, error) {
+	mHost := env.Get(minioHostEnvVar)
+	mPort := env.Get(minioPortEnvVar)
+	S3EP := env.Get(outsideStorageEndpoint)
 	if S3EP != "" {
 		return S3EP, nil
 	} else if mHost != "" && mPort != "" {

pkg/sys/env.go

@@ -0,0 +1,33 @@
+package sys
+
+import (
+	"os"
+)
+
+// Env is an interface to a set of environment variables
+type Env interface {
+	// Get gets the environment variable of the given name
+	Get(name string) string
+}
+
+type realEnv struct{}
+
+func (r realEnv) Get(name string) string {
+	return os.Getenv(name)
+}
+
+func RealEnv() Env {
+	return realEnv{}
+}
+
+type FakeEnv struct {
+	Envs map[string]string
+}
+
+func NewFakeEnv() *FakeEnv {
+	return &FakeEnv{Envs: make(map[string]string)}
+}
+
+func (f *FakeEnv) Get(name string) string {
+	return f.Envs[name]
+}

pkg/sys/fs.go

@@ -0,0 +1,49 @@
+package sys
+
+import (
+	"fmt"
+	"io/ioutil"
+)
+
+// FS is the interface to a file system
+type FS interface {
+	// ReadAll gets the contents of filename, or an error if the file didn't exist or there was an error reading it
+	ReadFile(filename string) ([]byte, error)
+}
+
+// RealFS returns an FS object that interacts with the real local filesystem
+func RealFS() FS {
+	return &realFS{}
+}
+
+type realFS struct{}
+
+func (r *realFS) ReadFile(name string) ([]byte, error) {
+	return ioutil.ReadFile(name)
+}
+
+// FakeFileNotFound is the error returned by FakeFS when a requested file isn't found
+type FakeFileNotFound struct {
+	Filename string
+}
+
+// Error is the error interface implementation
+func (f FakeFileNotFound) Error() string {
+	return fmt.Sprintf("Fake file %s not found", f.Filename)
+}
+
+type FakeFS struct {
+	Files map[string][]byte
+}
+
+func NewFakeFS() *FakeFS {
+	return &FakeFS{Files: make(map[string][]byte)}
+}
+
+func (f *FakeFS) ReadFile(name string) ([]byte, error) {
+	b, ok := f.Files[name]
+	if !ok {
+		return nil, FakeFileNotFound{Filename: name}
+	}
+	return b, nil
+}