vpython: Add primary execution package.

vpython/python/python_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 python
 
 import (
         "fmt"
         "os"
         "os/exec"
         "testing"
 
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestParsePythonCommandLine(t *testing.T) {
         t.Parallel()
 
         successes := []struct {
                 args []string
                 cmd  CommandLine
         }{
-                {nil, CommandLine{}},
+                {nil, CommandLine{Target: NoTarget{}}},
 
                 {[]string{"-a", "-b", "-Q'foo.bar.baz'", "-Wbar"},
                         CommandLine{
-                                Flags: []string{"-a", "-b", "-Q'foo.bar.baz'", "-Wbar"},
-                                Args:  []string{},
+                                Target: NoTarget{},
+                                Flags:  []string{"-a", "-b", "-Q'foo.bar.baz'", "-Wbar"},
+                                Args:   []string{},
                         },
                 },
 
                 {[]string{"path.py", "--", "foo", "bar"},
                         CommandLine{
-                                Type:  TargetScript,
-                                Value: "path.py",
-                                Flags: []string{},
-                                Args:  []string{"--", "foo", "bar"},
+                                Target: ScriptTarget{"path.py"},
+                                Flags:  []string{},
+                                Args:   []string{"--", "foo", "bar"},
                         },
                 },
 
                 {[]string{"-a", "-Wfoo", "-", "--", "foo"},
                         CommandLine{
-                                Type:  TargetScript,
-                                Value: "-",
-                                Flags: []string{"-a", "-Wfoo"},
-                                Args:  []string{"--", "foo"},
+                                Target: ScriptTarget{"-"},
+                                Flags:  []string{"-a", "-Wfoo"},
+                                Args:   []string{"--", "foo"},
                         },
                 },
 
                 {[]string{"-a", "-b", "-W", "foo", "-Wbar", "-c", "<script>", "--", "arg"},
                         CommandLine{
-                                Type:  TargetCommand,
-                                Value: "<script>",
-                                Flags: []string{"-a", "-b", "-W", "foo", "-Wbar"},
-                                Args:  []string{"--", "arg"},
+                                Target: CommandTarget{"<script>"},
+                                Flags:  []string{"-a", "-b", "-W", "foo", "-Wbar"},
+                                Args:   []string{"--", "arg"},
                         },
                 },
 
                 {[]string{"-a", "-b", "-m'foo.bar.baz'", "arg"},
                         CommandLine{
-                                Type:  TargetModule,
-                                Value: "'foo.bar.baz'",
-                                Flags: []string{"-a", "-b"},
-                                Args:  []string{"arg"},
+                                Target: ModuleTarget{"'foo.bar.baz'"},
+                                Flags:  []string{"-a", "-b"},
+                                Args:   []string{"arg"},
                         },
                 },
         }
 
         failures := []struct {
                 args []string
                 err  string
         }{
                 {[]string{"-a", "-b", "-Q"}, "truncated two-variable argument"},
                 {[]string{"-c"}, "missing second value"},
@@ skipping 89 matching lines @@
 
                                         So(cmd.Run(c, "foo", "bar"), ShouldBeNil)
                                         So(lastCmd, ShouldResemble, &exec.Cmd{
                                                 Path:   "/path/to/python",
                                                 Args:   []string{"/path/to/python", "-B", "-E", "-s", "foo", "bar"},
                                                 Stdout: os.Stdout,
                                                 Stderr: os.Stderr,
                                         })
                                 })
 
-                                Convey(`Can connect STDIN.`, func() {
-                                        cmd.ConnectSTDIN = true
-
-                                        So(cmd.Run(c, "foo", "bar"), ShouldBeNil)
-                                        So(lastCmd, ShouldResemble, &exec.Cmd{
-                                                Path:   "/path/to/python",
-                                                Args:   []string{"/path/to/python", "foo", "bar"},
-                                                Stdout: os.Stdout,
-                                                Stderr: os.Stderr,
-                                                Stdin:  os.Stdin,
-                                        })
-                                })
-
                                 Convey(`Will forward a working directory and enviornment`, func() {
                                         cmd.WorkDir = "zugzug"
                                         cmd.Env = []string{"pants=on"}
 
                                         So(cmd.Run(c, "foo", "bar"), ShouldBeNil)
                                         So(lastCmd, ShouldResemble, &exec.Cmd{
                                                 Path:   "/path/to/python",
                                                 Args:   []string{"/path/to/python", "foo", "bar"},
                                                 Stdout: os.Stdout,
                                                 Stderr: os.Stderr,
@@ skipping 17 matching lines @@
                                         Convey(fmt.Sprintf(`Will fail to parse %q (%s)`, tc.output, tc.err), func() {
                                                 runnerOutput = tc.output
                                                 _, err := i.GetVersion(c)
                                                 So(err, ShouldErrLike, tc.err)
                                         })
                                 }
                         })
                 })
         })
 }