dep: Update scads of tests

Tests are now almost completely working, after updating all the outputs
to the new lock format. There is also an assortment of other fixes in
here, mostly related to fixing nil pointer panics, that were uncovered
by fixing up these tests.

cmd/dep/ensure.go

@@ -278,6 +278,7 @@ func (cmd *ensureCommand) runDefault(ctx *dep.Ctx, args []string, p *dep.Project
 		return err
 	}
 
+	var solve bool
 	lock := p.ChangedLock
 	if lock != nil {
 		lsat := verify.LockSatisfiesInputs(p.Lock, p.Manifest, params.RootPackageTree)
@@ -298,21 +299,26 @@ func (cmd *ensureCommand) runDefault(ctx *dep.Ctx, args []string, p *dep.Project
 				}
 				ctx.Out.Println()
 			}
-
-			solver, err := gps.Prepare(params, sm)
-			if err != nil {
-				return errors.Wrap(err, "prepare solver")
-			}
-
-			solution, err := solver.Solve(context.TODO())
-			if err != nil {
-				return handleAllTheFailuresOfTheWorld(err)
-			}
-			lock = dep.LockFromSolution(solution, p.Manifest.PruneOptions)
+			solve = true
 		} else if cmd.noVendor {
 			// The user said not to touch vendor/, so definitely nothing to do.
 			return nil
 		}
+	} else {
+		solve = true
+	}
+
+	if solve {
+		solver, err := gps.Prepare(params, sm)
+		if err != nil {
+			return errors.Wrap(err, "prepare solver")
+		}
+
+		solution, err := solver.Solve(context.TODO())
+		if err != nil {
+			return handleAllTheFailuresOfTheWorld(err)
+		}
+		lock = dep.LockFromSolution(solution, p.Manifest.PruneOptions)
 	}
 
 	dw, err := dep.NewDeltaWriter(p.Lock, lock, <-statchan, p.Manifest.PruneOptions, filepath.Join(p.AbsRoot, "vendor"))
@@ -414,35 +420,29 @@ func (cmd *ensureCommand) runAdd(ctx *dep.Ctx, args []string, p *dep.Project, sm
 		return err
 	}
 
-	// We'll need to discard this prepared solver as later work changes params,
-	// but solver preparation is cheap and worth doing up front in order to
-	// perform the fastpath check of hash comparison.
-	solver, err := gps.Prepare(params, sm)
-	if err != nil {
-		return errors.Wrap(err, "fastpath solver prepare")
-	}
-
-	rm, _ := params.RootPackageTree.ToReachMap(true, true, false, p.Manifest.IgnoredPackages())
-
 	// Compile unique sets of 1) all external packages imported or required, and
 	// 2) the project roots under which they fall.
 	exmap := make(map[string]bool)
