github.com/golang/dep@v0.5.4/gps/verify/digest_test.go

// Copyright 2017 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 verify

import (
	"bytes"
	"io"
	"os"
	"path/filepath"
	"testing"
)

// crossBuffer is a test io.Reader that emits a few canned responses.
type crossBuffer struct {
	readCount  int
	iterations []string
}

func (cb *crossBuffer) Read(buf []byte) (int, error) {
	if cb.readCount == len(cb.iterations) {
		return 0, io.EOF
	}
	cb.readCount++
	return copy(buf, cb.iterations[cb.readCount-1]), nil
}

func streamThruLineEndingReader(t *testing.T, iterations []string) []byte {
	dst := new(bytes.Buffer)
	n, err := io.Copy(dst, newLineEndingReader(&crossBuffer{iterations: iterations}))
	if got, want := err, error(nil); got != want {
		t.Errorf("(GOT): %v; (WNT): %v", got, want)
	}
	if got, want := n, int64(dst.Len()); got != want {
		t.Errorf("(GOT): %v; (WNT): %v", got, want)
	}
	return dst.Bytes()
}

func TestLineEndingReader(t *testing.T) {
	testCases := []struct {
		input  []string
		output string
	}{
		{[]string{"\r"}, "\r"},
		{[]string{"\r\n"}, "\n"},
		{[]string{"now is the time\r\n"}, "now is the time\n"},
		{[]string{"now is the time\r\n(trailing data)"}, "now is the time\n(trailing data)"},
		{[]string{"now is the time\n"}, "now is the time\n"},
		{[]string{"now is the time\r"}, "now is the time\r"},     // trailing CR ought to convey
		{[]string{"\rnow is the time"}, "\rnow is the time"},     // CR not followed by LF ought to convey
		{[]string{"\rnow is the time\r"}, "\rnow is the time\r"}, // CR not followed by LF ought to convey

		// no line splits
		{[]string{"first", "second", "third"}, "firstsecondthird"},

		// 1->2 and 2->3 both break across a CRLF
		{[]string{"first\r", "\nsecond\r", "\nthird"}, "first\nsecond\nthird"},

		// 1->2 breaks across CRLF and 2->3 does not
		{[]string{"first\r", "\nsecond", "third"}, "first\nsecondthird"},

		// 1->2 breaks across CRLF and 2 ends in CR but 3 does not begin LF
		{[]string{"first\r", "\nsecond\r", "third"}, "first\nsecond\rthird"},

		// 1 ends in CR but 2 does not begin LF, and 2->3 breaks across CRLF
		{[]string{"first\r", "second\r", "\nthird"}, "first\rsecond\nthird"},

		// 1 ends in CR but 2 does not begin LF, and 2->3 does not break across CRLF
		{[]string{"first\r", "second\r", "\nthird"}, "first\rsecond\nthird"},

		// 1->2 and 2->3 both break across a CRLF, but 3->4 does not
		{[]string{"first\r", "\nsecond\r", "\nthird\r", "fourth"}, "first\nsecond\nthird\rfourth"},
		{[]string{"first\r", "\nsecond\r", "\nthird\n", "fourth"}, "first\nsecond\nthird\nfourth"},

		{[]string{"this is the result\r\nfrom the first read\r", "\nthis is the result\r\nfrom the second read\r"},
			"this is the result\nfrom the first read\nthis is the result\nfrom the second read\r"},
		{[]string{"now is the time\r\nfor all good engineers\r\nto improve their test coverage!\r\n"},
			"now is the time\nfor all good engineers\nto improve their test coverage!\n"},
		{[]string{"now is the time\r\nfor all good engineers\r", "\nto improve their test coverage!\r\n"},
			"now is the time\nfor all good engineers\nto improve their test coverage!\n"},
	}

	for _, testCase := range testCases {
		got := streamThruLineEndingReader(t, testCase.input)
		if want := []byte(testCase.output); !bytes.Equal(got, want) {
			t.Errorf("Input: %#v; (GOT): %#q; (WNT): %#q", testCase.input, got, want)
		}
	}
}

////////////////////////////////////////

func getTestdataVerifyRoot(t *testing.T) string {
	cwd, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}
	return filepath.Join(filepath.Dir(cwd), "_testdata/digest")
}

func TestDigestFromDirectoryBailsUnlessDirectory(t *testing.T) {
	prefix := getTestdataVerifyRoot(t)
	relativePathname := "launchpad.net/match"
	_, err := DigestFromDirectory(filepath.Join(prefix, relativePathname))
	if got, want := err, error(nil); got != want {
		t.Errorf("\n(GOT): %v; (WNT): %v", got, want)
	}
}

