golang/dep

// 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"
    "io/ioutil"
    "log"
    "os"
    "path/filepath"
    "runtime"
    "strings"
    "testing"
    "unicode"

    "github.com/golang/dep/internal/test"
)

func discardLogger() *log.Logger {
    return log.New(ioutil.Discard, "", 0)
}

func TestCtx_ProjectImport(t *testing.T) {
    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir("src")

    h.Setenv("GOPATH", h.Path("."))
    depCtx := &Ctx{GOPATH: h.Path(".")}

    importPaths := []string{
        "github.com/pkg/errors",
        "my/silly/thing",
    }

    for _, want := range importPaths {
        fullpath := filepath.Join(depCtx.GOPATH, "src", want)
        h.TempDir(filepath.Join("src", want))
        got, err := depCtx.ImportForAbs(fullpath)
        if err != nil {
            t.Fatal(err)
        }
        if got != want {
            t.Fatalf("expected %s, got %s", want, got)
        }
    }

    // test where it should return an error when directly within $GOPATH/src
    got, err := depCtx.ImportForAbs(filepath.Join(depCtx.GOPATH, "src"))
    if err == nil || !strings.Contains(err.Error(), "GOPATH/src") {
        t.Fatalf("should have gotten an error for use directly in GOPATH/src, but got %s", got)
    }

    // test where it should return an error
    got, err = depCtx.ImportForAbs("tra/la/la/la")
    if err == nil {
        t.Fatalf("should have gotten an error but did not for tra/la/la/la: %s", got)
    }
}

func TestAbsoluteProjectRoot(t *testing.T) {
    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir("src")
    h.Setenv("GOPATH", h.Path("."))
    depCtx := &Ctx{GOPATH: h.Path(".")}

    importPaths := map[string]bool{
        "github.com/pkg/errors": true,
        "my/silly/thing":        false,
    }

    for i, create := range importPaths {
        if create {
            h.TempDir(filepath.Join("src", i))
        }
    }

    for i, ok := range importPaths {
        got, err := depCtx.AbsForImport(i)
        if ok {
            h.Must(err)
            want := h.Path(filepath.Join("src", i))
            if got != want {
                t.Fatalf("expected %s, got %q", want, got)
            }
            continue
        }

        if err == nil {
            t.Fatalf("expected %s to fail", i)
        }
    }

    // test that a file fails
    h.TempFile("src/thing/thing.go", "hello world")
    _, err := depCtx.AbsForImport("thing/thing.go")
    if err == nil {
        t.Fatal("error should not be nil for a file found")
    }
}

func TestLoadProject(t *testing.T) {
    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir(filepath.Join("src", "test1", "sub"))
    h.TempFile(filepath.Join("src", "test1", ManifestName), "")
    h.TempFile(filepath.Join("src", "test1", LockName), `memo = "cdafe8641b28cd16fe025df278b0a49b9416859345d8b6ba0ace0272b74925ee"`)
    h.TempDir(filepath.Join("src", "test2", "sub"))
    h.TempFile(filepath.Join("src", "test2", ManifestName), "")

    var testcases = []struct {
        name string
        lock bool
        wd   string
    }{
        {"direct", true, filepath.Join("src", "test1")},
        {"ascending", true, filepath.Join("src", "test1", "sub")},
        {"without lock", false, filepath.Join("src", "test2")},
        {"ascending without lock", false, filepath.Join("src", "test2", "sub")},
    }

    for _, tc := range testcases {
        t.Run(tc.name, func(t *testing.T) {
            ctx := &Ctx{
                Out: discardLogger(),
                Err: discardLogger(),
            }

            err := ctx.SetPaths(h.Path(tc.wd), h.Path("."))
            if err != nil {
                t.Fatalf("%+v", err)
            }

            p, err := ctx.LoadProject()
            switch {
            case err != nil:
                t.Fatalf("%s: LoadProject failed: %+v", tc.wd, err)
            case p.Manifest == nil:
                t.Fatalf("%s: Manifest file didn't load", tc.wd)
            case tc.lock && p.Lock == nil:
                t.Fatalf("%s: Lock file didn't load", tc.wd)
            case !tc.lock && p.Lock != nil:
                t.Fatalf("%s: Non-existent Lock file loaded", tc.wd)
            }
        })
    }
}

