lock_test.go

// Copyright 2016 The Go 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 dep

import (
	"reflect"
	"strings"
	"testing"

	"github.com/flowrean/dep/gps"
	"github.com/flowrean/dep/gps/verify"
	"github.com/flowrean/dep/internal/test"
)

func TestReadLock(t *testing.T) {
	h := test.NewHelper(t)
	defer h.Cleanup()

	golden := "lock/golden0.toml"
	g0f := h.GetTestFile(golden)
	defer g0f.Close()
	got, err := readLock(g0f)
	if err != nil {
		t.Fatalf("Should have read Lock correctly, but got err %q", err)
	}

	want := &Lock{
		SolveMeta: SolveMeta{InputImports: []string{}},
		P: []gps.LockedProject{
			verify.VerifiableProject{
				LockedProject: gps.NewLockedProject(
					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/flowrean/dep")},
					gps.NewBranch("master").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
					[]string{"."},
				),
				PruneOpts: gps.PruneOptions(1),
				Digest: verify.VersionedDigest{
					HashVersion: verify.HashVersion,
					Digest:      []byte("foo"),
				},
			},
		},
	}

	if !reflect.DeepEqual(got, want) {
		t.Error("Valid lock did not parse as expected")
	}

	golden = "lock/golden1.toml"
	g1f := h.GetTestFile(golden)
	defer g1f.Close()
	got, err = readLock(g1f)
	if err != nil {
		t.Fatalf("Should have read Lock correctly, but got err %q", err)
	}

	want = &Lock{
		SolveMeta: SolveMeta{InputImports: []string{}},
		P: []gps.LockedProject{
			verify.VerifiableProject{
				LockedProject: gps.NewLockedProject(
					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/flowrean/dep")},
					gps.NewVersion("0.12.2").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
					[]string{"."},
				),
				PruneOpts: gps.PruneOptions(15),
				Digest: verify.VersionedDigest{
					HashVersion: verify.HashVersion,
					Digest:      []byte("foo"),
				},
			},
		},
	}

	if !reflect.DeepEqual(got, want) {
		t.Error("Valid lock did not parse as expected")
	}
}

func TestWriteLock(t *testing.T) {
	h := test.NewHelper(t)
	defer h.Cleanup()

	golden := "lock/golden0.toml"
	want := h.GetTestFileString(golden)
	l := &Lock{
		P: []gps.LockedProject{
			verify.VerifiableProject{
				LockedProject: gps.NewLockedProject(
					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/flowrean/dep")},
					gps.NewBranch("master").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
					[]string{"."},
				),
				PruneOpts: gps.PruneOptions(1),
				Digest: verify.VersionedDigest{
					HashVersion: verify.HashVersion,
					Digest:      []byte("foo"),
				},
			},
		},
	}

	got, err := l.MarshalTOML()
	if err != nil {
		t.Fatalf("Error while marshaling valid lock to TOML: %q", err)
	}

	if string(got) != want {
		if *test.UpdateGolden {
			if err = h.WriteTestFile(golden, string(got)); err != nil {
				t.Fatal(err)
			}
		} else {
			t.Errorf("Valid lock did not marshal to TOML as expected:\n\t(GOT): %s\n\t(WNT): %s", string(got), want)
		}
	}

	golden = "lock/golden1.toml"
	want = h.GetTestFileString(golden)
	l = &Lock{
		P: []gps.LockedProject{
			verify.VerifiableProject{
				LockedProject: gps.NewLockedProject(
					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/flowrean/dep")},
					gps.NewVersion("0.12.2").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
					[]string{"."},
				),
				PruneOpts: gps.PruneOptions(15),
				Digest: verify.VersionedDigest{
					HashVersion: verify.HashVersion,
					Digest:      []byte("foo"),
				},
			},
		},
	}

	got, err = l.MarshalTOML()
	if err != nil {
		t.Fatalf("Error while marshaling valid lock to TOML: %q", err)
	}

	if string(got) != want {
		if *test.UpdateGolden {
			if err = h.WriteTestFile(golden, string(got)); err != nil {
				t.Fatal(err)
			}
		} else {
			t.Errorf("Valid lock did not marshal to TOML as expected:\n\t(GOT): %s\n\t(WNT): %s", string(got), want)
		}
	}
}

func TestReadLockErrors(t *testing.T) {
	h := test.NewHelper(t)
	defer h.Cleanup()
	var err error

	tests := []struct {
		name string
		file string
	}{
		{"specified both", "lock/error0.toml"},
		{"odd length", "lock/error1.toml"},
		{"no branch or version", "lock/error2.toml"},
	}

	for _, tst := range tests {
		lf := h.GetTestFile(tst.file)
		defer lf.Close()
		_, err = readLock(lf)
		if err == nil {
			t.Errorf("Reading lock with %s should have caused error, but did not", tst.name)
		} else if !strings.Contains(err.Error(), tst.name) {
			t.Errorf("Unexpected error %q; expected %s error", err, tst.name)
		}
	}
}