path: root/internal/cmdtest/test_cmd.go

// Copyright 2017 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package cmdtest

import (
    "bufio"
    "bytes"
    "fmt"
    "io"
    "io/ioutil"
    "os"
    "os/exec"
    "regexp"
    "strings"
    "sync"
    "testing"
    "text/template"
    "time"

    "github.com/docker/docker/pkg/reexec"
)

func NewTestCmd(t *testing.T, data interface{}) *TestCmd {
    return &TestCmd{T: t, Data: data}
}

type TestCmd struct {
    // For total convenience, all testing methods are available.
    *testing.T

    Func    template.FuncMap
    Data    interface{}
    Cleanup func()

    cmd    *exec.Cmd
    stdout *bufio.Reader
    stdin  io.WriteCloser
    stderr *testlogger
}

// Run exec's the current binary using name as argv[0] which will trigger the
// reexec init function for that name (e.g. "geth-test" in cmd/geth/run_test.go)
func (tt *TestCmd) Run(name string, args ...string) {
    tt.stderr = &testlogger{t: tt.T}
    tt.cmd = &exec.Cmd{
        Path:   reexec.Self(),
        Args:   append([]string{name}, args...),
        Stderr: tt.stderr,
    }
    stdout, err := tt.cmd.StdoutPipe()
    if err != nil {
        tt.Fatal(err)
    }
    tt.stdout = bufio.NewReader(stdout)
    if tt.stdin, err = tt.cmd.StdinPipe(); err != nil {
        tt.Fatal(err)
    }
    if err := tt.cmd.Start(); err != nil {
        tt.Fatal(err)
    }
}

// InputLine writes the given text to the childs stdin.
// This method can also be called from an expect template, e.g.:
//
//     geth.expect(`Passphrase: {{.InputLine "password"}}`)
func (tt *TestCmd) InputLine(s string) string {
    io.WriteString(tt.stdin, s+"\n")
    return ""
}

func (tt *TestCmd) SetTemplateFunc(name string, fn interface{}) {
    if tt.Func == nil {
        tt.Func = make(map[string]interface{})
    }
    tt.Func[name] = fn
}

// Expect runs its argument as a template, then expects the
// child process to output the result of the template within 5s.
//
// If the template starts with a newline, the newline is removed
// before matching.
func (tt *TestCmd) Expect(tplsource string) {
    // Generate the expected output by running the template.
    tpl := template.Must(template.New("").Funcs(tt.Func).Parse(tplsource))
    wantbuf := new(bytes.Buffer)
    if err := tpl.Execute(wantbuf, tt.Data); err != nil {
        panic(err)
    }
    // Trim exactly one newline at the beginning. This makes tests look
    // much nicer because all expect strings are at column 0.
    want := bytes.TrimPrefix(wantbuf.Bytes(), []byte("\n"))
    if err := tt.matchExactOutput(want); err != nil {
        tt.Fatal(err)
    }
    tt.Logf("Matched stdout text:\n%s", want)
}

func (tt *TestCmd) matchExactOutput(want []byte) error {
    buf := make([]byte, len(want))
    n := 0
    tt.withKillTimeout(func() { n, _ = io.ReadFull(tt.stdout, buf) })
    buf = buf[:n]
    if n < len(want) || !bytes.Equal(buf, want) {
        // Grab any additional buffered output in case of mismatch
        // because it might help with debugging.
        buf = append(buf, make([]byte, tt.stdout.Buffered())...)
        tt.stdout.Read(buf[n:])
        // Find the mismatch position.
        for i := 0; i < n; i++ {
            if want[i] != buf[i] {
                return fmt.Errorf("Output mismatch at ◊:\n---------------- (stdout text)\n%s◊%s\n---------------- (expected text)\n%s",
                    buf[:i], buf[i:n], want)
            }
        }
        if n < len(want) {
            return fmt.Errorf("Not enough output, got until ◊:\n---------------- (stdout text)\n%s\n---------------- (expected text)\n%s◊%s",
                buf, want[:n], want[n:])
        }
    }
    return nil
}

