v.io/jiri@v0.0.0-20160715023856-abfb8b131290/profiles/manifest_test.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package profiles_test

import (
	"bufio"
	"bytes"
	"io/ioutil"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"strings"
	"testing"

	"v.io/jiri/jiritest"
	"v.io/jiri/profiles"
)

func addProfileAndTargets(t *testing.T, pdb *profiles.DB, name string) {
	t1, _ := profiles.NewTarget("cpu1-os1@1", "A=B,C=D")
	t2, _ := profiles.NewTarget("cpu2-os2@bar", "A=B,C=D")
	pdb.InstallProfile("test", name, "")
	if err := pdb.AddProfileTarget("test", name, t1); err != nil {
		t.Fatal(err)
	}
	t2.InstallationDir = "bar"
	if err := pdb.AddProfileTarget("test", name, t2); err != nil {
		t.Fatal(err)
	}
}

func tmpFile() string {
	dirname, err := ioutil.TempDir("", "pdb")
	if err != nil {
		panic(err)
	}
	return filepath.Join(dirname, "manifest")
}

func removeDate(s string) string {
	var result bytes.Buffer
	scanner := bufio.NewScanner(bytes.NewBufferString(s))
	re := regexp.MustCompile("(.*) date=\".*\"")
	for scanner.Scan() {
		result.WriteString(re.ReplaceAllString(scanner.Text(), "$1"))
		result.WriteString("\n")
	}
	return strings.TrimSpace(result.String())
}

func TestWrite(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()
	filename := tmpFile()
	defer os.RemoveAll(filepath.Dir(filename))

	// test for no version being set.
	t1, _ := profiles.NewTarget("cpu1-os1", "A=B,C=D")
	pdb.InstallProfile("test", "b", "")
	if err := pdb.AddProfileTarget("test", "b", t1); err != nil {
		t.Fatal(err)
	}
	if err := pdb.Write(jirix, "test", filename); err == nil || !strings.HasPrefix(err.Error(), "missing version for profile") {
		t.Fatalf("was expecing a missing version error, but got %v", err)
	}
	pdb.RemoveProfileTarget("test", "b", t1)

	addProfileAndTargets(t, pdb, "b")
	addProfileAndTargets(t, pdb, "a")
	if err := pdb.Write(jirix, "test", filename); err != nil {
		t.Fatal(err)
	}

	g, _ := ioutil.ReadFile(filename)
	w, _ := ioutil.ReadFile("./testdata/m1.xml")
	if got, want := removeDate(strings.TrimSpace(string(g))), strings.TrimSpace(string(w)); got != want {
		t.Fatalf("got %v, want %v", got, want)
	}
}

func exists(t *testing.T, filename string) bool {
	fi, err := os.Stat(filename)
	if err != nil {
		if !os.IsNotExist(err) {
			t.Fatal(err)
		}
		return false
	}
	return fi.Size() > 0
}

func TestWriteAndRename(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()
	filename := tmpFile()
	defer os.RemoveAll(filepath.Dir(filename))

	addProfileAndTargets(t, pdb, "b")

	if exists(t, filename) {
		t.Fatalf("%q  exists", filename)
	}
	if exists(t, filename+".prev") {
		t.Fatalf("%q  exists", filename+".prev")
	}
	if err := pdb.Write(jirix, "test", filename); err != nil {
		t.Fatal(err)
	}

	if !exists(t, filename) {
		t.Fatalf("%q  exists", filename)
	}
	if exists(t, filename+".prev") {
		t.Fatalf("%q  exists", filename+".prev")
	}

	if err := pdb.Write(jirix, "test", filename); err != nil {
		t.Fatal(err)
	}

	if !exists(t, filename) {
		t.Fatalf("%q does not exist", filename)
	}
	if !exists(t, filename+".prev") {
		t.Fatalf("%q does not exist", filename+".prev")
	}
}

func TestWriteDir(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()
	dir, err := ioutil.TempDir("", "pdb-")
	if err != nil {
		t.Fatal(err)
	}

	t1, _ := profiles.NewTarget("cpu1-os1@1", "A=B,C=D")
	pdb.InstallProfile("i1", "b", "")
	if err := pdb.AddProfileTarget("i1", "b", t1); err != nil {
		t.Fatal(err)
	}

	t2, _ := profiles.NewTarget("cpu1-os1@2", "A=B,C=D")
	pdb.InstallProfile("i2", "b", "")
	if err := pdb.AddProfileTarget("i2", "b", t2); err != nil {
		t.Fatal(err)
	}

	// Write out i1 installer's data
	if err := pdb.Write(jirix, "i1", dir); err != nil {
		t.Fatal(err)
	}
	if f := filepath.Join(dir, "i1"); !exists(t, f) {
		t.Errorf("%s doesn't exist", f)
	}
	if f := filepath.Join(dir, "i2"); exists(t, f) {
		t.Errorf("%s exists", f)
	}

	// Write out i2 installer's data
	if err := pdb.Write(jirix, "i2", dir); err != nil {
		t.Fatal(err)
	}
	if f := filepath.Join(dir, "i1"); !exists(t, f) {
		t.Errorf("%s doesn't exist", f)
	}
	if f := filepath.Join(dir, "i2"); !exists(t, f) {
		t.Errorf("%s doesn't exist", f)
	}
}

func TestRead(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()
	if err := pdb.Read(jirix, "./testdata/m1.xml"); err != nil {
		t.Fatal(err)
	}
	names := pdb.Names()
	if got, want := names, []string{"test:a", "test:b"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("got %v, want %v", got, want)
	}
	p := pdb.LookupProfile("test", "a")
	if got, want := p.Targets()[0].OS(), "os1"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
	if got, want := p.Targets()[1].Version(), "bar"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
}

