diff --git a/internal/gps/solve_test.go b/internal/gps/solve_test.go index b2ccc087d3..6713dfecf3 100644 --- a/internal/gps/solve_test.go +++ b/internal/gps/solve_test.go @@ -8,17 +8,12 @@ import ( "bytes" "flag" "fmt" - "io/ioutil" "log" - "math/rand" "reflect" "sort" - "strconv" "strings" "testing" "unicode" - - "github.com/golang/dep/internal/gps/pkgtree" ) var fixtorun string @@ -292,150 +287,3 @@ func TestRootLockNoVersionPairMatching(t *testing.T) { fixtureSolveSimpleChecks(fix, res, err, t) } - -// TestBadSolveOpts exercises the different possible inputs to a solver that can -// be determined as invalid in Prepare(), without any further work -func TestBadSolveOpts(t *testing.T) { - pn := strconv.FormatInt(rand.Int63(), 36) - fix := basicFixtures["no dependencies"] - fix.ds[0].n = ProjectRoot(pn) - - sm := newdepspecSM(fix.ds, nil) - params := SolveParameters{ - mkBridgeFn: overrideMkBridge, - } - - _, err := Prepare(params, nil) - if err == nil { - t.Errorf("Prepare should have errored on nil SourceManager") - } else if !strings.Contains(err.Error(), "non-nil SourceManager") { - t.Error("Prepare should have given error on nil SourceManager, but gave:", err) - } - - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Prepare should have errored without ProjectAnalyzer") - } else if !strings.Contains(err.Error(), "must provide a ProjectAnalyzer") { - t.Error("Prepare should have given error without ProjectAnalyzer, but gave:", err) - } - - params.ProjectAnalyzer = naiveAnalyzer{} - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Prepare should have errored on empty root") - } else if !strings.Contains(err.Error(), "non-empty root directory") { - t.Error("Prepare should have given error on empty root, but gave:", err) - } - - params.RootDir = pn - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Prepare should have errored on empty name") - } else if !strings.Contains(err.Error(), "non-empty import root") { - t.Error("Prepare should have given error on empty import root, but gave:", err) - } - - params.RootPackageTree = pkgtree.PackageTree{ - ImportRoot: pn, - } - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Prepare should have errored on empty name") - } else if !strings.Contains(err.Error(), "at least one package") { - t.Error("Prepare should have given error on empty import root, but gave:", err) - } - - params.RootPackageTree = pkgtree.PackageTree{ - ImportRoot: pn, - Packages: map[string]pkgtree.PackageOrErr{ - pn: { - P: pkgtree.Package{ - ImportPath: pn, - Name: pn, - }, - }, - }, - } - params.TraceLogger = log.New(ioutil.Discard, "", 0) - - params.Manifest = simpleRootManifest{ - ovr: ProjectConstraints{ - ProjectRoot("foo"): ProjectProperties{}, - }, - } - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on override with empty ProjectProperties") - } else if !strings.Contains(err.Error(), "foo, but without any non-zero properties") { - t.Error("Prepare should have given error override with empty ProjectProperties, but gave:", err) - } - - params.Manifest = simpleRootManifest{ - ig: map[string]bool{"foo": true}, - req: map[string]bool{"foo": true}, - } - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on pkg both ignored and required") - } else if !strings.Contains(err.Error(), "was given as both a required and ignored package") { - t.Error("Prepare should have given error with single ignore/require conflict error, but gave:", err) - } - - params.Manifest = simpleRootManifest{ - ig: map[string]bool{"foo": true, "bar": true}, - req: map[string]bool{"foo": true, "bar": true}, - } - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on pkg both ignored and required") - } else if !strings.Contains(err.Error(), "multiple packages given as both required and ignored:") { - t.Error("Prepare should have given error with multiple ignore/require conflict error, but gave:", err) - } - params.Manifest = nil - - params.ToChange = []ProjectRoot{"foo"} - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on non-empty ToChange without a lock provided") - } else if !strings.Contains(err.Error(), "update specifically requested for") { - t.Error("Prepare should have given error on ToChange without Lock, but gave:", err) - } - - params.Lock = safeLock{ - p: []LockedProject{ - NewLockedProject(mkPI("bar"), Revision("makebelieve"), nil), - }, - } - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on ToChange containing project not in lock") - } else if !strings.Contains(err.Error(), "cannot update foo as it is not in the lock") { - t.Error("Prepare should have given error on ToChange with item not present in Lock, but gave:", err) - } - - params.Lock, params.ToChange = nil, nil - _, err = Prepare(params, sm) - if err != nil { - t.Error("Basic conditions satisfied, prepare should have completed successfully, err as:", err) - } - - // swap out the test mkBridge override temporarily, just to make sure we get - // the right error - params.mkBridgeFn = nil - - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on nonexistent root") - } else if !strings.Contains(err.Error(), "could not read project root") { - t.Error("Prepare should have given error nonexistent project root dir, but gave:", err) - } - - // Pointing it at a file should also be an err - params.RootDir = "solve_test.go" - _, err = Prepare(params, sm) - if err == nil { - t.Errorf("Should have errored on file for RootDir") - } else if !strings.Contains(err.Error(), "is a file, not a directory") { - t.Error("Prepare should have given error on file as RootDir, but gave:", err) - } -} diff --git a/internal/gps/solver.go b/internal/gps/solver.go index c2354fbc38..ea8573d501 100644 --- a/internal/gps/solver.go +++ b/internal/gps/solver.go @@ -402,7 +402,6 @@ func ValidateParams(params SolveParameters, sm SourceManager) error { } deducePkg := func(ip string, sm SourceManager) { - fmt.Println(ip) _, err := sm.DeduceProjectRoot(ip) if err != nil { errsMut.Lock() diff --git a/internal/gps/solver_inputs_test.go b/internal/gps/solver_inputs_test.go index f0032a154d..b6aad11f2a 100644 --- a/internal/gps/solver_inputs_test.go +++ b/internal/gps/solver_inputs_test.go @@ -5,12 +5,164 @@ package gps import ( + "io/ioutil" + "log" + "math/rand" + "strconv" + "strings" "testing" "github.com/golang/dep/internal/gps/pkgtree" "github.com/golang/dep/internal/test" ) +// TestBadSolveOpts exercises the different possible inputs to a solver that can +// be determined as invalid in Prepare(), without any further work +func TestBadSolveOpts(t *testing.T) { + pn := strconv.FormatInt(rand.Int63(), 36) + fix := basicFixtures["no dependencies"] + fix.ds[0].n = ProjectRoot(pn) + + sm := newdepspecSM(fix.ds, nil) + params := SolveParameters{ + mkBridgeFn: overrideMkBridge, + } + + _, err := Prepare(params, nil) + if err == nil { + t.Errorf("Prepare should have errored on nil SourceManager") + } else if !strings.Contains(err.Error(), "non-nil SourceManager") { + t.Error("Prepare should have given error on nil SourceManager, but gave:", err) + } + + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Prepare should have errored without ProjectAnalyzer") + } else if !strings.Contains(err.Error(), "must provide a ProjectAnalyzer") { + t.Error("Prepare should have given error without ProjectAnalyzer, but gave:", err) + } + + params.ProjectAnalyzer = naiveAnalyzer{} + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Prepare should have errored on empty root") + } else if !strings.Contains(err.Error(), "non-empty root directory") { + t.Error("Prepare should have given error on empty root, but gave:", err) + } + + params.RootDir = pn + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Prepare should have errored on empty name") + } else if !strings.Contains(err.Error(), "non-empty import root") { + t.Error("Prepare should have given error on empty import root, but gave:", err) + } + + params.RootPackageTree = pkgtree.PackageTree{ + ImportRoot: pn, + } + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Prepare should have errored on empty name") + } else if !strings.Contains(err.Error(), "at least one package") { + t.Error("Prepare should have given error on empty import root, but gave:", err) + } + + params.RootPackageTree = pkgtree.PackageTree{ + ImportRoot: pn, + Packages: map[string]pkgtree.PackageOrErr{ + pn: { + P: pkgtree.Package{ + ImportPath: pn, + Name: pn, + }, + }, + }, + } + params.TraceLogger = log.New(ioutil.Discard, "", 0) + + params.Manifest = simpleRootManifest{ + ovr: ProjectConstraints{ + ProjectRoot("foo"): ProjectProperties{}, + }, + } + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on override with empty ProjectProperties") + } else if !strings.Contains(err.Error(), "foo, but without any non-zero properties") { + t.Error("Prepare should have given error override with empty ProjectProperties, but gave:", err) + } + + params.Manifest = simpleRootManifest{ + ig: map[string]bool{"foo": true}, + req: map[string]bool{"foo": true}, + } + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on pkg both ignored and required") + } else if !strings.Contains(err.Error(), "was given as both a required and ignored package") { + t.Error("Prepare should have given error with single ignore/require conflict error, but gave:", err) + } + + params.Manifest = simpleRootManifest{ + ig: map[string]bool{"foo": true, "bar": true}, + req: map[string]bool{"foo": true, "bar": true}, + } + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on pkg both ignored and required") + } else if !strings.Contains(err.Error(), "multiple packages given as both required and ignored:") { + t.Error("Prepare should have given error with multiple ignore/require conflict error, but gave:", err) + } + params.Manifest = nil + + params.ToChange = []ProjectRoot{"foo"} + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on non-empty ToChange without a lock provided") + } else if !strings.Contains(err.Error(), "update specifically requested for") { + t.Error("Prepare should have given error on ToChange without Lock, but gave:", err) + } + + params.Lock = safeLock{ + p: []LockedProject{ + NewLockedProject(mkPI("bar"), Revision("makebelieve"), nil), + }, + } + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on ToChange containing project not in lock") + } else if !strings.Contains(err.Error(), "cannot update foo as it is not in the lock") { + t.Error("Prepare should have given error on ToChange with item not present in Lock, but gave:", err) + } + + params.Lock, params.ToChange = nil, nil + _, err = Prepare(params, sm) + if err != nil { + t.Error("Basic conditions satisfied, prepare should have completed successfully, err as:", err) + } + + // swap out the test mkBridge override temporarily, just to make sure we get + // the right error + params.mkBridgeFn = nil + + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on nonexistent root") + } else if !strings.Contains(err.Error(), "could not read project root") { + t.Error("Prepare should have given error nonexistent project root dir, but gave:", err) + } + + // Pointing it at a file should also be an err + params.RootDir = "solve_test.go" + _, err = Prepare(params, sm) + if err == nil { + t.Errorf("Should have errored on file for RootDir") + } else if !strings.Contains(err.Error(), "is a file, not a directory") { + t.Error("Prepare should have given error on file as RootDir, but gave:", err) + } +} + func TestValidateParams(t *testing.T) { h := test.NewHelper(t) defer h.Cleanup()