// ExpectRegexp expects the child process to output text matching the
// given regular expression within 5s.
//
// Note that an arbitrary amount of output may be consumed by the
// regular expression. This usually means that expect cannot be used
// after ExpectRegexp.
func (tt *TestCmd) ExpectRegexp(regex string) (*regexp.Regexp, []string) {
    regex = strings.TrimPrefix(regex, "\n")
    var (
        re      = regexp.MustCompile(regex)
        rtee    = &runeTee{in: tt.stdout}
        matches []int
    )
    tt.withKillTimeout(func() { matches = re.FindReaderSubmatchIndex(rtee) })
    output := rtee.buf.Bytes()
    if matches == nil {
        tt.Fatalf("Output did not match:\n---------------- (stdout text)\n%s\n---------------- (regular expression)\n%s",
            output, regex)
        return re, nil
    }
    tt.Logf("Matched stdout text:\n%s", output)
    var submatches []string
    for i := 0; i < len(matches); i += 2 {
        submatch := string(output[matches[i]:matches[i+1]])
        submatches = append(submatches, submatch)
    }
    return re, submatches
}

// ExpectExit expects the child process to exit within 5s without
// printing any additional text on stdout.
func (tt *TestCmd) ExpectExit() {
    var output []byte
    tt.withKillTimeout(func() {
        output, _ = ioutil.ReadAll(tt.stdout)
    })
    tt.WaitExit()
    if tt.Cleanup != nil {
        tt.Cleanup()
    }
    if len(output) > 0 {
        tt.Errorf("Unmatched stdout text:\n%s", output)
    }
}

func (tt *TestCmd) WaitExit() {
    tt.cmd.Wait()
}

func (tt *TestCmd) Interrupt() {
    tt.cmd.Process.Signal(os.Interrupt)
}

// StderrText returns any stderr output written so far.
// The returned text holds all log lines after ExpectExit has
// returned.
func (tt *TestCmd) StderrText() string {
    tt.stderr.mu.Lock()
    defer tt.stderr.mu.Unlock()
    return tt.stderr.buf.String()
}

func (tt *TestCmd) CloseStdin() {
    tt.stdin.Close()
}

func (tt *TestCmd) Kill() {
    tt.cmd.Process.Kill()
    if tt.Cleanup != nil {
        tt.Cleanup()
    }
}

func (tt *TestCmd) withKillTimeout(fn func()) {
    timeout := time.AfterFunc(5*time.Second, func() {
        tt.Log("killing the child process (timeout)")
        tt.Kill()
    })
    defer timeout.Stop()
    fn()
}

// testlogger logs all written lines via t.Log and also
// collects them for later inspection.
type testlogger struct {
    t   *testing.T
    mu  sync.Mutex
    buf bytes.Buffer
}

func (tl *testlogger) Write(b []byte) (n int, err error) {
    lines := bytes.Split(b, []byte("\n"))
    for _, line := range lines {
        if len(line) > 0 {
            tl.t.Logf("(stderr) %s", line)
        }
    }
    tl.mu.Lock()
    tl.buf.Write(b)
    tl.mu.Unlock()
    return len(b), err
}

// runeTee collects text read through it into buf.
type runeTee struct {
    in interface {
        io.Reader
        io.ByteReader
        io.RuneReader
    }
    buf bytes.Buffer
}

func (rtee *runeTee) Read(b []byte) (n int, err error) {
    n, err = rtee.in.Read(b)
    rtee.buf.Write(b[:n])
    return n, err
}

func (rtee *runeTee) ReadRune() (r rune, size int, err error) {
    r, size, err = rtee.in.ReadRune()
    if err == nil {
        rtee.buf.WriteRune(r)
    }
    return r, size, err
}

func (rtee *runeTee) ReadByte() (b byte, err error) {
    b, err = rtee.in.ReadByte()
    if err == nil {
        rtee.buf.WriteByte(b)
    }
    return b, err
}