e2e tests using binary: render and init.

Signed-off-by: Matthieu Nottale <[email protected]>

Author: Matthieu Nottale

cmd/render.go

@@ -44,7 +44,7 @@ Override is provided in three different ways:
 			fmt.Printf("%v\n", err)
 			os.Exit(1)
 		}
-		fmt.Println(string(res))
+		fmt.Printf("%s", string(res))
 	},
 }
 

e2e/binary_test.go

@@ -0,0 +1,129 @@
+package e2e
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/gotestyourself/gotestyourself/fs"
+
+	"github.com/docker/lunchbox/utils"
+)
+
+var (
+	dockerApp = ""
+)
+
+func getBinary(t *testing.T) string {
+	if dockerApp != "" {
+		return dockerApp
+	}
+	dockerApp = os.Getenv("DOCKERAPP_BINARY")
+	if dockerApp == "" {
+		binName := "docker-app"
+		if runtime.GOOS == "windows" {
+			binName += ".exe"
+		}
+		locations := []string{".", "../_build"}
+		for _, l := range locations {
+			b := path.Join(l, binName)
+			if _, err := os.Stat(b); err == nil {
+				dockerApp = b
+				break
+			}
+		}
+	}
+	if dockerApp == "" {
+		t.Error("cannot locate docker-app binary")
+	}
+	cmd := exec.Command(dockerApp, "version")
+	_, err := cmd.CombinedOutput()
+	assert.NilError(t, err, "failed to execute docker-app binary")
+	return dockerApp
+}
+
+func TestRenderBinary(t *testing.T) {
+	getBinary(t)
+	apps, err := ioutil.ReadDir("render")
+	assert.NilError(t, err, "unable to get apps")
+	for _, app := range apps {
+		t.Log("testing", app.Name())
+		settings, overrides, env := gather(t, path.Join("render", app.Name()))
+		args := []string{
+			"render",
+			path.Join("render", app.Name()),
+		}
+		for _, s := range settings {
+			args = append(args, "-s", s)
+		}
+		for _, c := range overrides {
+			args = append(args, "-c", c)
+		}
+		for k, v := range env {
+			args = append(args, "-e", fmt.Sprintf("%s=%s", k, v))
+		}
+		t.Logf("executing with %v", args)
+		cmd := exec.Command(dockerApp, args...)
+		output, err := cmd.CombinedOutput()
+		checkResult(t, string(output), err, path.Join("render", app.Name()))
+	}
+}
+
+func randomName(prefix string) string {
+	b := make([]byte, 16)
+	_, err := rand.Read(b)
+	if err != nil {
+		panic(err)
+	}
+	return prefix + hex.EncodeToString(b)
+}
+
+func TestInitBinary(t *testing.T) {
+	getBinary(t)
+	composeData := `services:
+  nginx:
+    image: nginx:${NGINX_VERSION}
+    command: nginx $NGINX_ARGS
+`
+	envData := "# some comment\nNGINX_VERSION=latest"
+	inputDir := randomName("app_input_")
+	os.Mkdir(inputDir, 0755)
+	ioutil.WriteFile(path.Join(inputDir, "docker-compose.yml"), []byte(composeData), 0644)
+	ioutil.WriteFile(path.Join(inputDir, ".env"), []byte(envData), 0644)
+	defer os.RemoveAll(inputDir)
+
+	testAppName := randomName("app_")
+	dirName := utils.DirNameFromAppName(testAppName)
+	defer os.RemoveAll(dirName)
+
+	args := []string{
+		"init",
+		testAppName,
+		"-c",
+		path.Join(inputDir, "docker-compose.yml"),
+	}
+	cmd := exec.Command(dockerApp, args...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		fmt.Println(string(output))
+	}
+	assert.NilError(t, err)
+	meta, err := ioutil.ReadFile(path.Join(dirName, "metadata.yml"))
+	assert.NilError(t, err)
+	manifest := fs.Expected(
+		t,
+		fs.WithMode(0755),
+		fs.WithFile("metadata.yml", string(meta), fs.WithMode(0644)), // too many variables, cheating
+		fs.WithFile("docker-compose.yml", composeData, fs.WithMode(0644)),
+		fs.WithFile("settings.yml", "NGINX_ARGS: FILL ME\nNGINX_VERSION: latest\n", fs.WithMode(0644)),
+	)
+
+	assert.Assert(t, fs.Equal(dirName, manifest))
+}

