vpython: Add VirtualEnv creation package.

vpython/venv/venv_test.go

+// Copyright 2017 The LUCI Authors. All rights reserved.
+// Use of this source code is governed under the Apache License, Version 2.0
+// that can be found in the LICENSE file.
+
+package venv
+
+import (
+        "encoding/json"
+        "fmt"
+        "io/ioutil"
+        "path/filepath"
+        "testing"
+
+        "github.com/luci/luci-go/vpython/api/vpython"
+        "github.com/luci/luci-go/vpython/filesystem"
+        "github.com/luci/luci-go/vpython/filesystem/testfs"
+        "github.com/luci/luci-go/vpython/python"
+
+        "github.com/luci/luci-go/common/errors"
+
+        "golang.org/x/net/context"
+
+        . "github.com/luci/luci-go/common/testing/assertions"
+        . "github.com/smartystreets/goconvey/convey"
+)
+
+type resolvedInterpreter struct {
+        i       *python.Interpreter
+        version python.Version
+}
+
+func resolveFromPath(vers python.Version) *resolvedInterpreter {
+        c := context.Background()
+        i, err := python.Find(c, vers)
+        if err != nil {
+                return nil
+        }
+        if err := filesystem.AbsPath(&i.Python); err != nil {
+                panic(err)
+        }
+
+        ri := resolvedInterpreter{
+                i: i,
+        }
+        if ri.version, err = ri.i.GetVersion(c); err != nil {
+                panic(err)
+        }
+        return &ri
+}
+
+var (
+        pythonGeneric = resolveFromPath(python.Version{})
+        python27      = resolveFromPath(python.Version{2, 7, 0})
+        python3       = resolveFromPath(python.Version{3, 0, 0})
+)
+
+func TestResolvePythonInterpreter(t *testing.T) {
+        t.Parallel()
+
+        Convey(`Resolving a Python interpreter`, t, func() {
+                c := context.Background()
+                cfg := Config{
+                        Spec: &vpython.Spec{},
+                }
+
+                // Tests to run if we have Python 2.7 installed.
+                if python27 != nil {
+                        Convey(`When Python 2.7 is requested, it gets resolved.`, func() {
+                                cfg.Spec.PythonVersion = "2.7"
+                                So(cfg.resolvePythonInterpreter(c), ShouldBeNil)
+                                So(cfg.Python, ShouldEqual, python27.i.Python)
+
+                                vers, err := python.ParseVersion(cfg.Spec.PythonVersion)
+                                So(err, ShouldBeNil)
+                                So(vers.IsSatisfiedBy(python27.version), ShouldBeTrue)
+                        })
+
+                        Convey(`Fails when Python 9999 is requested, but a Python 2 interpreter is forced.`, func() {
+                                cfg.Python = python27.i.Python
+                                cfg.Spec.PythonVersion = "9999"
+                                So(cfg.resolvePythonInterpreter(c), ShouldErrLike, "doesn't match specification")
+                        })
+                }
+
+                // Tests to run if we have Python 2.7 and a generic Python installed.
+                if pythonGeneric != nil && python27 != nil {
+                        // Our generic Python resolves to a known version, so we can proceed.
+                        Convey(`When no Python version is specified, spec resolves to generic.`, func() {
+                                So(cfg.resolvePythonInterpreter(c), ShouldBeNil)
+                                So(cfg.Python, ShouldEqual, pythonGeneric.i.Python)
+
+                                vers, err := python.ParseVersion(cfg.Spec.PythonVersion)
+                                So(err, ShouldBeNil)
+                                So(vers.IsSatisfiedBy(pythonGeneric.version), ShouldBeTrue)
+                        })
+                }
+
+                // Tests to run if we have Python 3 installed.
+                if python3 != nil {
+                        Convey(`When Python 3 is requested, it gets resolved.`, func() {
+                                cfg.Spec.PythonVersion = "3"
+                                So(cfg.resolvePythonInterpreter(c), ShouldBeNil)
+                                So(cfg.Python, ShouldEqual, python3.i.Python)
+
+                                vers, err := python.ParseVersion(cfg.Spec.PythonVersion)
+                                So(err, ShouldBeNil)
+                                So(vers.IsSatisfiedBy(python3.version), ShouldBeTrue)
+                        })
+
+                        Convey(`Fails when Python 9999 is requested, but a Python 3 interpreter is forced.`, func() {
+                                cfg.Python = python3.i.Python
+                                cfg.Spec.PythonVersion = "9999"
+                                So(cfg.resolvePythonInterpreter(c), ShouldErrLike, "doesn't match specification")
+                        })
+                }
+        })
+}
+
+type setupCheckManifest struct {
+        Interpreter string `json:"interpreter"`
+        Pants       string `json:"pants"`
+        Shirt       string `json:"shirt"`
+}
+
+func testVirtualEnvWith(t *testing.T, py *python.Interpreter) {
+        t.Parallel()
+
+        if py == nil {
+                t.Skipf("No python interpreter found.")
+        }
+
+        tl, err := loadTestEnvironment(context.Background(), t)
+        if err != nil {
+                t.Fatalf("could not set up test loader for %q: %s", py.Python, err)
+        }
+
+        Convey(`Testing Setup`, t, testfs.MustWithTempDir(t, "TestVirtualEnv", func(tdir string) {
+                c := context.Background()
+                config := Config{
+                        BaseDir:    tdir,
+                        MaxHashLen: 4,
+                        Package: vpython.Spec_Package{
+                                Path:    "foo/bar/virtualenv",
+                                Version: "unresolved",
+                        },
+                        Python: py.Python,
+                        Spec: &vpython.Spec{
+                                Wheel: []*vpython.Spec_Package{
+                                        {Path: "foo/bar/shirt", Version: "unresolved"},
+                                        {Path: "foo/bar/pants", Version: "unresolved"},
+                                },
+                        },
+                        Loader: tl,
+                }
+
+                // Load the bootstrap wheels for the next part of the test.
+                So(tl.ensureWheels(c, t, py, tdir), ShouldBeNil)
+
+                err := With(c, config, false, func(c context.Context, v *Env) error {
+                        testScriptPath := filepath.Join(testDataDir, "setup_check.py")
+                        checkOut := filepath.Join(tdir, "output.json")
+                        i := v.InterpreterCommand()
+                        So(i.Run(c, testScriptPath, "--json-output", checkOut), ShouldBeNil)
+
+                        var m setupCheckManifest
+                        So(loadJSON(checkOut, &m), ShouldBeNil)
+                        So(m.Interpreter, ShouldStartWith, v.Root)
+                        So(m.Pants, ShouldStartWith, v.Root)
+                        So(m.Shirt, ShouldStartWith, v.Root)
+
+                        // We should be able to delete it.
+                        So(v.Delete(c), ShouldBeNil)
+                        return nil
+                })
+                So(err, ShouldBeNil)
+        }))
+}
+
+func TestVirtualEnv(t *testing.T) {
+        t.Parallel()
+
+        for _, tc := range []struct {
+                name string
+                ri   *resolvedInterpreter
+        }{
+                {"python27", python27},
+                {"python3", python3},
+        } {
+                tc := tc
+
+                t.Run(fmt.Sprintf(`Testing Virtualenv for: %s`, tc.name), func(t *testing.T) {
+                        testVirtualEnvWith(t, tc.ri.i)
+                })
+        }
+}
+
+func loadJSON(path string, dst interface{}) error {
+        content, err := ioutil.ReadFile(path)
+        if err != nil {
+                return errors.Annotate(err).Reason("failed to open file").Err()
+        }
+        if err := json.Unmarshal(content, dst); err != nil {
+                return errors.Annotate(err).Reason("failed to unmarshal JSON").Err()
+        }
+        return nil
+}