| // Copyright 2017 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package dep |
| |
| import ( |
| "fmt" |
| "os" |
| "path/filepath" |
| "runtime" |
| "strings" |
| "testing" |
| |
| "github.com/golang/dep/gps" |
| "github.com/golang/dep/internal/test" |
| ) |
| |
| func TestFindRoot(t *testing.T) { |
| wd, err := os.Getwd() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| want := filepath.Join(wd, "testdata", "rootfind") |
| got1, err := findProjectRoot(want) |
| if err != nil { |
| t.Errorf("Unexpected error while finding root: %s", err) |
| } else if want != got1 { |
| t.Errorf("findProjectRoot directly on root dir should have found %s, got %s", want, got1) |
| } |
| |
| got2, err := findProjectRoot(filepath.Join(want, "subdir")) |
| if err != nil { |
| t.Errorf("Unexpected error while finding root: %s", err) |
| } else if want != got2 { |
| t.Errorf("findProjectRoot on subdir should have found %s, got %s", want, got2) |
| } |
| |
| got3, err := findProjectRoot(filepath.Join(want, "nonexistent")) |
| if err != nil { |
| t.Errorf("Unexpected error while finding root: %s", err) |
| } else if want != got3 { |
| t.Errorf("findProjectRoot on nonexistent subdir should still work and give %s, got %s", want, got3) |
| } |
| |
| root := "/" |
| p, err := findProjectRoot(root) |
| if p != "" { |
| t.Errorf("findProjectRoot with path %s returned non empty string: %s", root, p) |
| } |
| if err != errProjectNotFound { |
| t.Errorf("findProjectRoot want: %#v got: %#v", errProjectNotFound, err) |
| } |
| |
| // The following test does not work on windows because syscall.Stat does not |
| // return a "not a directory" error. |
| if runtime.GOOS != "windows" { |
| got4, err := findProjectRoot(filepath.Join(want, ManifestName)) |
| if err == nil { |
| t.Errorf("Should have err'd when trying subdir of file, but returned %s", got4) |
| } |
| } |
| } |
| |
| func TestCheckGopkgFilenames(t *testing.T) { |
| // We are trying to skip this test on file systems which are case-sensiive. We could |
| // have used `fs.IsCaseSensitiveFilesystem` for this check. However, the code we are |
| // testing also relies on `fs.IsCaseSensitiveFilesystem`. So a bug in |
| // `fs.IsCaseSensitiveFilesystem` could prevent this test from being run. This is the |
| // only scenario where we prefer the OS heuristic over doing the actual work of |
| // validating filesystem case sensitivity via `fs.IsCaseSensitiveFilesystem`. |
| if runtime.GOOS != "windows" && runtime.GOOS != "darwin" { |
| t.Skip("skip this test on non-Windows, non-macOS") |
| } |
| |
| errMsgFor := func(filetype, filename string) func(string) string { |
| return func(name string) string { |
| return fmt.Sprintf("%s filename %q does not match %q", filetype, name, filename) |
| } |
| } |
| |
| manifestErrMsg := errMsgFor("manifest", ManifestName) |
| lockErrMsg := errMsgFor("lock", LockName) |
| |
| invalidMfName := strings.ToLower(ManifestName) |
| invalidLfName := strings.ToLower(LockName) |
| |
| cases := []struct { |
| wantErr bool |
| createFiles []string |
| wantErrMsg string |
| }{ |
| // No error should be returned when the project contains a valid manifest file |
| // but no lock file. |
| {false, []string{ManifestName}, ""}, |
| // No error should be returned when the project contains a valid manifest file as |
| // well as a valid lock file. |
| {false, []string{ManifestName, LockName}, ""}, |
| // Error indicating the project was not found should be returned if a manifest |
| // file is not found. |
| {true, nil, errProjectNotFound.Error()}, |
| // Error should be returned if the project has a manifest file with invalid name |
| // but no lock file. |
| {true, []string{invalidMfName}, manifestErrMsg(invalidMfName)}, |
| // Error should be returned if the project has a valid manifest file and an |
| // invalid lock file. |
| {true, []string{ManifestName, invalidLfName}, lockErrMsg(invalidLfName)}, |
| } |
| |
| for _, c := range cases { |
| h := test.NewHelper(t) |
| defer h.Cleanup() |
| |
| // Create a temporary directory which we will use as the project folder. |
| h.TempDir("") |
| tmpPath := h.Path(".") |
| |
| // Create any files that are needed for the test before invoking |
| // `checkGopkgFilenames`. |
| for _, file := range c.createFiles { |
| h.TempFile(file, "") |
| } |
| err := checkGopkgFilenames(tmpPath) |
| |
| if c.wantErr { |
| if err == nil { |
| // We were expecting an error but did not get one. |
| t.Fatalf("unexpected error message: \n\t(GOT) nil\n\t(WNT) %s", c.wantErrMsg) |
| } else if err.Error() != c.wantErrMsg { |
| // We got an error but it is not the one we were expecting. |
| t.Fatalf("unexpected error message: \n\t(GOT) %s\n\t(WNT) %s", err.Error(), c.wantErrMsg) |
| } |
| } else if err != nil { |
| // Error was not expected but still we got one |
| t.Fatalf("unexpected error message: \n\t(GOT) %+v", err) |
| } |
| } |
| } |
| |
| func TestProjectMakeParams(t *testing.T) { |
| m := NewManifest() |
| m.Ignored = []string{"ignoring this"} |
| |
| p := Project{ |
| AbsRoot: "someroot", |
| ImportRoot: gps.ProjectRoot("Some project root"), |
| Manifest: m, |
| Lock: &Lock{}, |
| } |
| p.ChangedLock = p.Lock |
| |
| solveParam := p.MakeParams() |
| |
| if solveParam.Manifest != p.Manifest { |
| t.Error("makeParams() returned gps.SolveParameters with incorrect Manifest") |
| } |
| |
| if solveParam.Lock != p.Lock { |
| t.Error("makeParams() returned gps.SolveParameters with incorrect Lock") |
| } |
| } |
| |
| func TestBackupVendor(t *testing.T) { |
| h := test.NewHelper(t) |
| defer h.Cleanup() |
| |
| pc := NewTestProjectContext(h, "vendorbackupproject") |
| defer pc.Release() |
| |
| dummyFile := filepath.Join("vendor", "badinput_fileroot") |
| pc.CopyFile(dummyFile, "txn_writer/badinput_fileroot") |
| pc.Load() |
| |
| if err := pc.VendorShouldExist(); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Create a backup |
| wantName := "_vendor-sfx" |
| vendorbak, err := BackupVendor("vendor", "sfx") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if vendorbak != wantName { |
| t.Fatalf("Vendor backup name is not as expected: \n\t(GOT) %v\n\t(WNT) %v", vendorbak, wantName) |
| } |
| |
| if err = pc.h.ShouldExist(vendorbak); err != nil { |
| t.Fatal(err) |
| } |
| |
| if err = pc.h.ShouldExist(vendorbak + string(filepath.Separator) + "badinput_fileroot"); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Should return error on creating backup with existing filename |
| vendorbak, err = BackupVendor("vendor", "sfx") |
| |
| if err != errVendorBackupFailed { |
| t.Fatalf("Vendor backup error is not as expected: \n\t(GOT) %v\n\t(WNT) %v", err, errVendorBackupFailed) |
| } |
| |
| if vendorbak != "" { |
| t.Fatalf("Vendor backup name is not as expected: \n\t(GOT) %v\n\t(WNT) %v", vendorbak, "") |
| } |
| |
| // Delete vendor |
| if err = os.RemoveAll("vendor"); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Should return empty backup file name when no vendor exists |
| vendorbak, err = BackupVendor("vendor", "sfx") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if vendorbak != "" { |
| t.Fatalf("Vendor backup name is not as expected: \n\t(GOT) %v\n\t(WNT) %v", vendorbak, "") |
| } |
| } |
