ui_test.go

// +build darwin dragonfly freebsd linux netbsd openbsd solaris

package sand

import (
	"bytes"
	"context"
	"github.com/golang/mock/gomock"
	"io"
	"io/ioutil"
	"os"
	"reflect"
	"syscall"
	"testing"
	"time"
)

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/Zaba505/sand (interfaces: Engine)

// MockEngine is a mock of Engine interface
type MockEngine struct {
	ctrl     *gomock.Controller
	recorder *MockEngineMockRecorder
}

// MockEngineMockRecorder is the mock recorder for MockEngine
type MockEngineMockRecorder struct {
	mock *MockEngine
}

// NewMockEngine creates a new mock instance
func NewMockEngine(ctrl *gomock.Controller) *MockEngine {
	mock := &MockEngine{ctrl: ctrl}
	mock.recorder = &MockEngineMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockEngine) EXPECT() *MockEngineMockRecorder {
	return m.recorder
}

// Exec mocks base method
func (m *MockEngine) Exec(arg0 context.Context, arg1 string, arg2 io.ReadWriter) int {
	ret := m.ctrl.Call(m, "Exec", arg0, arg1, arg2)
	ret0, _ := ret[0].(int)
	return ret0
}

// Exec indicates an expected call of Exec
func (mr *MockEngineMockRecorder) Exec(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockEngine)(nil).Exec), arg0, arg1, arg2)
}

// This is the same as TestRun but just assures test coverage
func TestUI_Run(t *testing.T) {
	// Set engine
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()
	eng := NewMockEngine(ctrl)
	eng.EXPECT().Exec(gomock.Any(), gomock.Eq("hello, world!"), gomock.Any()).Return(0).MinTimes(1)

	// Set IO
	in := bytes.NewReader([]byte("hello, world!"))
	var out bytes.Buffer

	// Run UI
	ui := new(UI)
	ui.SetPrefix(">")
	ui.SetIO(in, &out)
	err := ui.Run(nil, eng)
	var ok bool
	if err, ok = IsRecoverable(err); !ok {
		t.Error(err)
	}
	if err != nil && err != io.EOF {
		t.Error(err)
	}

	// Verify the output length
	// 	- First prefix write
	//  - Second prefix write
	//  - EndLine from defer.
	if out.Len() != 3 {
		t.Fail()
	}

	// Verify the output: ">>\n"
	if out.String() != ">>\n" {
		t.Fail()
	}
}

func TestRun(t *testing.T) {
	// Set engine
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()
	eng := NewMockEngine(ctrl)
	eng.EXPECT().Exec(gomock.Any(), gomock.Eq("hello, world!"), gomock.Any()).Return(0).MinTimes(1)

	// Set IO
	in := bytes.NewReader([]byte("hello, world!"))
	var out bytes.Buffer

	// Run UI
	err := Run(nil, eng, WithPrefix(">"), WithIO(in, &out))
	var ok bool
	if err, ok = IsRecoverable(err); !ok {
		t.Error(err)
	}
	if err != nil && err != io.EOF {
		t.Error(err)
	}

	// Verify the output length
	// 	- First prefix write
	//  - Second prefix write
	//  - EndLine from defer.
	if out.Len() != 3 {
		t.Fail()
	}

	// Verify the output: ">>\n"
	if out.String() != ">>\n" {
		t.Fail()
	}
}

func TestRunWithContext(t *testing.T) {
	// Imagine using sand to create an SSH client like PuTTY and you allow
	// for login sessions that expire after a certain amount of time.

	sessionLife := 3 * time.Second
	ctx, cancel := context.WithTimeout(context.Background(), sessionLife)
	defer cancel()
	pr, pw := io.Pipe() // This allows Read to be blocking

	ctrl := gomock.NewController(t)
	defer ctrl.Finish()
	eng := NewMockEngine(ctrl)

	err := Run(ctx, eng, WithIO(pr, ioutil.Discard))
	var ok bool
	if err, ok = IsRecoverable(err); !ok {
		t.Error(err)
	}
	if err != context.DeadlineExceeded {
		t.Errorf("expected context.DeadlineExceeded but instead received: %s", err)
	}

	pr.Close()
	pw.Close()
}

// testLongEngine represents an Exec call that takes a long time.
type testLongEngine struct {
	timeout time.Duration
}

func (eng testLongEngine) Exec(ctx context.Context, _ string, _ io.ReadWriter) int {
	select {
	case <-ctx.Done():
	case <-time.After(eng.timeout):
	}
	return 0
}

func TestRunWithLongExec(t *testing.T) {
	sessionLife := 3 * time.Second
	ctx, cancel := context.WithTimeout(context.Background(), sessionLife)
	defer cancel()
	pr, pw := io.Pipe() // This allows Read to be blocking

	// Set IO
	in := bytes.NewReader([]byte("test line to start Engine.Exec call"))

	eng := testLongEngine{timeout: 1 * time.Minute}
	err := Run(ctx, eng, WithIO(in, ioutil.Discard))
	var ok bool
	if err, ok = IsRecoverable(err); !ok {
		t.Error(err)
	}
	if err != context.DeadlineExceeded {
		t.Error(err)
	}

	pr.Close()
	pw.Close()
}

func TestRunWithNoEngine(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {
			err, ok := r.(error)
			if !ok {
				t.Errorf("expected erroNoEngine error from recover but instead received: %v", r)
			}

			if err != errNoEngine {
				t.Fail()
			}
		}
	}()

	ui := new(UI)
	ui.Run(nil, nil)
}

func TestRunWithSignalInterrupt(t *testing.T) {
	go func() {
		<-time.After(time.Second) // Give the UI a little time to start up
		// Send this process a SIGHUP
		syscall.Kill(syscall.Getpid(), syscall.SIGHUP)
	}()

	// Set up UI, IO and Engine
	ui := new(UI)
	pr, pw := io.Pipe()
	eng := testLongEngine{timeout: 1 * time.Minute}

	// Re-route SIGHUP to os.Interrupt so when sending a signal
	// we don't mess with any other tests
	opts := []Option{
		WithIO(pr, pw),
		WithSignalHandlers(map[os.Signal]SignalHandler{
			syscall.SIGHUP: func(signal os.Signal) os.Signal {
				return os.Interrupt
			},
		}),
	}

	// Run UI
	ctx, cancel := context.WithCancel(context.Background())
	err := ui.Run(ctx, eng, opts...)
	cancel()

	// Clean up
	pr.Close()
	pw.Close()

	// Check error
	var ok bool
	if err, ok = IsRecoverable(err); !ok {
		t.Error(err)
	}
	if err != context.Canceled {
		t.Errorf("expected context.Canceled but instead received: %s", err)
	}
}