func TestDigestFromDirectory(t *testing.T) {
	relativePathname := "launchpad.net/match"
	want := []byte{0x7e, 0x10, 0x6, 0x2f, 0x8, 0x3, 0x3c, 0x76, 0xae, 0xbc, 0xa4, 0xc9, 0xec, 0x73, 0x67, 0x15, 0x70, 0x2b, 0x0, 0x89, 0x27, 0xbb, 0x61, 0x9d, 0xc7, 0xc3, 0x39, 0x46, 0x3, 0x91, 0xb7, 0x3b}

	// NOTE: Create the hash using both an absolute and a relative pathname to
	// ensure hash ignores prefix.

	t.Run("AbsolutePrefix", func(t *testing.T) {
		t.Parallel()
		prefix := getTestdataVerifyRoot(t)
		got, err := DigestFromDirectory(filepath.Join(prefix, relativePathname))
		if err != nil {
			t.Fatal(err)
		}
		if !bytes.Equal(got.Digest, want) {
			t.Errorf("\n(GOT):\n\t%#v\n(WNT):\n\t%#v", got, want)
		}
	})

	t.Run("RelativePrefix", func(t *testing.T) {
		t.Parallel()
		prefix := "../_testdata/digest"
		got, err := DigestFromDirectory(filepath.Join(prefix, relativePathname))
		if err != nil {
			t.Fatal(err)
		}
		if !bytes.Equal(got.Digest, want) {
			t.Errorf("\n(GOT):\n\t%#v\n(WNT):\n\t%#v", got, want)
		}
	})
}

func TestVerifyDepTree(t *testing.T) {
	vendorRoot := getTestdataVerifyRoot(t)

	wantSums := map[string][]byte{
		"github.com/alice/match":       {0x7e, 0x10, 0x6, 0x2f, 0x8, 0x3, 0x3c, 0x76, 0xae, 0xbc, 0xa4, 0xc9, 0xec, 0x73, 0x67, 0x15, 0x70, 0x2b, 0x0, 0x89, 0x27, 0xbb, 0x61, 0x9d, 0xc7, 0xc3, 0x39, 0x46, 0x3, 0x91, 0xb7, 0x3b},
		"github.com/alice/mismatch":    []byte("some non-matching digest"),
		"github.com/bob/emptyDigest":   nil, // empty hash result
		"github.com/bob/match":         {0x7e, 0x10, 0x6, 0x2f, 0x8, 0x3, 0x3c, 0x76, 0xae, 0xbc, 0xa4, 0xc9, 0xec, 0x73, 0x67, 0x15, 0x70, 0x2b, 0x0, 0x89, 0x27, 0xbb, 0x61, 0x9d, 0xc7, 0xc3, 0x39, 0x46, 0x3, 0x91, 0xb7, 0x3b},
		"github.com/charlie/notInTree": nil, // not in tree result ought to superseede empty digest result
		// matching result at seldom found directory level
		"launchpad.net/match": {0x7e, 0x10, 0x6, 0x2f, 0x8, 0x3, 0x3c, 0x76, 0xae, 0xbc, 0xa4, 0xc9, 0xec, 0x73, 0x67, 0x15, 0x70, 0x2b, 0x0, 0x89, 0x27, 0xbb, 0x61, 0x9d, 0xc7, 0xc3, 0x39, 0x46, 0x3, 0x91, 0xb7, 0x3b},
	}

	checkStatus := func(t *testing.T, status map[string]VendorStatus, key string, want VendorStatus) {
		t.Helper()
		got, ok := status[key]
		if !ok {
			t.Errorf("Want key: %q", key)
			return
		}
		if got != want {
			t.Errorf("Key: %q; (GOT): %v; (WNT): %v", key, got, want)
		}
	}

	t.Run("normal", func(t *testing.T) {
		t.Parallel()
		wantDigests := make(map[string]VersionedDigest)
		for k, v := range wantSums {
			wantDigests[k] = VersionedDigest{
				HashVersion: HashVersion,
				Digest:      v,
			}
		}

		status, err := CheckDepTree(vendorRoot, wantDigests)
		if err != nil {
			t.Fatal(err)
		}

		if got, want := len(status), 7; got != want {
			t.Errorf("Unexpected result count from VerifyDepTree:\n\t(GOT): %v\n\t(WNT): %v", got, want)
		}

		checkStatus(t, status, "github.com/alice/match", NoMismatch)
		checkStatus(t, status, "github.com/alice/mismatch", DigestMismatchInLock)
		checkStatus(t, status, "github.com/alice/notInLock", NotInLock)
		checkStatus(t, status, "github.com/bob/match", NoMismatch)
		checkStatus(t, status, "github.com/bob/emptyDigest", EmptyDigestInLock)
		checkStatus(t, status, "github.com/charlie/notInTree", NotInTree)
		checkStatus(t, status, "launchpad.net/match", NoMismatch)

		if t.Failed() {
			for k, want := range wantSums {
				got, err := DigestFromDirectory(filepath.Join(vendorRoot, k))
				if err != nil {
					t.Error(err)
				}
				if !bytes.Equal(got.Digest, want) {
					t.Errorf("Digest mismatch for %q\n(GOT):\n\t%#v\n(WNT):\n\t%#v", k, got, want)
				}
			}
		}

	})

	t.Run("hashv-mismatch", func(t *testing.T) {
		t.Parallel()
		wantDigests := make(map[string]VersionedDigest)
		for k, v := range wantSums {
			wantDigests[k] = VersionedDigest{
				HashVersion: HashVersion + 1,
				Digest:      v,
			}
		}

		status, err := CheckDepTree(vendorRoot, wantDigests)
		if err != nil {
			t.Fatal(err)
		}

		if got, want := len(status), 7; got != want {
			t.Errorf("Unexpected result count from VerifyDepTree:\n\t(GOT): %v\n\t(WNT): %v", got, want)
		}

		checkStatus(t, status, "github.com/alice/match", HashVersionMismatch)
		checkStatus(t, status, "github.com/alice/mismatch", HashVersionMismatch)
		checkStatus(t, status, "github.com/alice/notInLock", NotInLock)
		checkStatus(t, status, "github.com/bob/match", HashVersionMismatch)
		checkStatus(t, status, "github.com/bob/emptyDigest", HashVersionMismatch)
		checkStatus(t, status, "github.com/charlie/notInTree", NotInTree)
		checkStatus(t, status, "launchpad.net/match", HashVersionMismatch)
	})

	t.Run("Non-existent directory", func(t *testing.T) {
		t.Parallel()
		wantDigests := make(map[string]VersionedDigest)
		for k, v := range wantSums {
			wantDigests[k] = VersionedDigest{
				HashVersion: HashVersion + 1,
				Digest:      v,
			}
		}

		status, err := CheckDepTree("fooVendorRoot", wantDigests)
		if err != nil {
			t.Fatal(err)
		}

		if got, want := len(status), 6; got != want {
			t.Errorf("Unexpected result count from VerifyDepTree:\n\t(GOT): %v\n\t(WNT): %v", got, want)
		}

		checkStatus(t, status, "github.com/alice/match", NotInTree)
		checkStatus(t, status, "github.com/alice/mismatch", NotInTree)
		checkStatus(t, status, "github.com/bob/match", NotInTree)
		checkStatus(t, status, "github.com/bob/emptyDigest", NotInTree)
		checkStatus(t, status, "github.com/charlie/notInTree", NotInTree)
		checkStatus(t, status, "launchpad.net/match", NotInTree)

	})
}