e2e/render_test.go

@@ -13,35 +13,54 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
+func gather(t *testing.T, dir string) ([]string, []string, map[string]string) {
+	var (
+		overrides []string
+		settings  []string
+	)
+	content, err := ioutil.ReadDir(dir)
+	assert.NilError(t, err, "unable to get app: %q", dir)
+	// look for overrides and settings file to inject in the rendering process
+	for _, f := range content {
+		split := strings.SplitN(f.Name(), "-", 2)
+		if split[0] == "settings" {
+			settings = append(settings, path.Join(dir, f.Name()))
+		}
+		if split[0] == "override" {
+			overrides = append(overrides, path.Join(dir, f.Name()))
+		}
+	}
+	// look for emulated command line env
+	env := make(map[string]string)
+	if _, err = os.Stat(path.Join(dir, "env.yml")); err == nil {
+		envRaw, err := ioutil.ReadFile(path.Join(dir, "env.yml"))
+		assert.NilError(t, err, "unable to read file")
+		err = yaml.Unmarshal(envRaw, &env)
+		assert.NilError(t, err, "unable to unmarshal env")
+	}
+	return settings, overrides, env
+}
+
+func checkResult(t *testing.T, result string, resultErr error, dir string) {
+	if resultErr != nil {
+		ee := path.Join(dir, "expectedError.txt")
+		if _, err := os.Stat(ee); err != nil {
+			assert.NilError(t, resultErr, "unexpected render error")
+		}
+		expectedErr := readFile(t, ee)
+		assert.ErrorContains(t, resultErr, expectedErr)
+	} else {
+		expectedRender := readFile(t, path.Join(dir, "expected.txt"))
+		assert.Equal(t, string(expectedRender), result, "rendering missmatch")
+	}
+}
+
 func TestRender(t *testing.T) {
 	apps, err := ioutil.ReadDir("render")
 	assert.NilError(t, err, "unable to get apps")
 	for _, app := range apps {
 		t.Log("testing", app.Name())
-		var (
-			overrides []string
-			settings  []string
-		)
-		content, err := ioutil.ReadDir(path.Join("render", app.Name()))
-		assert.NilError(t, err, "unable to get app: %q", app.Name())
-		// look for overrides and settings file to inject in the rendering process
-		for _, f := range content {
-			split := strings.SplitN(f.Name(), "-", 2)
-			if split[0] == "settings" {
-				settings = append(settings, path.Join("render", app.Name(), f.Name()))
-			}
-			if split[0] == "override" {
-				overrides = append(overrides, path.Join("render", app.Name(), f.Name()))
-			}
-		}
-		// look for emulated command line env
-		env := make(map[string]string)
-		if _, err = os.Stat(path.Join("render", app.Name(), "env.yml")); err == nil {
-			envRaw, err := ioutil.ReadFile(path.Join("render", app.Name(), "env.yml"))
-			assert.NilError(t, err, "unable to read file")
-			err = yaml.Unmarshal(envRaw, &env)
-			assert.NilError(t, err, "unable to unmarshal env")
-		}
+		settings, overrides, env := gather(t, path.Join("render", app.Name()))
 		// run the render
 		config, resultErr := renderer.Render(path.Join("render", app.Name()), overrides, settings, env)
 		var result string
@@ -50,13 +69,7 @@ func TestRender(t *testing.T) {
 			bytes, resultErr = yaml.Marshal(config)
 			result = string(bytes)
 		}
-		if resultErr != nil {
-			expectedErr := readFile(t, path.Join("render", app.Name(), "expectedError.txt"))
-			assert.ErrorContains(t, resultErr, expectedErr)
-		} else {
-			expectedRender := readFile(t, path.Join("render", app.Name(), "expected.txt"))
-			assert.Equal(t, string(expectedRender), result, "rendering missmatch")
-		}
+		checkResult(t, result, resultErr, path.Join("render", app.Name()))
 	}
 }