abra/pkg/app/app_test.go

package app_test

import (
	"encoding/json"
	"fmt"
	"os"
	"path"
	"reflect"
	"testing"

	appPkg "coopcloud.tech/abra/pkg/app"
	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/envfile"
	"coopcloud.tech/abra/pkg/recipe"
	"github.com/docker/docker/api/types/filters"
	"github.com/google/go-cmp/cmp"
	"github.com/stretchr/testify/assert"
)

var (
	TestFolder    = os.ExpandEnv("$PWD/../../tests/resources/test_folder")
	ValidAbraConf = os.ExpandEnv("$PWD/../../tests/resources/valid_abra_config")
)

// make sure these are in alphabetical order
var (
	TFolders = []string{"folder1", "folder2"}
	TFiles   = []string{"bar.env", "foo.env"}
)

var (
	AppName    = "ecloud"
	ServerName = "evil.corp"
)

var ExpectedAppEnv = envfile.AppEnv{
	"DOMAIN": "ecloud.evil.corp",
	"RECIPE": "ecloud",
}

var ExpectedApp = appPkg.App{
	Name:   AppName,
	Recipe: ExpectedAppEnv["RECIPE"],
	Domain: ExpectedAppEnv["DOMAIN"],
	Env:    ExpectedAppEnv,
	Path:   ExpectedAppFile.Path,
	Server: ExpectedAppFile.Server,
}

var ExpectedAppFile = appPkg.AppFile{
	Path:   path.Join(ValidAbraConf, "servers", ServerName, AppName+".env"),
	Server: ServerName,
}

var ExpectedAppFiles = map[string]appPkg.AppFile{
	AppName: ExpectedAppFile,
}

func TestNewApp(t *testing.T) {
	app, err := appPkg.NewApp(ExpectedAppEnv, AppName, ExpectedAppFile)
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(app, ExpectedApp) {
		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, ExpectedApp)
	}
}

func TestReadAppEnvFile(t *testing.T) {
	app, err := appPkg.ReadAppEnvFile(ExpectedAppFile, AppName)
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(app, ExpectedApp) {
		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, ExpectedApp)
	}
}

func TestGetApp(t *testing.T) {
	app, err := appPkg.GetApp(ExpectedAppFiles, AppName)
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(app, ExpectedApp) {
		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, ExpectedApp)
	}
}

func TestGetComposeFiles(t *testing.T) {
	offline := true
	r, err := recipe.Get("abra-test-recipe", offline)
	if err != nil {
		t.Fatal(err)
	}

	tests := []struct {
		appEnv       map[string]string
		composeFiles []string
	}{
		{
			map[string]string{},
			[]string{
				fmt.Sprintf("%s/%s/compose.yml", config.RECIPES_DIR, r.Name),
			},
		},
		{
			map[string]string{"COMPOSE_FILE": "compose.yml"},
			[]string{
				fmt.Sprintf("%s/%s/compose.yml", config.RECIPES_DIR, r.Name),
			},
		},
		{
			map[string]string{"COMPOSE_FILE": "compose.extra_secret.yml"},
			[]string{
				fmt.Sprintf("%s/%s/compose.extra_secret.yml", config.RECIPES_DIR, r.Name),
			},
		},
		{
			map[string]string{"COMPOSE_FILE": "compose.yml:compose.extra_secret.yml"},
			[]string{
				fmt.Sprintf("%s/%s/compose.yml", config.RECIPES_DIR, r.Name),
				fmt.Sprintf("%s/%s/compose.extra_secret.yml", config.RECIPES_DIR, r.Name),
			},
		},
	}

	for _, test := range tests {
		composeFiles, err := recipe.GetComposeFiles(r.Name, test.appEnv)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, composeFiles, test.composeFiles)
	}
}

func TestGetComposeFilesError(t *testing.T) {
	offline := true
	r, err := recipe.Get("abra-test-recipe", offline)
	if err != nil {
		t.Fatal(err)
	}

	tests := []struct{ appEnv map[string]string }{
		{map[string]string{"COMPOSE_FILE": "compose.yml::compose.foo.yml"}},
		{map[string]string{"COMPOSE_FILE": "doesnt.exist.yml"}},
	}

	for _, test := range tests {
		_, err := recipe.GetComposeFiles(r.Name, test.appEnv)
		if err == nil {
			t.Fatalf("should have failed: %v", test.appEnv)
		}
	}
}

func TestFilters(t *testing.T) {
	oldDir := config.RECIPES_DIR
	config.RECIPES_DIR = "./testdata"
	defer func() {
		config.RECIPES_DIR = oldDir
	}()

	app, err := appPkg.NewApp(envfile.AppEnv{
		"DOMAIN": "test.example.com",
		"RECIPE": "test-recipe",
	}, "test_example_com", appPkg.AppFile{
		Path:   "./testdata/filtertest.end",
		Server: "local",
	})
	if err != nil {
		t.Fatal(err)
	}

	f, err := app.Filters(false, false)
	if err != nil {
		t.Error(err)
	}
	compareFilter(t, f, map[string]map[string]bool{
		"name": {
			"test_example_com": true,
		},
	})

	f2, err := app.Filters(false, true)
	if err != nil {
		t.Error(err)
	}
	compareFilter(t, f2, map[string]map[string]bool{
		"name": {
			"^test_example_com": true,
		},
	})

	f3, err := app.Filters(true, false)
	if err != nil {
		t.Error(err)
	}
	compareFilter(t, f3, map[string]map[string]bool{
		"name": {
			"test_example_com_bar": true,
			"test_example_com_foo": true,
		},
	})

	f4, err := app.Filters(true, true)
	if err != nil {
		t.Error(err)
	}
	compareFilter(t, f4, map[string]map[string]bool{
		"name": {
			"^test_example_com_bar": true,
			"^test_example_com_foo": true,
		},
	})

	f5, err := app.Filters(false, false, "foo")
	if err != nil {
		t.Error(err)
	}
	compareFilter(t, f5, map[string]map[string]bool{
		"name": {
			"test_example_com_foo": true,
		},
	})
}

func compareFilter(t *testing.T, f1 filters.Args, f2 map[string]map[string]bool) {
	t.Helper()
	j1, err := f1.MarshalJSON()
	if err != nil {
		t.Error(err)
	}
	j2, err := json.Marshal(f2)
	if err != nil {
		t.Error(err)
	}
	if diff := cmp.Diff(string(j2), string(j1)); diff != "" {
		t.Errorf("filters mismatch (-want +got):\n%s", diff)
	}
}