func TestParseVersionedDigest(t *testing.T) {
	t.Run("Parse valid VersionedDigest", func(t *testing.T) {
		t.Parallel()
		input := "1:60861e762bdbe39c4c7bf292c291329b731c9925388fd41125888f5c1c595feb"
		vd, err := ParseVersionedDigest(input)
		if err != nil {
			t.Fatal()
		}

		expectedHash := "60861e762bdbe39c4c7bf292c291329b731c9925388fd41125888f5c1c595feb"
		if got, want := vd.Digest, expectedHash; bytes.Equal(got, []byte(expectedHash)) {
			t.Errorf("Unexpected result from ParseVersionedDigest:\n\t(GOT): %s\n\t(WNT): %s", got, want)
		}

		if got, want := vd.String(), input; got != want {
			t.Errorf("Unexpected result from ParseVersionedDigest String:\n\t(GOT): %s\n\t(WNT): %s", got, want)
		}
	})

	t.Run("Parse VersionedDigest with invalid format", func(t *testing.T) {
		t.Parallel()
		input := "1abc"
		_, err := ParseVersionedDigest(input)
		if err == nil {
			t.Error("expected error for invalid VersionedDigest format")
		}
	})

	t.Run("Parse VersionedDigest with invalid hex string", func(t *testing.T) {
		t.Parallel()
		input := "1:60861g762bdbe39c4c7bf292c291329b731c9925388fd41125888f5c1c595feb"
		_, err := ParseVersionedDigest(input)
		if err == nil {
			t.Error("expected error VersionedDigest with invalid hex string")
		}
	})

	t.Run("Parse VersionedDigest with invalid hash version", func(t *testing.T) {
		t.Parallel()
		input := "a:60861e762bdbe39c4c7bf292c291329b731c9925388fd41125888f5c1c595feb"
		_, err := ParseVersionedDigest(input)
		if err == nil {
			t.Error("expected error VersionedDigest with invalid hash version")
		}
	})
}

func BenchmarkDigestFromDirectory(b *testing.B) {
	b.Skip("Eliding benchmark of user's Go source directory")

	prefix := filepath.Join(os.Getenv("GOPATH"), "src")

	for i := 0; i < b.N; i++ {
		_, err := DigestFromDirectory(prefix)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkVerifyDepTree(b *testing.B) {
	b.Skip("Eliding benchmark of user's Go source directory")

	prefix := filepath.Join(os.Getenv("GOPATH"), "src")

	for i := 0; i < b.N; i++ {
		_, err := CheckDepTree(prefix, nil)
		if err != nil {
			b.Fatal(err)
		}
	}
}