-	exrmap := make(map[gps.ProjectRoot]bool)
-
-	for _, ex := range append(rm.FlattenFn(paths.IsStandardImportPath), p.Manifest.Required...) {
-		exmap[ex] = true
-		root, err := sm.DeduceProjectRoot(ex)
-		if err != nil {
-			// This should be very uncommon to hit, as it entails that we
-			// couldn't deduce the root for an import, but that some previous
-			// solve run WAS able to deduce the root. It's most likely to occur
-			// if the user has e.g. not connected to their organization's VPN,
-			// and thus cannot access an internal go-get metadata service.
-			return errors.Wrapf(err, "could not deduce project root for %s", ex)
+	if p.ChangedLock != nil {
+		for _, imp := range p.ChangedLock.InputImports() {
+			exmap[imp] = true
+		}
+	} else {
+		// The only time we'll hit this branch is if
+		rm, _ := p.RootPackageTree.ToReachMap(true, true, false, p.Manifest.IgnoredPackages())
+		for _, imp := range rm.FlattenFn(paths.IsStandardImportPath) {
+			exmap[imp] = true
+		}
+		for imp := range p.Manifest.RequiredPackages() {
+			exmap[imp] = true
 		}
-		exrmap[root] = true
 	}
 
+	//exrmap, err := p.GetDirectDependencyNames(sm)
+	//if err != nil {
+	//return err
+	//}
+
 	// Note: these flags are only partially used by the latter parts of the
 	// algorithm; rather, it relies on inference. However, they remain in their
 	// entirety as future needs may make further use of them, being a handy,
@@ -620,7 +620,7 @@ func (cmd *ensureCommand) runAdd(ctx *dep.Ctx, args []string, p *dep.Project, sm
 	}
 
 	// Re-prepare a solver now that our params are complete.
-	solver, err = gps.Prepare(params, sm)
+	solver, err := gps.Prepare(params, sm)
 	if err != nil {
 		return errors.Wrap(err, "fastpath solver prepare")
 	}

cmd/dep/init.go

@@ -168,8 +168,6 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 		return errors.Wrap(err, "init failed: unable to recalculate the lock digest")
 	}
 
-	//p.Lock.SolveMeta.InputsDigest = s.HashInputs()
-
 	// Pass timestamp (yyyyMMddHHmmss format) as suffix to backup name.
 	vendorbak, err := dep.BackupVendor(filepath.Join(root, "vendor"), time.Now().Format("20060102150405"))
 	if err != nil {

cmd/dep/root_analyzer.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/golang/dep"
 	"github.com/golang/dep/gps"
-	"github.com/golang/dep/gps/verify"
 	fb "github.com/golang/dep/internal/feedback"
 	"github.com/golang/dep/internal/importers"
 	"golang.org/x/sync/errgroup"
@@ -168,7 +167,7 @@ func (a *rootAnalyzer) DeriveManifestAndLock(dir string, pr gps.ProjectRoot) (gp
 func (a *rootAnalyzer) FinalizeRootManifestAndLock(m *dep.Manifest, l *dep.Lock, ol dep.Lock) {
 	// Iterate through the new projects in solved lock and add them to manifest
 	// if they are direct deps and log feedback for all the new projects.
-	diff := verify.DiffLocks(&ol, l)
+	diff := fb.DiffLocks(&ol, l)
 	bi := fb.NewBrokenImportFeedback(diff)
 	bi.LogFeedback(a.ctx.Err)
 	for _, y := range l.Projects() {

cmd/dep/status.go

@@ -7,7 +7,6 @@ package main
 import (
 	"bytes"
 	"context"
-	"encoding/hex"
 	"encoding/json"
 	"flag"
 	"fmt"
@@ -779,7 +778,6 @@ func newRawMetadata(metadata *dep.SolveMeta) rawDetailMetadata {
 	return rawDetailMetadata{
 		AnalyzerName:    metadata.AnalyzerName,
 		AnalyzerVersion: metadata.AnalyzerVersion,
-		InputsDigest:    hex.EncodeToString(metadata.InputsDigest),
 		SolverName:      metadata.SolverName,
 		SolverVersion:   metadata.SolverVersion,
 	}
@@ -921,6 +919,10 @@ func (cmd *statusCommand) runStatusAll(ctx *dep.Ctx, out outputter, p *dep.Proje
 	sort.Slice(slp, func(i, j int) bool {
 		return slp[i].Ident().Less(slp[j].Ident())
 	})
+	slcp := p.ChangedLock.Projects()
+	sort.Slice(slcp, func(i, j int) bool {
+		return slcp[i].Ident().Less(slcp[j].Ident())
+	})
 
 	lsat := verify.LockSatisfiesInputs(p.Lock, p.Manifest, params.RootPackageTree)
 	if lsat.Passed() {

cmd/dep/testdata/harness_tests/ensure/add/desync/stdout.txt

@@ -1,2 +1 @@
-Warning: Gopkg.lock is out of sync with Gopkg.toml or the project's imports.
 Fetching sources...