func TestReadDir(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()
	if err := pdb.Read(jirix, "./testdata/old_version"); err == nil || !strings.Contains(err.Error(), "files must be at version") {
		t.Fatalf("missing or wrong error: %v", err)
	}
	if err := pdb.Read(jirix, "./testdata/mismatched_versions"); err == nil || !strings.Contains(err.Error(), "files must have the same version") {
		t.Fatalf("missing or wrong error: %v", err)
	}
	if err := pdb.Read(jirix, "./testdata/db_dir"); err != nil {
		t.Fatal(err)
	}
	names := pdb.Names()
	if got, want := names, []string{"m1:a", "m1:b", "m2:a", "m2:b"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("got %v, want %v", got, want)
	}
	profile := pdb.LookupProfile("m2", "a")
	if got, want := profile.Root(), "root"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
	profile = pdb.LookupProfile("m1", "b")
	if got, want := profile.Root(), "r1"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
}

func TestReadDirWithPrevFiles(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()
	if err := pdb.Read(jirix, "./testdata/db_dir_with_prev"); err != nil {
		t.Fatal(err)
	}
	names := pdb.Names()
	if got, want := names, []string{"m1:a", "m2:b"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("got %v, want %v", got, want)
	}
	profile := pdb.LookupProfile("m1", "a")
	if got, want := profile.Root(), "root"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
	profile = pdb.LookupProfile("m2", "b")
	if got, want := profile.Root(), "r2"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
}

func TestInstallProfile(t *testing.T) {
	pdb := profiles.NewDB()
	pdb.InstallProfile("test", "a", "root1")
	pdb.InstallProfile("test", "a", "root2")
	profile := pdb.LookupProfile("test", "a")
	if got, want := profile.Root(), "root1"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
}

func TestReadingV0(t *testing.T) {
	pdb := profiles.NewDB()
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()

	if err := pdb.Read(jirix, "./testdata/legacy.xml"); err != nil {
		t.Fatal(err)
	}

	if got, want := pdb.SchemaVersion(), profiles.Original; got != want {
		t.Errorf("got %v, want %v", got, want)
	}

	oprofiles := pdb.Profiles()
	if got, want := len(oprofiles), 5; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
	filename := tmpFile()
	defer os.RemoveAll(filepath.Dir(filename))

	var t1 profiles.Target
	t1.Set("cpu-os@1")
	pdb.InstallProfile("", "__first", "")
	if err := pdb.AddProfileTarget("", "__first", t1); err != nil {
		t.Fatal(err)
	}

	if err := pdb.Write(jirix, "", filename); err != nil {
		t.Fatal(err)
	}

	if err := pdb.Read(jirix, filename); err != nil {
		t.Fatal(err)
	}

	if got, want := pdb.SchemaVersion(), profiles.V5; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
	nprofiles := pdb.Profiles()
	if got, want := len(nprofiles), 6; got != want {
		t.Fatalf("got %v, want %v", got, want)
	}

	if got, want := nprofiles[0].Name(), "__first"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}

	for i, v := range nprofiles[1:] {
		if got, want := v.Name(), oprofiles[i].Name(); got != want {
			t.Errorf("got %v, want %v", got, want)
		}
	}
}

func TestReadingV3AndV4(t *testing.T) {
	fake, cleanup := jiritest.NewFakeJiriRoot(t)
	defer cleanup()
	for i, c := range []struct {
		filename, prefix, variable string
		version                    profiles.Version
	}{
		{"v3.xml", "", "", profiles.V3},
		{"v4.xml", fake.X.Root, "${JIRI_ROOT}", profiles.V4},
	} {
		pdb := profiles.NewDB()
		err := pdb.Read(fake.X, filepath.Join("testdata", c.filename))
		if err != nil {
			t.Fatal(err)
		}
		if got, want := pdb.SchemaVersion(), c.version; got != want {
			t.Errorf("%d: got %v, want %v", i, got, want)
		}
		target, err := profiles.NewTarget("cpu1-os1@1", "")
		if err != nil {
			t.Fatal(err)
		}
		p := pdb.LookupProfile("", "a")
		// We need to expand the variable here for a V4 profile if we want
		// to get the full absolute path.
		if got, want := p.Root(), c.variable+"/an/absolute/root"; got != want {
			t.Errorf("%d: got %v, want %v", i, got, want)
		}
		lt := pdb.LookupProfileTarget("", "a", target)
		if got, want := lt.InstallationDir, c.variable+"/an/absolute/dir"; got != want {
			t.Errorf("%d: got %v, want %v", i, got, want)
		}
	}
}

func TestQualifiedNames(t *testing.T) {
	for i, c := range []struct{ i, p, e string }{
		{"a", "b", "a:b"},
		{"a", ":b", "a:b"},
		{"a", "", "a:"},
		{"", "b", "b"},
		{"", "", ""},
	} {
		if got, want := profiles.QualifiedProfileName(c.i, c.p), c.e; got != want {
			t.Errorf("%d: got %v, want %v", i, got, want)
		}
	}
	for i, c := range []struct{ q, i, p string }{
		{"aa:bb", "aa", "bb"},
		{":bb", "", "bb"},
		{"bb", "", "bb"},
		{"", "", ""},
		{":bb", "", "bb"},
	} {
		gi, gp := profiles.SplitProfileName(c.q)
		if got, want := gi, c.i; got != want {
			t.Errorf("%d: got %v, want %v", i, got, want)
		}
		if got, want := gp, c.p; got != want {
			t.Errorf("%d: got %v, want %v", i, got, want)
		}
	}

	if got, want := profiles.QualifiedProfileName("new", "old:bar"), "new:bar"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}

}