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

     1  // Copyright 2017 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 gps
     6  
     7  import (
     8  	"context"
     9  	"fmt"
    10  	"io/ioutil"
    11  	"log"
    12  	"os"
    13  	"path/filepath"
    14  	"testing"
    15  
    16  	"github.com/golang/dep/gps/pkgtree"
    17  	"github.com/golang/dep/internal/test"
    18  )
    19  
    20  // Executed in parallel by TestSlowVcs
    21  func testSourceGateway(t *testing.T) {
    22  	t.Parallel()
    23  
    24  	if testing.Short() {
    25  		t.Skip("Skipping gateway testing in short mode")
    26  	}
    27  	requiresBins(t, "git")
    28  
    29  	cachedir, err := ioutil.TempDir("", "smcache")
    30  	if err != nil {
    31  		t.Fatalf("failed to create temp dir: %s", err)
    32  	}
    33  	bgc := context.Background()
    34  	ctx, cancelFunc := context.WithCancel(bgc)
    35  	defer func() {
    36  		os.RemoveAll(cachedir)
    37  		cancelFunc()
    38  	}()
    39  	os.Mkdir(filepath.Join(cachedir, "sources"), 0777)
    40  
    41  	do := func(wantstate sourceState) func(t *testing.T) {
    42  		return func(t *testing.T) {
    43  			superv := newSupervisor(ctx)
    44  			deducer := newDeductionCoordinator(superv)
    45  			logger := log.New(test.Writer{TB: t}, "", 0)
    46  			sc := newSourceCoordinator(superv, deducer, cachedir, nil, logger)
    47  			defer sc.close()
    48  
    49  			id := mkPI("github.com/sdboyer/deptest")
    50  			sg, err := sc.getSourceGatewayFor(ctx, id)
    51  			if err != nil {
    52  				t.Fatal(err)
    53  			}
    54  
    55  			if sg.srcState != wantstate {
    56  				t.Fatalf("expected state to be %q, got %q", wantstate, sg.srcState)
    57  			}
    58  
    59  			if err := sg.existsUpstream(ctx); err != nil {
    60  				t.Fatalf("failed to verify upstream source: %s", err)
    61  			}
    62  
    63  			wantstate |= sourceExistsUpstream
    64  			if sg.src.existsCallsListVersions() {
    65  				wantstate |= sourceHasLatestVersionList
    66  			}
    67  			if sg.srcState != wantstate {
    68  				t.Fatalf("expected state to be %q, got %q", wantstate, sg.srcState)
    69  			}
    70  
    71  			if err := sg.syncLocal(ctx); err != nil {
    72  				t.Fatalf("error on cloning git repo: %s", err)
    73  			}
    74  
    75  			wantstate |= sourceExistsLocally | sourceHasLatestLocally
    76  			if sg.srcState != wantstate {
    77  				t.Fatalf("expected state to be %q, got %q", wantstate, sg.srcState)
    78  			}
    79  
    80  			if _, ok := sg.src.(*gitSource); !ok {
    81  				t.Fatalf("Expected a gitSource, got a %T", sg.src)
    82  			}
    83  
    84  			vlist, err := sg.listVersions(ctx)
    85  			if err != nil {
    86  				t.Fatalf("Unexpected error getting version pairs from git repo: %s", err)
    87  			}
    88  
    89  			wantstate |= sourceHasLatestVersionList
    90  			if sg.srcState != wantstate {
    91  				t.Fatalf("expected state to be %q, got %q", wantstate, sg.srcState)
    92  			}
    93  
    94  			if len(vlist) != 4 {
    95  				t.Fatalf("git test repo should've produced four versions, got %v: vlist was %s", len(vlist), vlist)
    96  			} else {
    97  				SortPairedForUpgrade(vlist)
    98  				evl := []PairedVersion{
    99  					NewVersion("v1.0.0").Pair(Revision("ff2948a2ac8f538c4ecd55962e919d1e13e74baf")),
   100  					NewVersion("v0.8.1").Pair(Revision("3f4c3bea144e112a69bbe5d8d01c1b09a544253f")),
   101  					NewVersion("v0.8.0").Pair(Revision("ff2948a2ac8f538c4ecd55962e919d1e13e74baf")),
   102  					newDefaultBranch("master").Pair(Revision("3f4c3bea144e112a69bbe5d8d01c1b09a544253f")),
   103  				}
   104  				if len(evl) != len(vlist) {
   105  					t.Errorf("expected %d versions but got %d", len(evl), len(vlist))
   106  				} else {
   107  					for i := range evl {
   108  						if !evl[i].identical(vlist[i]) {
   109  							t.Errorf("index %d: expected version identical to %#v but got %#v", i, evl[i], vlist[i])
   110  						}
   111  					}
   112  				}
   113  			}
   114  
   115  			rev := Revision("c575196502940c07bf89fd6d95e83b999162e051")
   116  			// check that an expected rev is not in cache
   117  			_, has := sg.cache.getVersionsFor(rev)
   118  			if has {
   119  				t.Fatal("shouldn't have bare revs in cache without specifically requesting them")
   120  			}
   121  
   122  			is, err := sg.revisionPresentIn(ctx, rev)
   123  			if err != nil {
   124  				t.Fatalf("unexpected error while checking revision presence: %s", err)
   125  			} else if !is {
   126  				t.Fatalf("revision that should exist was not present")
   127  			}
   128  
   129  			// check that an expected rev is not in cache
   130  			_, has = sg.cache.getVersionsFor(rev)
   131  			if !has {
   132  				t.Fatal("bare rev should be in cache after specific request for it")
   133  			}
   134  
   135  			// Ensure that a bad rev doesn't work on any method that takes
   136  			// versions
   137  			badver := NewVersion("notexist")
   138  			wanterr := fmt.Errorf("version %q does not exist in source", badver)
   139  
   140  			_, _, err = sg.getManifestAndLock(ctx, ProjectRoot("github.com/sdboyer/deptest"), badver, naiveAnalyzer{})
   141  			if err == nil {
   142  				t.Fatal("wanted err on nonexistent version")
   143  			} else if err.Error() != wanterr.Error() {
   144  				t.Fatalf("wanted nonexistent err when passing bad version, got: %s", err)
   145  			}
   146  
   147  			_, err = sg.listPackages(ctx, ProjectRoot("github.com/sdboyer/deptest"), badver)
   148  			if err == nil {
   149  				t.Fatal("wanted err on nonexistent version")
   150  			} else if err.Error() != wanterr.Error() {
   151  				t.Fatalf("wanted nonexistent err when passing bad version, got: %s", err)
   152  			}
   153  
   154  			err = sg.exportVersionTo(ctx, badver, cachedir)
   155  			if err == nil {
   156  				t.Fatal("wanted err on nonexistent version")
   157  			} else if err.Error() != wanterr.Error() {
   158  				t.Fatalf("wanted nonexistent err when passing bad version, got: %s", err)
   159  			}
   160  
   161  			wantptree := pkgtree.PackageTree{
   162  				ImportRoot: "github.com/sdboyer/deptest",
   163  				Packages: map[string]pkgtree.PackageOrErr{
   164  					"github.com/sdboyer/deptest": {
   165  						P: pkgtree.Package{
   166  							ImportPath: "github.com/sdboyer/deptest",
   167  							Name:       "deptest",
   168  							Imports:    []string{},
   169  						},
   170  					},
   171  				},
   172  			}
   173  
   174  			ptree, err := sg.listPackages(ctx, ProjectRoot("github.com/sdboyer/deptest"), Revision("ff2948a2ac8f538c4ecd55962e919d1e13e74baf"))
   175  			if err != nil {
   176  				t.Fatalf("unexpected err when getting package tree with known rev: %s", err)
   177  			}
   178  			comparePackageTree(t, wantptree, ptree)
   179  
   180  			ptree, err = sg.listPackages(ctx, ProjectRoot("github.com/sdboyer/deptest"), NewVersion("v1.0.0"))
   181  			if err != nil {
   182  				t.Fatalf("unexpected err when getting package tree with unpaired good version: %s", err)
   183  			}
   184  			comparePackageTree(t, wantptree, ptree)
   185  		}
   186  	}
   187  
   188  	// Run test twice so that we cover both the existing and non-existing case.
   189  	t.Run("empty", do(sourceExistsUpstream|sourceHasLatestVersionList))
   190  	t.Run("exists", do(sourceExistsLocally))
   191  }