func TestExplicitRootProject(t *testing.T) {
    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir(filepath.Join("src", "test1", "sub"))
    h.TempFile(filepath.Join("src", "test1", ManifestName), "")
    h.TempFile(filepath.Join("src", "test1", LockName), `memo = "cdafe8641b28cd16fe025df278b0a49b9416859345d8b6ba0ace0272b74925ee"`)
    h.TempDir(filepath.Join("src", "test2", "sub"))
    h.TempFile(filepath.Join("src", "test2", ManifestName), "")
    h.Setenv("DEP_PROJECT_ROOT", "github.com/user/module")

    type tcase struct {
        name string
        lock bool
        wd   string
    }
    var testcases = []tcase{
        {"direct", true, filepath.Join("src", "test1")},
        {"ascending", true, filepath.Join("src", "test1", "sub")},
        {"without lock", false, filepath.Join("src", "test2")},
        {"ascending without lock", false, filepath.Join("src", "test2", "sub")},
    }

    tf := func(withGOPATH bool, tc tcase, t *testing.T) func(t *testing.T) {
        return func(t *testing.T) {
            ctx := &Ctx{
                Out: discardLogger(),
                Err: discardLogger(),
            }

            var err error
            if withGOPATH {
                err = ctx.SetPaths(h.Path(tc.wd), h.Path("."))
            } else {
                err = ctx.SetPaths(h.Path(tc.wd))
            }
            if err != nil {
                t.Fatalf("%+v", err)
            }
            ctx.ExplicitRoot = "github.com/user/module"

            p, err := ctx.LoadProject()
            switch {
            case err != nil:
                t.Fatalf("%s: LoadProject failed: %+v", tc.wd, err)
            case p.Manifest == nil:
                t.Fatalf("%s: Manifest file didn't load", tc.wd)
            case tc.lock && p.Lock == nil:
                t.Fatalf("%s: Lock file didn't load", tc.wd)
            case !tc.lock && p.Lock != nil:
                t.Fatalf("%s: Non-existent Lock file loaded", tc.wd)
            }
        }
    }

    for _, tc := range testcases {
        t.Run(tc.name, func(t *testing.T) {
            t.Run("within-GOPATH", tf(true, tc, t))
            t.Run("outside-GOPATH", tf(false, tc, t))
        })
    }
}

func TestLoadProjectNotFoundErrors(t *testing.T) {
    tg := test.NewHelper(t)
    defer tg.Cleanup()

    tg.TempDir("src")
    tg.TempDir("src/test1")
    tg.TempDir("src/test1/sub")
    tg.Setenv("GOPATH", tg.Path("."))

    var testcases = []struct {
        lock  bool
        start string
        path  string
    }{
        {true, filepath.Join("src", "test1"), ""},        //direct
        {true, filepath.Join("src", "test1", "sub"), ""}, //ascending
    }

    for _, testcase := range testcases {
        ctx := &Ctx{GOPATHs: []string{tg.Path(".")}, WorkingDir: tg.Path(testcase.start)}

        _, err := ctx.LoadProject()
        if err == nil {
            t.Errorf("%s: should have returned 'No Manifest Found' error", testcase.start)
        }
    }
}

