adding in-process tests

cmd/dep/ensure.go

@@ -11,15 +11,13 @@ import (
 	"fmt"
 	"go/build"
 	"log"
-	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 
 	"github.com/golang/dep"
 	"github.com/golang/dep/gps"
 	"github.com/golang/dep/gps/pkgtree"
-	"github.com/golang/dep/internal"
 	"github.com/pkg/errors"
 )
 
@@ -103,9 +101,9 @@ type ensureCommand struct {
 	overrides stringSlice
 }
 
-func (cmd *ensureCommand) Run(ctx *dep.Ctx, args []string) error {
+func (cmd *ensureCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
 	if cmd.examples {
-		internal.Logln(strings.TrimSpace(ensureExamples))
+		loggers.Err.Println(strings.TrimSpace(ensureExamples))
 		return nil
 	}
 
@@ -122,8 +120,8 @@ func (cmd *ensureCommand) Run(ctx *dep.Ctx, args []string) error {
 	defer sm.Release()
 
 	params := p.MakeParams()
-	if *verbose {
-		params.TraceLogger = log.New(os.Stderr, "", 0)
+	if loggers.Verbose {
+		params.TraceLogger = loggers.Err
 	}
 	params.RootPackageTree, err = pkgtree.ListPackages(p.AbsRoot, string(p.ImportRoot))
 	if err != nil {
@@ -137,7 +135,7 @@ func (cmd *ensureCommand) Run(ctx *dep.Ctx, args []string) error {
 	if cmd.update {
 		applyUpdateArgs(args, &params)
 	} else {
-		err := applyEnsureArgs(args, cmd.overrides, p, sm, &params)
+		err := applyEnsureArgs(loggers.Err, args, cmd.overrides, p, sm, &params)
 		if err != nil {
 			return err
 		}
@@ -170,7 +168,7 @@ func (cmd *ensureCommand) Run(ctx *dep.Ctx, args []string) error {
 		return err
 	}
 	if cmd.dryRun {
-		return sw.PrintPreparedActions()
+		return sw.PrintPreparedActions(loggers.Out)
 	}
 
 	return errors.Wrap(sw.Write(p.AbsRoot, sm, true), "grouped write of manifest, lock and vendor")
@@ -189,7 +187,7 @@ func applyUpdateArgs(args []string, params *gps.SolveParameters) {
 	}
 }
 
-func applyEnsureArgs(args []string, overrides stringSlice, p *dep.Project, sm gps.SourceManager, params *gps.SolveParameters) error {
+func applyEnsureArgs(logger *log.Logger, args []string, overrides stringSlice, p *dep.Project, sm gps.SourceManager, params *gps.SolveParameters) error {
 	var errs []error
 	for _, arg := range args {
 		pc, err := getProjectConstraint(arg, sm)
@@ -207,7 +205,7 @@ func applyEnsureArgs(args []string, overrides stringSlice, p *dep.Project, sm gp
 			// TODO(sdboyer): for this case - or just in general - do we want to
 			// add project args to the requires list temporarily for this run?
 			if _, has := p.Manifest.Dependencies[pc.Ident.ProjectRoot]; !has {
-				internal.Logf("No constraint or alternate source specified for %q, omitting from manifest", pc.Ident.ProjectRoot)
+				logger.Printf("dep: No constraint or alternate source specified for %q, omitting from manifest\n", pc.Ident.ProjectRoot)
 			}
 			// If it's already in the manifest, no need to log
 			continue

cmd/dep/hash_in.go

@@ -6,7 +6,6 @@ package main
 
 import (
 	"flag"
-	"fmt"
 
 	"github.com/golang/dep"
 	"github.com/golang/dep/gps"
@@ -24,7 +23,7 @@ func (cmd *hashinCommand) Register(fs *flag.FlagSet) {}
 
 type hashinCommand struct{}
 
-func (hashinCommand) Run(ctx *dep.Ctx, args []string) error {
+func (hashinCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
 	p, err := ctx.LoadProject("")
 	if err != nil {
 		return err
@@ -52,7 +51,6 @@ func (hashinCommand) Run(ctx *dep.Ctx, args []string) error {
 	if err != nil {
 		return errors.Wrap(err, "prepare solver")
 	}
-
-	fmt.Println(gps.HashingInputsAsString(s))
+	loggers.Out.Println(gps.HashingInputsAsString(s))
 	return nil
 }

cmd/dep/init.go

@@ -6,11 +6,10 @@ package main
 
 import (
 	"flag"
-	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 
 	"github.com/golang/dep"
 	"github.com/golang/dep/gps"
@@ -59,18 +58,14 @@ func trimPathPrefix(p1, p2 string) string {
 	return p1
 }
 
-func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
+func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
 	if len(args) > 1 {
 		return errors.Errorf("too many args (%d)", len(args))
 	}
 
 	var root string
 	if len(args) <= 0 {
-		wd, err := os.Getwd()
-		if err != nil {
-			return err
-		}
-		root = wd
+		root = ctx.WorkingDir
 	} else {
 		root = args[0]
 	}
@@ -99,20 +94,24 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	if err != nil {
 		return errors.Wrap(err, "determineProjectRoot")
 	}
-	internal.Vlogf("Finding dependencies for %q...", cpr)
+	if loggers.Verbose {
+		loggers.Err.Printf("dep: Finding dependencies for %q...\n", cpr)
+	}
 	pkgT, err := pkgtree.ListPackages(root, cpr)
 	if err != nil {
 		return errors.Wrap(err, "gps.ListPackages")
 	}
-	internal.Vlogf("Found %d dependencies.", len(pkgT.Packages))
+	if loggers.Verbose {
+		loggers.Err.Printf("dep: Found %d dependencies.\n", len(pkgT.Packages))
+	}
 	sm, err := ctx.SourceManager()
 	if err != nil {
 		return errors.Wrap(err, "getSourceManager")
 	}
 	sm.UseDefaultSignalHandling()
 	defer sm.Release()
 
-	pd, err := getProjectData(ctx, pkgT, cpr, sm)
+	pd, err := getProjectData(ctx, loggers, pkgT, cpr, sm)
 	if err != nil {
 		return err
 	}
@@ -145,7 +144,9 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	}
 
 	// Run solver with project versions found on disk
-	internal.Vlogf("Solving...")
+	if loggers.Verbose {
+		loggers.Err.Println("dep: Solving...")
+	}
 	params := gps.SolveParameters{
 		RootDir:         root,
 		RootPackageTree: pkgT,
@@ -154,9 +155,10 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 		ProjectAnalyzer: dep.Analyzer{},
 	}
 
-	if *verbose {
-		params.TraceLogger = log.New(os.Stderr, "", 0)
+	if loggers.Verbose {
+		params.TraceLogger = loggers.Err
 	}
+
 	s, err := gps.Prepare(params, sm)
 	if err != nil {
 		return errors.Wrap(err, "prepare solver")
@@ -188,7 +190,9 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 
 	l.Memo = s.HashInputs()
 
-	internal.Vlogf("Writing manifest and lock files.")
+	if loggers.Verbose {
+		loggers.Err.Println("dep: Writing manifest and lock files.")
+	}
 
 	sw, err := dep.NewSafeWriter(m, nil, l, dep.VendorAlways)
 	if err != nil {
@@ -273,27 +277,31 @@ type projectData struct {
 	ondisk       map[gps.ProjectRoot]gps.Version // projects that were found on disk
 }
 
-func getProjectData(ctx *dep.Ctx, pkgT pkgtree.PackageTree, cpr string, sm gps.SourceManager) (projectData, error) {
+func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cpr string, sm gps.SourceManager) (projectData, error) {
 	constraints := make(gps.ProjectConstraints)
 	dependencies := make(map[gps.ProjectRoot][]string)
 	packages := make(map[string]bool)
 	notondisk := make(map[gps.ProjectRoot]bool)
 	ondisk := make(map[gps.ProjectRoot]gps.Version)
 
+	var syncDepGroup sync.WaitGroup
 	syncDep := func(pr gps.ProjectRoot, sm gps.SourceManager) {
 		message := "Cached"
 		if err := sm.SyncSourceFor(gps.ProjectIdentifier{ProjectRoot: pr}); err != nil {
 			message = "Unable to cache"
 		}
-		fmt.Fprintf(os.Stderr, "%s %s\n", message, pr)
+		loggers.Err.Printf("%s %s\n", message, pr)
+		syncDepGroup.Done()
 	}
 
 	rm, _ := pkgT.ToReachMap(true, true, false, nil)
 	if len(rm) == 0 {
 		return projectData{}, nil
 	}
 
-	internal.Vlogf("Building dependency graph...")
+	if loggers.Verbose {
+		loggers.Err.Println("dep: Building dependency graph...")
+	}
 	// Exclude stdlib imports from the list returned from Flatten().
 	const omitStdlib = false
 	for _, ip := range rm.Flatten(omitStdlib) {
@@ -307,23 +315,30 @@ func getProjectData(ctx *dep.Ctx, pkgT pkgtree.PackageTree, cpr string, sm gps.S
 			dependencies[pr] = append(dependencies[pr], ip)
 			continue
 		}
+		syncDepGroup.Add(1)
 		go syncDep(pr, sm)
 
-		internal.Vlogf("Found import of %q, analyzing...", ip)
+		if loggers.Verbose {
+			loggers.Err.Printf("dep: Found import of %q, analyzing...\n", ip)
+		}
 
 		dependencies[pr] = []string{ip}
 		v, err := ctx.VersionInWorkspace(pr)
 		if err != nil {
 			notondisk[pr] = true
-			internal.Vlogf("Could not determine version for %q, omitting from generated manifest", pr)
+			if loggers.Verbose {
+				loggers.Err.Printf("dep: Could not determine version for %q, omitting from generated manifest\n", pr)
+			}
 			continue
 		}
 
 		ondisk[pr] = v
 		constraints[pr] = getProjectPropertiesFromVersion(v)
 	}
 
-	internal.Vlogf("Analyzing transitive imports...")
+	if loggers.Verbose {
+		loggers.Err.Printf("dep: Analyzing transitive imports...\n")
+	}
 	// Explore the packages we've found for transitive deps, either
 	// completing the lock or identifying (more) missing projects that we'll
 	// need to ask gps to solve for us.
@@ -342,7 +357,9 @@ func getProjectData(ctx *dep.Ctx, pkgT pkgtree.PackageTree, cpr string, sm gps.S
 	dft = func(pkg string) error {
 		switch colors[pkg] {
 		case white:
-			internal.Vlogf("Analyzing %q...", pkg)
+			if loggers.Verbose {
+				loggers.Err.Printf("dep: Analyzing %q...\n", pkg)
+			}
 			colors[pkg] = grey
 
 			pr, err := sm.DeduceProjectRoot(pkg)
@@ -424,6 +441,7 @@ func getProjectData(ctx *dep.Ctx, pkgT pkgtree.PackageTree, cpr string, sm gps.S
 				}
 			} else {
 				dependencies[pr] = []string{pkg}
+				syncDepGroup.Add(1)
 				go syncDep(pr, sm)
 			}
 
@@ -456,6 +474,8 @@ func getProjectData(ctx *dep.Ctx, pkgT pkgtree.PackageTree, cpr string, sm gps.S
 		}
 	}
 
+	syncDepGroup.Wait()
+
 	pd := projectData{
 		constraints:  constraints,
 		dependencies: dependencies,