cipd/cipd_test.go - jiri - Git at Google

 // Copyright 2018 The Fuchsia 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 cipd

 import (
 	"bytes"
 	"encoding/hex"
 	"io/ioutil"
 	"os"
 	"path"
 	"reflect"
 	"sort"
 	"strings"
 	"testing"

 	"go.fuchsia.dev/jiri/jiritest/xtest"
 )

 const (
 	// Some random valid cipd version tags from infra/tools/cipd
 	cipdVersionForTestA = "git_revision:00e2d8b49a4e7505d1c71f19d15c9e7c5b9245a5"
 	cipdVersionForTestB = "git_revision:8fac632847b1ce0de3b57d16d0f2193625f4a4f0"
 	// package path and versions for ACL tests
 	cipdPkgPathA    = "gn/gn/${platform}"
 	cipdPkgVersionA = "git_revision:bdb0fd02324b120cacde634a9235405061c8ea06"
 	cipdPkgPathB    = "notexist/notexist"
 	cipdPkgVersionB = "git_revision:bdb0fd02324b120cacde634a9235405061c8ea06"
 )

 var (
 	// Digests generated by cipd selfupdate-roll ...
 	digestMapA = map[string]string{
 		"linux-amd64":  "df37ffc2588e345a31ca790d773b6136fedbd2efbf9a34cb735dd34b6891c16c",
 		"linux-arm64":  "650f2a045f8587062a16299a650aa24ba5c5c0652585a2d9bd56594369d5f99e",
 		"linux-armv6l": "61b657c860ddc39d3286ced073c843852b1dafc0222af0bdc22ad988b289d733",
 		"mac-amd64":    "4d015791ed6f03f305cf6a5a673a447e5c47ff5fdb701f43f99fba9ca73e61f8",
 	}
 	digestMapB = map[string]string{
 		"linux-amd64":  "bdc971fd2895c3771e0709d2a3ec5fcace69c59a3a9f9dc33ab76fbc2f777d40",
 		"linux-arm64":  "e1d6aadc9bfc155e9088aa3de39b9d3311c7359f398f372b5ad1c308e25edfeb",
 		"linux-armv6l": "3ad97b47ecc1b358c8ebd1b0307087d354433d88f24bf8ece096fb05452837f9",
 		"mac-amd64":    "167edadf7c7c019a40b9f7869a4c05b2d9834427dad68e295442ef9ebce88dba",
 	}
 	instanceIDMap = map[string]string{
 		"gn/gn/linux-amd64": "0uGjKAZkJXPZjtYktgEwHiNbwsut_qRsk7ZCGGxi82IC",
 		"gn/gn/mac-amd64":   "rN2F641yR4Bj-H1q8OwC_RiqRpUYxy3hryzRfPER9wcC",
 	}
 )

 // TestFetchBinary tests fetchiBinary method by fetching a set of
 // cipd binaries. This test requires network access
 func TestFetchBinary(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	tmpDir, err := ioutil.TempDir("", "jiri-test")
 	if err != nil {
 		t.Error("failed to create temp dir for testing")
 	}
 	defer os.RemoveAll(tmpDir)

 	tests := []struct {
 		version string
 		digest  map[string]string
 	}{
 		{cipdVersionForTestA, digestMapA},
 		{cipdVersionForTestB, digestMapB},
 	}

 	for i, test := range tests {
 		for platform, digest := range test.digest {
 			cipdPath := path.Join(tmpDir, "cipd"+platform+test.version)
 			if err := fetchBinary(fakex, cipdPath, platform, test.version, digest); err != nil {
 				t.Errorf("test %d failed while retrieving cipd binary for platform %q on version %q with digest %q: %v", i, platform, test.version, digest, err)
 			}
 		}
 	}
 }

 func TestCipdVersion(t *testing.T) {
 	t.Parallel()
 	// Assume cipd version is always a git commit hash for now
 	versionStr := string(cipdVersion)
 	if len(versionStr) != len("git_revision:00e2d8b49a4e7505d1c71f19d15c9e7c5b9245a5") ||
 		!strings.HasPrefix(versionStr, "git_revision:") {
 		t.Errorf("unsupported cipd version tag: %q", versionStr)
 	}
 	versionHash := versionStr[len("git_revision:"):]
 	if _, err := hex.DecodeString(versionHash); err != nil {
 		t.Errorf("unsupported cipd version tag: %q", versionStr)
 	}
 }

 func TestFetchDigest(t *testing.T) {
 	t.Parallel()
 	tests := []string{
 		"linux-amd64",
 		"linux-arm64",
 		"linux-armv6l",
 		"mac-amd64",
 	}

 	for _, platform := range tests {
 		digest, _, err := fetchDigest(platform)
 		if err != nil {
 			t.Errorf("failed to retrieve cipd digest for platform %q due to error: %v", platform, err)
 		}
 		if _, err := hex.DecodeString(digest); err != nil {
 			t.Errorf("digest %q is not a valid hex string for platform %q", digest, platform)
 		}
 	}
 }

 func TestSelfUpdate(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	tmpDir, err := ioutil.TempDir("", "jiri-test")
 	if err != nil {
 		t.Error("failed to create temp dir for testing")
 	}
 	defer os.RemoveAll(tmpDir)
 	// Bootstrap cipd to version A
 	cipdPath := path.Join(tmpDir, "cipd")
 	if err := fetchBinary(fakex, cipdPath, CipdPlatform.String(), cipdVersionForTestA, digestMapA[CipdPlatform.String()]); err != nil {
 		t.Errorf("failed to bootstrap cipd with version %q: %v", cipdVersionForTestA, err)
 	}
 	// Perform cipd self update to version B
 	if err := selfUpdate(cipdPath, cipdVersionForTestB); err != nil {
 		t.Errorf("failed to perform cipd self update: %v", err)
 	}
 	// Verify self updated cipd
 	cipdData, err := ioutil.ReadFile(cipdPath)
 	if err != nil {
 		t.Errorf("failed to read self-updated cipd binary: %v", err)
 	}
 	verified, err := verifyDigest(cipdData, digestMapB[CipdPlatform.String()])
 	if err != nil {
 		t.Errorf("digest failed verification for platform %q on version %q", CipdPlatform.String(), cipdVersionForTestB)
 	}
 	if !verified {
 		t.Errorf("self-updated cipd failed integrity test")
 	}
 }

 func TestBootsrap(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if cipdPath == "" {
 		t.Errorf("bootstrap returned an empty path")
 	}
 	fileInfo, err := os.Stat(cipdPath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			t.Errorf("bootstrap failed, cipd binary was not found at %q", cipdPath)
 		}
 		t.Errorf("bootstrap failed, could not access cipd binary at %q due to error %v", cipdPath, err)
 	}
 	if fileInfo.Mode()&0111 == 0 {
 		t.Errorf("bootstrap failed, cipd binary at %q is not executable", cipdBinary)
 	}
 }

 func TestEnsure(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if err != nil {
 		t.Errorf("bootstrap failed due to error: %v", err)
 	}
 	defer os.Remove(cipdPath)
 	// Write test ensure file
 	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
 	if err != nil {
 		t.Errorf("failed to create test ensure file: %v", err)
 	}
 	defer testEnsureFile.Close()
 	defer os.Remove(testEnsureFile.Name())
 	_, err = testEnsureFile.Write([]byte(`
 $ParanoidMode CheckPresence

 # GN
 gn/gn/${platform} git_revision:bdb0fd02324b120cacde634a9235405061c8ea06
 `))
 	if err != nil {
 		t.Errorf("failed to write test ensure file: %v", err)
 	}
 	testEnsureFile.Sync()
 	tmpDir, err := ioutil.TempDir("", "jiri-test")
 	if err != nil {
 		t.Error("failed to creat temp dir for testing")
 	}
 	defer os.RemoveAll(tmpDir)
 	// Invoke Ensure on test ensure file
 	if err := Ensure(fakex, testEnsureFile.Name(), tmpDir, 30); err != nil {
 		t.Errorf("ensure failed due to error: %v", err)
 	}
 	// Check the existence downloaded package
 	gnPath := path.Join(tmpDir, "gn")
 	if _, err := os.Stat(gnPath); err != nil {
 		if os.IsNotExist(err) {
 			t.Errorf("fetched cipd package is not found at %q", gnPath)
 		}
 		t.Errorf("failed to execute os.Stat() on fetched cipd package due to error: %v", err)
 	}
 }

 func TestEnsureFileVerify(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if err != nil {
 		t.Errorf("bootstrap failed due to error: %v", err)
 	}
 	defer os.Remove(cipdPath)
 	// Write test ensure file
 	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
 	if err != nil {
 		t.Errorf("failed to create test ensure file: %v", err)
 	}
 	defer testEnsureFile.Close()
 	defer os.Remove(testEnsureFile.Name())
 	_, err = testEnsureFile.Write([]byte(`
 $ParanoidMode CheckPresence
 $VerifiedPlatform linux-amd64
 $VerifiedPlatform mac-amd64

 # GN
 gn/gn/${platform} git_revision:bdb0fd02324b120cacde634a9235405061c8ea06
 `))
 	if err != nil {
 		t.Errorf("failed to write test ensure file: %v", err)
 	}
 	testEnsureFile.Sync()
 	if err := EnsureFileVerify(fakex, testEnsureFile.Name()); err != nil {
 		t.Error("ensure file failed verification")
 	}
 }

 func TestEnsureFileVerifyInvalid(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if err != nil {
 		t.Errorf("bootstrap failed due to error: %v", err)
 	}
 	defer os.Remove(cipdPath)
 	// Write test ensure file
 	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
 	if err != nil {
 		t.Errorf("failed to create test ensure file: %v", err)
 	}
 	defer testEnsureFile.Close()
 	defer os.Remove(testEnsureFile.Name())
 	_, err = testEnsureFile.Write([]byte(`
 $ParanoidMode CheckPresence
 $VerifiedPlatform linux-amd64
 $VerifiedPlatform mac-amd64

 # GN
 gn/gn/${platform} git_revision:not_a_real_version
 `))
 	if err != nil {
 		t.Errorf("failed to write test ensure file: %v", err)
 	}
 	testEnsureFile.Sync()
 	if err := EnsureFileVerify(fakex, testEnsureFile.Name()); err == nil {
 		t.Error("ensure file passed verification, should have failed")
 	}
 }

 func TestCheckACL(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if err != nil {
 		t.Errorf("bootstrap failed due to error: %v", err)
 	}
 	defer os.Remove(cipdPath)

 	pkgMap := make(map[string]bool)
 	pkgMap[cipdPkgPathA] = false
 	pkgMap[cipdPkgPathB] = false
 	if err := CheckPackageACL(fakex, pkgMap); err != nil {
 		t.Errorf("CheckPackageACL failed due to error: %v", err)
 	}

 	if !pkgMap[cipdPkgPathA] {
 		t.Errorf("pkg %q should be accessible, but it is not accessible by cipd", cipdPkgPathA)
 	}

 	if pkgMap[cipdPkgPathB] {
 		t.Errorf("pkg %q should not be accessible, but it is accessible by cipd", cipdPkgPathB)
 	}

 }

 func TestResolve(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if err != nil {
 		t.Errorf("bootstrap failed due to error: %v", err)
 	}
 	defer os.Remove(cipdPath)

 	// Write test ensure file
 	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
 	if err != nil {
 		t.Errorf("failed to create test ensure file: %v", err)
 	}
 	defer testEnsureFile.Close()
 	ensureFileName := testEnsureFile.Name()
 	defer os.Remove(ensureFileName)
 	versionFileName := ensureFileName[:len(ensureFileName)-len(".ensure")] + ".version"
 	var ensureBuf bytes.Buffer
 	ensureBuf.WriteString("$ResolvedVersions " + versionFileName + "\n")
 	ensureBuf.WriteString(`
 $ParanoidMode CheckPresence
 $VerifiedPlatform linux-amd64
 $VerifiedPlatform mac-amd64

 # GN
 gn/gn/${platform} git_revision:bdb0fd02324b120cacde634a9235405061c8ea06
 `)
 	_, err = testEnsureFile.Write(ensureBuf.Bytes())
 	if err != nil {
 		t.Errorf("failed to write test ensure file: %v", err)
 	}

 	testEnsureFile.Sync()
 	instances, err := Resolve(fakex, testEnsureFile.Name())
 	if err != nil {
 		t.Errorf("resolve failed due to error: %v", err)
 	}
 	for _, instance := range instances {
 		if val, ok := instanceIDMap[instance.PackageName]; ok {
 			if val != instance.InstanceID {
 				t.Errorf("instance id %q for package %q does not match the record %q",
 					instance.InstanceID, instance.PackageName, val)
 			}
 		} else {
 			t.Errorf("package %q is not found in record", instance.PackageName)
 		}
 	}
 }

 func TestExpand(t *testing.T) {
 	t.Parallel()
 	platforms := []Platform{
 		{"linux", "amd64"},
 		{"linux", "arm64"},
 		{"mac", "amd64"},
 	}

 	tests := map[string][]string{
 		"gn/gn/${platform}":                   {"gn/gn/linux-amd64", "gn/gn/linux-arm64", "gn/gn/mac-amd64"},
 		"fuchsia/sysroot/${os=linux}-${arch}": {"fuchsia/sysroot/linux-amd64", "fuchsia/sysroot/linux-arm64"},
 		"infra/ninja/linux-amd64":             {"infra/ninja/linux-amd64"},
 	}

 	for k, p := range tests {
 		pkgs, err := Expand(k, platforms)
 		if err != nil {
 			t.Errorf("Expand faild on path %q due to error: %v", p, err)
 		}
 		sort.Strings(p)
 		sort.Strings(pkgs)
 		if !reflect.DeepEqual(p, pkgs) {
 			t.Errorf("test on %q failed: expecting %v, got %v", k, p, pkgs)
 		}
 	}
 }

 func TestMustExpand(t *testing.T) {
 	t.Parallel()
 	tests := map[string]bool{
 		"fuchsia/clang/${platform}":               true,
 		"fuchsia/clang/${os}-${arch}":             true,
 		"fuchsia/clang/${os=linux}-${arch=amd64}": true,
 		"fuchsia/clang/linux-amd64":               false,
 	}
 	for k, v := range tests {
 		if MustExpand(k) != v {
 			t.Errorf("MustExpand failed on package %q, expecting %v got %v", k, v, MustExpand(k))
 		}
 	}
 }

 func TestDecl(t *testing.T) {
 	t.Parallel()
 	platforms := []Platform{
 		{"linux", "amd64"},
 		{"linux", "arm64"},
 		{"mac", "amd64"},
 	}

 	tests := map[string]string{
 		"fuchsia/clang/${platform}":               "fuchsia/clang/${platform=linux-amd64,linux-arm64,mac-amd64}",
 		"fuchsia/clang/${os}-${arch}":             "fuchsia/clang/${os=linux,mac}-${arch=amd64,arm64}",
 		"fuchsia/clang/${os=linux}-${arch}":       "fuchsia/clang/${os=linux}-${arch=amd64,arm64}",
 		"fuchsia/clang/${os=linux}-${arch=amd64}": "fuchsia/clang/${os=linux}-${arch=amd64}",
 		"fuchsia/clang/linux-amd64":               "fuchsia/clang/linux-amd64",
 	}

 	for k, v := range tests {
 		cipdPath, err := Decl(k, platforms)
 		if err != nil {
 			t.Errorf("Decl failed on cipdPath %q due to error: %v", k, err)
 		}
 		if cipdPath != v {
 			t.Errorf("test on %q failed: expecting %q, got %q", k, v, cipdPath)
 		}
 	}
 }

 func TestFloatingRefs(t *testing.T) {
 	fakex, cleanup := xtest.NewX(t)
 	defer cleanup()
 	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
 	if err != nil {
 		t.Errorf("bootstrap failed due to error: %v", err)
 	}
 	defer os.Remove(cipdPath)
 	testExpects := map[PackageInstance]bool{
 		{
 			PackageName: "gn/gn/${platform}",
 			VersionTag:  "latest",
 		}: true,
 		{
 			PackageName: "gn/gn/${platform}",
 			VersionTag:  "git_revision:bdb0fd02324b120cacde634a9235405061c8ea06",
 		}: false,
 	}

 	platformMap := make(map[PackageInstance][]Platform)
 	for k := range testExpects {
 		platformMap[k] = DefaultPlatforms()
 	}

 	tests := make(map[PackageInstance]bool)
 	for k, v := range testExpects {
 		tests[k] = v
 	}

 	if err := CheckFloatingRefs(fakex, tests, platformMap); err != nil {
 		t.Errorf("CheckFloatingRefs failed due to error: %v", err)
 		return
 	}

 	for k, v := range tests {
 		if v != testExpects[k] {
 			t.Errorf("expecting %v, got %v for test %q", testExpects[k], v, k.PackageName)
 		}
 	}
 }
	// Copyright 2018 The Fuchsia 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 cipd

	import (
	"bytes"
	"encoding/hex"
	"io/ioutil"
	"os"
	"path"
	"reflect"
	"sort"
	"strings"
	"testing"

	"go.fuchsia.dev/jiri/jiritest/xtest"
	)

	const (
	// Some random valid cipd version tags from infra/tools/cipd
	cipdVersionForTestA = "git_revision:00e2d8b49a4e7505d1c71f19d15c9e7c5b9245a5"
	cipdVersionForTestB = "git_revision:8fac632847b1ce0de3b57d16d0f2193625f4a4f0"
	// package path and versions for ACL tests
	cipdPkgPathA = "gn/gn/${platform}"
	cipdPkgVersionA = "git_revision:bdb0fd02324b120cacde634a9235405061c8ea06"
	cipdPkgPathB = "notexist/notexist"
	cipdPkgVersionB = "git_revision:bdb0fd02324b120cacde634a9235405061c8ea06"
	)

	var (
	// Digests generated by cipd selfupdate-roll ...
	digestMapA = map[string]string{
	"linux-amd64": "df37ffc2588e345a31ca790d773b6136fedbd2efbf9a34cb735dd34b6891c16c",
	"linux-arm64": "650f2a045f8587062a16299a650aa24ba5c5c0652585a2d9bd56594369d5f99e",
	"linux-armv6l": "61b657c860ddc39d3286ced073c843852b1dafc0222af0bdc22ad988b289d733",
	"mac-amd64": "4d015791ed6f03f305cf6a5a673a447e5c47ff5fdb701f43f99fba9ca73e61f8",
	}
	digestMapB = map[string]string{
	"linux-amd64": "bdc971fd2895c3771e0709d2a3ec5fcace69c59a3a9f9dc33ab76fbc2f777d40",
	"linux-arm64": "e1d6aadc9bfc155e9088aa3de39b9d3311c7359f398f372b5ad1c308e25edfeb",
	"linux-armv6l": "3ad97b47ecc1b358c8ebd1b0307087d354433d88f24bf8ece096fb05452837f9",
	"mac-amd64": "167edadf7c7c019a40b9f7869a4c05b2d9834427dad68e295442ef9ebce88dba",
	}
	instanceIDMap = map[string]string{
	"gn/gn/linux-amd64": "0uGjKAZkJXPZjtYktgEwHiNbwsut_qRsk7ZCGGxi82IC",
	"gn/gn/mac-amd64": "rN2F641yR4Bj-H1q8OwC_RiqRpUYxy3hryzRfPER9wcC",
	}
	)

	// TestFetchBinary tests fetchiBinary method by fetching a set of
	// cipd binaries. This test requires network access
	func TestFetchBinary(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	tmpDir, err := ioutil.TempDir("", "jiri-test")
	if err != nil {
	t.Error("failed to create temp dir for testing")
	}
	defer os.RemoveAll(tmpDir)

	tests := []struct {
	version string
	digest map[string]string
	}{
	{cipdVersionForTestA, digestMapA},
	{cipdVersionForTestB, digestMapB},
	}

	for i, test := range tests {
	for platform, digest := range test.digest {
	cipdPath := path.Join(tmpDir, "cipd"+platform+test.version)
	if err := fetchBinary(fakex, cipdPath, platform, test.version, digest); err != nil {
	t.Errorf("test %d failed while retrieving cipd binary for platform %q on version %q with digest %q: %v", i, platform, test.version, digest, err)
	}
	}
	}
	}

	func TestCipdVersion(t *testing.T) {
	t.Parallel()
	// Assume cipd version is always a git commit hash for now
	versionStr := string(cipdVersion)
	if len(versionStr) != len("git_revision:00e2d8b49a4e7505d1c71f19d15c9e7c5b9245a5") \|\|
	!strings.HasPrefix(versionStr, "git_revision:") {
	t.Errorf("unsupported cipd version tag: %q", versionStr)
	}
	versionHash := versionStr[len("git_revision:"):]
	if _, err := hex.DecodeString(versionHash); err != nil {
	t.Errorf("unsupported cipd version tag: %q", versionStr)
	}
	}

	func TestFetchDigest(t *testing.T) {
	t.Parallel()
	tests := []string{
	"linux-amd64",
	"linux-arm64",
	"linux-armv6l",
	"mac-amd64",
	}

	for _, platform := range tests {
	digest, _, err := fetchDigest(platform)
	if err != nil {
	t.Errorf("failed to retrieve cipd digest for platform %q due to error: %v", platform, err)
	}
	if _, err := hex.DecodeString(digest); err != nil {
	t.Errorf("digest %q is not a valid hex string for platform %q", digest, platform)
	}
	}
	}

	func TestSelfUpdate(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	tmpDir, err := ioutil.TempDir("", "jiri-test")
	if err != nil {
	t.Error("failed to create temp dir for testing")
	}
	defer os.RemoveAll(tmpDir)
	// Bootstrap cipd to version A
	cipdPath := path.Join(tmpDir, "cipd")
	if err := fetchBinary(fakex, cipdPath, CipdPlatform.String(), cipdVersionForTestA, digestMapA[CipdPlatform.String()]); err != nil {
	t.Errorf("failed to bootstrap cipd with version %q: %v", cipdVersionForTestA, err)
	}
	// Perform cipd self update to version B
	if err := selfUpdate(cipdPath, cipdVersionForTestB); err != nil {
	t.Errorf("failed to perform cipd self update: %v", err)
	}
	// Verify self updated cipd
	cipdData, err := ioutil.ReadFile(cipdPath)
	if err != nil {
	t.Errorf("failed to read self-updated cipd binary: %v", err)
	}
	verified, err := verifyDigest(cipdData, digestMapB[CipdPlatform.String()])
	if err != nil {
	t.Errorf("digest failed verification for platform %q on version %q", CipdPlatform.String(), cipdVersionForTestB)
	}
	if !verified {
	t.Errorf("self-updated cipd failed integrity test")
	}
	}

	func TestBootsrap(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if cipdPath == "" {
	t.Errorf("bootstrap returned an empty path")
	}
	fileInfo, err := os.Stat(cipdPath)
	if err != nil {
	if os.IsNotExist(err) {
	t.Errorf("bootstrap failed, cipd binary was not found at %q", cipdPath)
	}
	t.Errorf("bootstrap failed, could not access cipd binary at %q due to error %v", cipdPath, err)
	}
	if fileInfo.Mode()&0111 == 0 {
	t.Errorf("bootstrap failed, cipd binary at %q is not executable", cipdBinary)
	}
	}

	func TestEnsure(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if err != nil {
	t.Errorf("bootstrap failed due to error: %v", err)
	}
	defer os.Remove(cipdPath)
	// Write test ensure file
	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
	if err != nil {
	t.Errorf("failed to create test ensure file: %v", err)
	}
	defer testEnsureFile.Close()
	defer os.Remove(testEnsureFile.Name())
	_, err = testEnsureFile.Write([]byte(`
	$ParanoidMode CheckPresence

	# GN
	gn/gn/${platform} git_revision:bdb0fd02324b120cacde634a9235405061c8ea06
	`))
	if err != nil {
	t.Errorf("failed to write test ensure file: %v", err)
	}
	testEnsureFile.Sync()
	tmpDir, err := ioutil.TempDir("", "jiri-test")
	if err != nil {
	t.Error("failed to creat temp dir for testing")
	}
	defer os.RemoveAll(tmpDir)
	// Invoke Ensure on test ensure file
	if err := Ensure(fakex, testEnsureFile.Name(), tmpDir, 30); err != nil {
	t.Errorf("ensure failed due to error: %v", err)
	}
	// Check the existence downloaded package
	gnPath := path.Join(tmpDir, "gn")
	if _, err := os.Stat(gnPath); err != nil {
	if os.IsNotExist(err) {
	t.Errorf("fetched cipd package is not found at %q", gnPath)
	}
	t.Errorf("failed to execute os.Stat() on fetched cipd package due to error: %v", err)
	}
	}

	func TestEnsureFileVerify(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if err != nil {
	t.Errorf("bootstrap failed due to error: %v", err)
	}
	defer os.Remove(cipdPath)
	// Write test ensure file
	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
	if err != nil {
	t.Errorf("failed to create test ensure file: %v", err)
	}
	defer testEnsureFile.Close()
	defer os.Remove(testEnsureFile.Name())
	_, err = testEnsureFile.Write([]byte(`
	$ParanoidMode CheckPresence
	$VerifiedPlatform linux-amd64
	$VerifiedPlatform mac-amd64

	# GN
	gn/gn/${platform} git_revision:bdb0fd02324b120cacde634a9235405061c8ea06
	`))
	if err != nil {
	t.Errorf("failed to write test ensure file: %v", err)
	}
	testEnsureFile.Sync()
	if err := EnsureFileVerify(fakex, testEnsureFile.Name()); err != nil {
	t.Error("ensure file failed verification")
	}
	}

	func TestEnsureFileVerifyInvalid(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if err != nil {
	t.Errorf("bootstrap failed due to error: %v", err)
	}
	defer os.Remove(cipdPath)
	// Write test ensure file
	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
	if err != nil {
	t.Errorf("failed to create test ensure file: %v", err)
	}
	defer testEnsureFile.Close()
	defer os.Remove(testEnsureFile.Name())
	_, err = testEnsureFile.Write([]byte(`
	$ParanoidMode CheckPresence
	$VerifiedPlatform linux-amd64
	$VerifiedPlatform mac-amd64

	# GN
	gn/gn/${platform} git_revision:not_a_real_version
	`))
	if err != nil {
	t.Errorf("failed to write test ensure file: %v", err)
	}
	testEnsureFile.Sync()
	if err := EnsureFileVerify(fakex, testEnsureFile.Name()); err == nil {
	t.Error("ensure file passed verification, should have failed")
	}
	}

	func TestCheckACL(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if err != nil {
	t.Errorf("bootstrap failed due to error: %v", err)
	}
	defer os.Remove(cipdPath)

	pkgMap := make(map[string]bool)
	pkgMap[cipdPkgPathA] = false
	pkgMap[cipdPkgPathB] = false
	if err := CheckPackageACL(fakex, pkgMap); err != nil {
	t.Errorf("CheckPackageACL failed due to error: %v", err)
	}

	if !pkgMap[cipdPkgPathA] {
	t.Errorf("pkg %q should be accessible, but it is not accessible by cipd", cipdPkgPathA)
	}

	if pkgMap[cipdPkgPathB] {
	t.Errorf("pkg %q should not be accessible, but it is accessible by cipd", cipdPkgPathB)
	}

	}

	func TestResolve(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if err != nil {
	t.Errorf("bootstrap failed due to error: %v", err)
	}
	defer os.Remove(cipdPath)

	// Write test ensure file
	testEnsureFile, err := ioutil.TempFile("", "test_jiri*.ensure")
	if err != nil {
	t.Errorf("failed to create test ensure file: %v", err)
	}
	defer testEnsureFile.Close()
	ensureFileName := testEnsureFile.Name()
	defer os.Remove(ensureFileName)
	versionFileName := ensureFileName[:len(ensureFileName)-len(".ensure")] + ".version"
	var ensureBuf bytes.Buffer
	ensureBuf.WriteString("$ResolvedVersions " + versionFileName + "\n")
	ensureBuf.WriteString(`
	$ParanoidMode CheckPresence
	$VerifiedPlatform linux-amd64
	$VerifiedPlatform mac-amd64

	# GN
	gn/gn/${platform} git_revision:bdb0fd02324b120cacde634a9235405061c8ea06
	`)
	_, err = testEnsureFile.Write(ensureBuf.Bytes())
	if err != nil {
	t.Errorf("failed to write test ensure file: %v", err)
	}

	testEnsureFile.Sync()
	instances, err := Resolve(fakex, testEnsureFile.Name())
	if err != nil {
	t.Errorf("resolve failed due to error: %v", err)
	}
	for _, instance := range instances {
	if val, ok := instanceIDMap[instance.PackageName]; ok {
	if val != instance.InstanceID {
	t.Errorf("instance id %q for package %q does not match the record %q",
	instance.InstanceID, instance.PackageName, val)
	}
	} else {
	t.Errorf("package %q is not found in record", instance.PackageName)
	}
	}
	}

	func TestExpand(t *testing.T) {
	t.Parallel()
	platforms := []Platform{
	{"linux", "amd64"},
	{"linux", "arm64"},
	{"mac", "amd64"},
	}

	tests := map[string][]string{
	"gn/gn/${platform}": {"gn/gn/linux-amd64", "gn/gn/linux-arm64", "gn/gn/mac-amd64"},
	"fuchsia/sysroot/${os=linux}-${arch}": {"fuchsia/sysroot/linux-amd64", "fuchsia/sysroot/linux-arm64"},
	"infra/ninja/linux-amd64": {"infra/ninja/linux-amd64"},
	}

	for k, p := range tests {
	pkgs, err := Expand(k, platforms)
	if err != nil {
	t.Errorf("Expand faild on path %q due to error: %v", p, err)
	}
	sort.Strings(p)
	sort.Strings(pkgs)
	if !reflect.DeepEqual(p, pkgs) {
	t.Errorf("test on %q failed: expecting %v, got %v", k, p, pkgs)
	}
	}
	}

	func TestMustExpand(t *testing.T) {
	t.Parallel()
	tests := map[string]bool{
	"fuchsia/clang/${platform}": true,
	"fuchsia/clang/${os}-${arch}": true,
	"fuchsia/clang/${os=linux}-${arch=amd64}": true,
	"fuchsia/clang/linux-amd64": false,
	}
	for k, v := range tests {
	if MustExpand(k) != v {
	t.Errorf("MustExpand failed on package %q, expecting %v got %v", k, v, MustExpand(k))
	}
	}
	}

	func TestDecl(t *testing.T) {
	t.Parallel()
	platforms := []Platform{
	{"linux", "amd64"},
	{"linux", "arm64"},
	{"mac", "amd64"},
	}

	tests := map[string]string{
	"fuchsia/clang/${platform}": "fuchsia/clang/${platform=linux-amd64,linux-arm64,mac-amd64}",
	"fuchsia/clang/${os}-${arch}": "fuchsia/clang/${os=linux,mac}-${arch=amd64,arm64}",
	"fuchsia/clang/${os=linux}-${arch}": "fuchsia/clang/${os=linux}-${arch=amd64,arm64}",
	"fuchsia/clang/${os=linux}-${arch=amd64}": "fuchsia/clang/${os=linux}-${arch=amd64}",
	"fuchsia/clang/linux-amd64": "fuchsia/clang/linux-amd64",
	}

	for k, v := range tests {
	cipdPath, err := Decl(k, platforms)
	if err != nil {
	t.Errorf("Decl failed on cipdPath %q due to error: %v", k, err)
	}
	if cipdPath != v {
	t.Errorf("test on %q failed: expecting %q, got %q", k, v, cipdPath)
	}
	}
	}

	func TestFloatingRefs(t *testing.T) {
	fakex, cleanup := xtest.NewX(t)
	defer cleanup()
	cipdPath, err := Bootstrap(fakex, fakex.CIPDPath())
	if err != nil {
	t.Errorf("bootstrap failed due to error: %v", err)
	}
	defer os.Remove(cipdPath)
	testExpects := map[PackageInstance]bool{
	{
	PackageName: "gn/gn/${platform}",
	VersionTag: "latest",
	}: true,
	{
	PackageName: "gn/gn/${platform}",
	VersionTag: "git_revision:bdb0fd02324b120cacde634a9235405061c8ea06",
	}: false,
	}

	platformMap := make(map[PackageInstance][]Platform)
	for k := range testExpects {
	platformMap[k] = DefaultPlatforms()
	}

	tests := make(map[PackageInstance]bool)
	for k, v := range testExpects {
	tests[k] = v
	}

	if err := CheckFloatingRefs(fakex, tests, platformMap); err != nil {
	t.Errorf("CheckFloatingRefs failed due to error: %v", err)
	return
	}

	for k, v := range tests {
	if v != testExpects[k] {
	t.Errorf("expecting %v, got %v for test %q", testExpects[k], v, k.PackageName)
	}
	}
	}