func TestLoadProjectManifestParseError(t *testing.T) {
    tg := test.NewHelper(t)
    defer tg.Cleanup()

    tg.TempDir("src")
    tg.TempDir("src/test1")
    tg.TempFile(filepath.Join("src/test1", ManifestName), `[[constraint]]`)
    tg.TempFile(filepath.Join("src/test1", LockName), `memo = "cdafe8641b28cd16fe025df278b0a49b9416859345d8b6ba0ace0272b74925ee"\n\n[[projects]]`)
    tg.Setenv("GOPATH", tg.Path("."))

    path := filepath.Join("src", "test1")
    tg.Cd(tg.Path(path))

    wd, err := os.Getwd()
    if err != nil {
        t.Fatal("failed to get working directory", err)
    }

    ctx := &Ctx{
        GOPATH:     tg.Path("."),
        WorkingDir: wd,
        Out:        discardLogger(),
        Err:        discardLogger(),
    }

    _, err = ctx.LoadProject()
    if err == nil {
        t.Fatal("should have returned 'Manifest Syntax' error")
    }
}

func TestLoadProjectLockParseError(t *testing.T) {
    tg := test.NewHelper(t)
    defer tg.Cleanup()

    tg.TempDir("src")
    tg.TempDir("src/test1")
    tg.TempFile(filepath.Join("src/test1", ManifestName), `[[constraint]]`)
    tg.TempFile(filepath.Join("src/test1", LockName), `memo = "cdafe8641b28cd16fe025df278b0a49b9416859345d8b6ba0ace0272b74925ee"\n\n[[projects]]`)
    tg.Setenv("GOPATH", tg.Path("."))

    path := filepath.Join("src", "test1")
    tg.Cd(tg.Path(path))

    wd, err := os.Getwd()
    if err != nil {
        t.Fatal("failed to get working directory", err)
    }

    ctx := &Ctx{
        GOPATH:     tg.Path("."),
        WorkingDir: wd,
        Out:        discardLogger(),
        Err:        discardLogger(),
    }

    _, err = ctx.LoadProject()
    if err == nil {
        t.Fatal("should have returned 'Lock Syntax' error")
    }
}

func TestLoadProjectNoSrcDir(t *testing.T) {
    tg := test.NewHelper(t)
    defer tg.Cleanup()

    tg.TempDir("test1")
    tg.TempFile(filepath.Join("test1", ManifestName), `[[constraint]]`)
    tg.TempFile(filepath.Join("test1", LockName), `memo = "cdafe8641b28cd16fe025df278b0a49b9416859345d8b6ba0ace0272b74925ee"\n\n[[projects]]`)
    tg.Setenv("GOPATH", tg.Path("."))

    ctx := &Ctx{GOPATH: tg.Path(".")}
    path := filepath.Join("test1")
    tg.Cd(tg.Path(path))

    f, _ := os.OpenFile(filepath.Join(ctx.GOPATH, "src", "test1", LockName), os.O_WRONLY, os.ModePerm)
    defer f.Close()

    _, err := ctx.LoadProject()
    if err == nil {
        t.Fatal("should have returned 'Split Absolute Root' error (no 'src' dir present)")
    }
}

func TestLoadProjectGopkgFilenames(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")
    }

    // Here we test that a manifest filename with incorrect case throws an error. Similar
    // error will also be thrown for the lock file as well which has been tested in
    // `project_test.go#TestCheckGopkgFilenames`. So not repeating here.

    h := test.NewHelper(t)
    defer h.Cleanup()

    invalidMfName := strings.ToLower(ManifestName)

    wd := filepath.Join("src", "test")
    h.TempFile(filepath.Join(wd, invalidMfName), "")

    ctx := &Ctx{
        Out: discardLogger(),
        Err: discardLogger(),
    }

    err := ctx.SetPaths(h.Path(wd), h.Path("."))
    if err != nil {
        t.Fatalf("%+v", err)
    }

    _, err = ctx.LoadProject()

    if err == nil {
        t.Fatal("should have returned 'Manifest Filename' error")
    }

    expectedErrMsg := fmt.Sprintf(
        "manifest filename %q does not match %q",
        invalidMfName, ManifestName,
    )

    if err.Error() != expectedErrMsg {
        t.Fatalf("unexpected error: %+v", err)
    }
}

