github.com/golang/dep@v0.5.4/lock_test.go (about)

     1  // Copyright 2016 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package dep
     6  
     7  import (
     8  	"reflect"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/golang/dep/gps"
    13  	"github.com/golang/dep/gps/verify"
    14  	"github.com/golang/dep/internal/test"
    15  )
    16  
    17  func TestReadLock(t *testing.T) {
    18  	h := test.NewHelper(t)
    19  	defer h.Cleanup()
    20  
    21  	golden := "lock/golden0.toml"
    22  	g0f := h.GetTestFile(golden)
    23  	defer g0f.Close()
    24  	got, err := readLock(g0f)
    25  	if err != nil {
    26  		t.Fatalf("Should have read Lock correctly, but got err %q", err)
    27  	}
    28  
    29  	want := &Lock{
    30  		SolveMeta: SolveMeta{InputImports: []string{}},
    31  		P: []gps.LockedProject{
    32  			verify.VerifiableProject{
    33  				LockedProject: gps.NewLockedProject(
    34  					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/golang/dep")},
    35  					gps.NewBranch("master").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
    36  					[]string{"."},
    37  				),
    38  				PruneOpts: gps.PruneOptions(1),
    39  				Digest: verify.VersionedDigest{
    40  					HashVersion: verify.HashVersion,
    41  					Digest:      []byte("foo"),
    42  				},
    43  			},
    44  		},
    45  	}
    46  
    47  	if !reflect.DeepEqual(got, want) {
    48  		t.Error("Valid lock did not parse as expected")
    49  	}
    50  
    51  	golden = "lock/golden1.toml"
    52  	g1f := h.GetTestFile(golden)
    53  	defer g1f.Close()
    54  	got, err = readLock(g1f)
    55  	if err != nil {
    56  		t.Fatalf("Should have read Lock correctly, but got err %q", err)
    57  	}
    58  
    59  	want = &Lock{
    60  		SolveMeta: SolveMeta{InputImports: []string{}},
    61  		P: []gps.LockedProject{
    62  			verify.VerifiableProject{
    63  				LockedProject: gps.NewLockedProject(
    64  					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/golang/dep")},
    65  					gps.NewVersion("0.12.2").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
    66  					[]string{"."},
    67  				),
    68  				PruneOpts: gps.PruneOptions(15),
    69  				Digest: verify.VersionedDigest{
    70  					HashVersion: verify.HashVersion,
    71  					Digest:      []byte("foo"),
    72  				},
    73  			},
    74  		},
    75  	}
    76  
    77  	if !reflect.DeepEqual(got, want) {
    78  		t.Error("Valid lock did not parse as expected")
    79  	}
    80  }
    81  
    82  func TestWriteLock(t *testing.T) {
    83  	h := test.NewHelper(t)
    84  	defer h.Cleanup()
    85  
    86  	golden := "lock/golden0.toml"
    87  	want := h.GetTestFileString(golden)
    88  	l := &Lock{
    89  		P: []gps.LockedProject{
    90  			verify.VerifiableProject{
    91  				LockedProject: gps.NewLockedProject(
    92  					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/golang/dep")},
    93  					gps.NewBranch("master").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
    94  					[]string{"."},
    95  				),
    96  				PruneOpts: gps.PruneOptions(1),
    97  				Digest: verify.VersionedDigest{
    98  					HashVersion: verify.HashVersion,
    99  					Digest:      []byte("foo"),
   100  				},
   101  			},
   102  		},
   103  	}
   104  
   105  	got, err := l.MarshalTOML()
   106  	if err != nil {
   107  		t.Fatalf("Error while marshaling valid lock to TOML: %q", err)
   108  	}
   109  
   110  	if string(got) != want {
   111  		if *test.UpdateGolden {
   112  			if err = h.WriteTestFile(golden, string(got)); err != nil {
   113  				t.Fatal(err)
   114  			}
   115  		} else {
   116  			t.Errorf("Valid lock did not marshal to TOML as expected:\n\t(GOT): %s\n\t(WNT): %s", string(got), want)
   117  		}
   118  	}
   119  
   120  	golden = "lock/golden1.toml"
   121  	want = h.GetTestFileString(golden)
   122  	l = &Lock{
   123  		P: []gps.LockedProject{
   124  			verify.VerifiableProject{
   125  				LockedProject: gps.NewLockedProject(
   126  					gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/golang/dep")},
   127  					gps.NewVersion("0.12.2").Pair(gps.Revision("d05d5aca9f895d19e9265839bffeadd74a2d2ecb")),
   128  					[]string{"."},
   129  				),
   130  				PruneOpts: gps.PruneOptions(15),
   131  				Digest: verify.VersionedDigest{
   132  					HashVersion: verify.HashVersion,
   133  					Digest:      []byte("foo"),
   134  				},
   135  			},
   136  		},
   137  	}
   138  
   139  	got, err = l.MarshalTOML()
   140  	if err != nil {
   141  		t.Fatalf("Error while marshaling valid lock to TOML: %q", err)
   142  	}
   143  
   144  	if string(got) != want {
   145  		if *test.UpdateGolden {
   146  			if err = h.WriteTestFile(golden, string(got)); err != nil {
   147  				t.Fatal(err)
   148  			}
   149  		} else {
   150  			t.Errorf("Valid lock did not marshal to TOML as expected:\n\t(GOT): %s\n\t(WNT): %s", string(got), want)
   151  		}
   152  	}
   153  }
   154  
   155  func TestReadLockErrors(t *testing.T) {
   156  	h := test.NewHelper(t)
   157  	defer h.Cleanup()
   158  	var err error
   159  
   160  	tests := []struct {
   161  		name string
   162  		file string
   163  	}{
   164  		{"specified both", "lock/error0.toml"},
   165  		{"odd length", "lock/error1.toml"},
   166  		{"no branch or version", "lock/error2.toml"},
   167  	}
   168  
   169  	for _, tst := range tests {
   170  		lf := h.GetTestFile(tst.file)
   171  		defer lf.Close()
   172  		_, err = readLock(lf)
   173  		if err == nil {
   174  			t.Errorf("Reading lock with %s should have caused error, but did not", tst.name)
   175  		} else if !strings.Contains(err.Error(), tst.name) {
   176  			t.Errorf("Unexpected error %q; expected %s error", err, tst.name)
   177  		}
   178  	}
   179  }