// TestCaseInsensitive is test for Windows. This should work even though set
// difference letter cases in GOPATH.
func TestCaseInsensitiveGOPATH(t *testing.T) {
    if runtime.GOOS != "windows" {
        t.Skip("skip this test on non-Windows")
    }

    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir("src")
    h.TempDir("src/test1")
    h.TempFile(filepath.Join("src/test1", ManifestName), `
    [[constraint]]
        name = "github.com/foo/bar"
        branch = "master"`)

    // Shuffle letter case
    rs := []rune(strings.ToLower(h.Path(".")))
    for i, r := range rs {
        if unicode.IsLower(r) {
            rs[i] = unicode.ToUpper(r)
        } else {
            rs[i] = unicode.ToLower(r)
        }
    }
    gopath := string(rs)
    h.Setenv("GOPATH", gopath)
    wd := h.Path("src/test1")

    depCtx := &Ctx{}
    if err := depCtx.SetPaths(wd, gopath); err != nil {
        t.Fatal(err)
    }
    if _, err := depCtx.LoadProject(); err != nil {
        t.Fatal(err)
    }

    ip := "github.com/pkg/errors"
    fullpath := filepath.Join(depCtx.GOPATH, "src", ip)
    h.TempDir(filepath.Join("src", ip))
    pr, err := depCtx.ImportForAbs(fullpath)
    if err != nil {
        t.Fatal(err)
    }
    if pr != ip {
        t.Fatalf("expected %s, got %s", ip, pr)
    }
}

func TestDetectProjectGOPATH(t *testing.T) {
    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir(filepath.Join("sym", "symlink"))
    h.TempDir(filepath.Join("go", "src", "sym", "path"))
    h.TempDir(filepath.Join("go", "src", "real", "path"))
    h.TempDir(filepath.Join("go-two", "src", "real", "path"))
    h.TempDir(filepath.Join("go-two", "src", "sym"))

    ctx := &Ctx{
        GOPATHs: []string{h.Path("go"), h.Path("go-two")},
    }

    testcases := []struct {
        name         string
        root         string
        resolvedRoot string
        GOPATH       string
        expectErr    bool
    }{
        {
            name:         "project-with-no-AbsRoot",
            root:         "",
            resolvedRoot: filepath.Join(ctx.GOPATHs[0], "src", "real", "path"),
            expectErr:    true,
        },
        {
            name:         "project-with-no-ResolvedAbsRoot",
            root:         filepath.Join(ctx.GOPATHs[0], "src", "real", "path"),
            resolvedRoot: "",
            expectErr:    true,
        },
        {
            name:         "AbsRoot-is-not-within-any-GOPATH",
            root:         filepath.Join(h.Path("."), "src", "real", "path"),
            resolvedRoot: filepath.Join(h.Path("."), "src", "real", "path"),
            expectErr:    true,
        },
        {
            name:         "neither-AbsRoot-nor-ResolvedAbsRoot-are-in-any-GOPATH",
            root:         filepath.Join(h.Path("."), "src", "sym", "path"),
            resolvedRoot: filepath.Join(h.Path("."), "src", "real", "path"),
            expectErr:    true,
        },
        {
            name:         "both-AbsRoot-and-ResolvedAbsRoot-are-in-the-same-GOPATH",
            root:         filepath.Join(ctx.GOPATHs[0], "src", "sym", "path"),
            resolvedRoot: filepath.Join(ctx.GOPATHs[0], "src", "real", "path"),
            expectErr:    true,
        },
        {
            name:         "AbsRoot-and-ResolvedAbsRoot-are-each-within-a-different-GOPATH",
            root:         filepath.Join(ctx.GOPATHs[0], "src", "sym", "path"),
            resolvedRoot: filepath.Join(ctx.GOPATHs[1], "src", "real", "path"),
            expectErr:    true,
        },
        {
            name:         "AbsRoot-is-not-a-symlink",
            root:         filepath.Join(ctx.GOPATHs[0], "src", "real", "path"),
            resolvedRoot: filepath.Join(ctx.GOPATHs[0], "src", "real", "path"),
            GOPATH:       ctx.GOPATHs[0],
        },
        {
            name:         "AbsRoot-is-a-symlink-to-ResolvedAbsRoot",
            root:         filepath.Join(h.Path("."), "sym", "symlink"),
            resolvedRoot: filepath.Join(ctx.GOPATHs[0], "src", "real", "path"),
            GOPATH:       ctx.GOPATHs[0],
        },
    }

    for _, tc := range testcases {
        t.Run(tc.name, func(t *testing.T) {
            project := &Project{
                AbsRoot:         tc.root,
                ResolvedAbsRoot: tc.resolvedRoot,
            }

            GOPATH, err := ctx.DetectProjectGOPATH(project)
            if !tc.expectErr && err != nil {
                t.Fatalf("%+v", err)
            } else if tc.expectErr && err == nil {
                t.Fatalf("expected an error, got nil and gopath %s", GOPATH)
            }
            if GOPATH != tc.GOPATH {
                t.Errorf("expected GOPATH %s, got %s", tc.GOPATH, GOPATH)
            }
        })
    }
}

func TestDetectGOPATH(t *testing.T) {
    th := test.NewHelper(t)
    defer th.Cleanup()

    th.TempDir(filepath.Join("code", "src", "github.com", "username", "package"))
    th.TempDir(filepath.Join("go", "src", "github.com", "username", "package"))
    th.TempDir(filepath.Join("gotwo", "src", "github.com", "username", "package"))
    th.TempDir(filepath.Join("gothree", "sep", "src", "github.com", "username", "package"))

    sep := string(os.PathSeparator)

    ctx := &Ctx{GOPATHs: []string{
        th.Path("go"),
        th.Path("gotwo"),
        th.Path("gothree") + sep + sep + "sep",
    }}

    testcases := []struct {
        GOPATH string
        path   string
        err    bool
    }{
        {th.Path("go"), th.Path(filepath.Join("go", "src", "github.com", "username", "package")), false},
        {th.Path("go"), th.Path(filepath.Join("go", "src", "github.com", "username", "package")), false},
        {th.Path("gotwo"), th.Path(filepath.Join("gotwo", "src", "github.com", "username", "package")), false},
        {th.Path(filepath.Join("gothree", "sep")),
            th.Path(filepath.Join("gothree", "sep", "src", "github.com", "username", "package")), false},
        {"", th.Path(filepath.Join("code", "src", "github.com", "username", "package")), true},
    }

    for _, tc := range testcases {
        GOPATH, err := ctx.detectGOPATH(tc.path)
        if tc.err && err == nil {
            t.Error("expected error but got none")
        }
        if GOPATH != tc.GOPATH {
            t.Errorf("expected GOPATH to be %s, got %s", tc.GOPATH, GOPATH)
        }
    }
}

func TestDepCachedir(t *testing.T) {
    h := test.NewHelper(t)
    defer h.Cleanup()

    h.TempDir("cache")
    // Create the directory for default cachedir location.
    h.TempDir(filepath.Join("go", "pkg", "dep"))

    testCachedir := h.Path("cache")
    gopath := h.Path("go")
    discardLgr := discardLogger()

    cases := []struct {
        cachedir     string
        wantCachedir string
    }{
        // If `Cachedir` is not set in the context, it should use `$GOPATH/pkg/dep`.
        {cachedir: "", wantCachedir: h.Path(filepath.Join("go", "pkg", "dep"))},
        // If `Cachedir` is set in the context, it should use that.
        {cachedir: testCachedir, wantCachedir: testCachedir},
    }

    for _, c := range cases {
        ctx := &Ctx{
            GOPATH:   gopath,
            Cachedir: c.cachedir,
            Out:      discardLgr,
            Err:      discardLgr,
        }
        sm, err := ctx.SourceManager()
        h.Must(err)
        defer sm.Release()

        if sm.Cachedir() != c.wantCachedir {
            t.Errorf("expected cachedir to be %s, got %s", c.wantCachedir, sm.Cachedir())
        }
    }
}