Added an interface for all the public functions of the survey package

README.md

@@ -442,6 +442,10 @@ survey.AskOne(
 
 ## Testing
 
+There are two ways to test a program using survey. Using a mock is recommended because it leads to faster, less brittle tests. 
+
+### Using a simulated terminal
+
 You can test your program's interactive prompts using [go-expect](https://github.com/Netflix/go-expect). The library
 can be used to expect a match on stdout and respond on stdin. Since `os.Stdout` in a `go test` process is not a TTY,
 if you are manipulating the cursor or using `survey`, you will need a way to interpret terminal / ANSI escape sequences
@@ -450,6 +454,65 @@ stdio to an in-memory [virtual terminal](https://github.com/hinshun/vt10x).
 
 For some examples, you can see any of the tests in this repo.
 
+### Using a mock
+
+Instead of calling the survey functions directly, you can create a survey struct and call the functions from there.
+
+```golang
+
+survey := survey.Survey{}
+
+response := false
+prompt := &survey.Confirm{
+    Message: "Do you like pie?",
+}
+survey.AskOne(prompt, &response)
+
+```
+
+If you create only one survey struct at the top level of your program and pass it to all functions, you can test those functions by replacing the struct with a mock provided by survey.
+
+#### main
+
+```golang
+func main() {
+    survey := survey.Survey{}
+
+    AskForPie(survey)
+}
+
+func AskForPie(survey survey.SurveyInterface) bool {
+    response := false
+    prompt := &survey.Confirm{
+        Message: "Do you like pie?",
+    }
+    survey.AskOne(prompt, &response)
+
+    return response
+}
+
+```
+
+#### Test
+
+```golang
+func TestAskForPie(t *testing.T) {
+
+    //create mock
+    mock := survey.SurveyMock{} 
+    //set the response the "user" should select 
+    mock.setResponse(true)
+
+    result := AskForPie(mock)
+
+    //check output of the function
+    if result != true {
+        t.Fatalf("AskForPie returned false, but it should have returned true!")
+    }
+}
+
+```
+
 ## FAQ
 
 ### What kinds of IO are supported by `survey`?

survey.go

@@ -12,6 +12,55 @@ import (
 	"github.com/AlecAivazis/survey/v2/terminal"
 )
 
+//SurveyInterface includes all the functions a normal user uses when using survey
+type SurveyInterface interface {
+	WithStdio(in terminal.FileReader, out terminal.FileWriter, err io.Writer) AskOpt
+	WithFilter(filter func(filter string, value string, index int) (include bool)) AskOpt
+	WithKeepFilter(KeepFilter bool) AskOpt
+	WithValidator(v Validator) AskOpt
+	WithPageSize(pageSize int) AskOpt
+	WithHelpInput(r rune) AskOpt
+	WithIcons(setIcons func(*IconSet)) AskOpt
+	WithShowCursor(ShowCursor bool) AskOpt
+	AskOne(p Prompt, response interface{}, opts ...AskOpt) error
+	Ask(qs []*Question, response interface{}, opts ...AskOpt) error
+}
+
+type Survey struct{}
+
+//the following ten functions are just passthroughs to the actual functions, but they make sure that the survey struct is backwards compatible to calling the functions directly
+
+func (survey Survey) WithStdio(in terminal.FileReader, out terminal.FileWriter, err io.Writer) AskOpt {
+	return WithStdio(in, out, err)
+}
+func (survey Survey) WithFilter(filter func(filter string, value string, index int) (include bool)) AskOpt {
+	return WithFilter(filter)
+}
+func (survey Survey) WithKeepFilter(KeepFilter bool) AskOpt {
+	return WithKeepFilter(KeepFilter)
+}
+func (survey Survey) WithValidator(v Validator) AskOpt {
+	return WithValidator(v)
+}
+func (survey Survey) WithPageSize(pageSize int) AskOpt {
+	return WithPageSize(pageSize)
+}
+func (survey Survey) WithHelpInput(r rune) AskOpt {
+	return WithHelpInput(r)
+}
+func (survey Survey) WithIcons(setIcons func(*IconSet)) AskOpt {
+	return WithIcons(setIcons)
+}
+func (survey Survey) WithShowCursor(ShowCursor bool) AskOpt {
+	return WithShowCursor(ShowCursor)
+}
+func (survey Survey) AskOne(p Prompt, response interface{}, opts ...AskOpt) error {
+	return AskOne(p, response, opts...)
+}
+func (survey Survey) Ask(qs []*Question, response interface{}, opts ...AskOpt) error {
+	return Ask(qs, response, opts...)
+}
+
 // DefaultAskOptions is the default options on ask, using the OS stdio.
 func defaultAskOptions() *AskOptions {
 	return &AskOptions{

surveyMock.go

@@ -0,0 +1,84 @@
+package survey
+
+import (
+	"io"
+
+	"github.com/AlecAivazis/survey/v2/core"
+	"github.com/AlecAivazis/survey/v2/terminal"
+)
+
+type SurveyMock struct {
+	singleResponse    interface{}
+	multipleResponses map[string]interface{}
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithStdio(in terminal.FileReader, out terminal.FileWriter, err io.Writer) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithFilter(filter func(filter string, value string, index int) (include bool)) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithKeepFilter(KeepFilter bool) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithValidator(v Validator) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithPageSize(pageSize int) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithHelpInput(r rune) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithIcons(setIcons func(*IconSet)) AskOpt {
+	return nil
+}
+
+// Not implemented, because it does not affect the mock
+func (mock *SurveyMock) WithShowCursor(ShowCursor bool) AskOpt {
+	return nil
+}
+
+func (mock *SurveyMock) AskOne(p Prompt, response interface{}, opts ...AskOpt) error {
+	err := core.WriteAnswer(response, "", mock.singleResponse)
+	if err != nil {
+		// panicing is fine inside a mock
+		panic(err)
+	}
+	return nil
+}
+
+func (mock *SurveyMock) Ask(qs []*Question, response interface{}, opts ...AskOpt) error {
+	for _, q := range qs {
+
+		err := core.WriteAnswer(response, q.Name, mock.multipleResponses[q.Name])
+		if err != nil {
+			// panicing is fine inside a mock
+			panic(err)
+		}
+
+	}
+
+	return nil
+}
+
+func (mock *SurveyMock) SetResponse(response interface{}) {
+	if val, ok := response.(map[string]interface{}); ok {
+		mock.multipleResponses = val
+	} else {
+		mock.singleResponse = response
+	}
+}

surveyMock_test.go

@@ -0,0 +1,53 @@
+package survey
+
+import (
+	"testing"
+)
+
+func TestMockAskOne(t *testing.T) {
+	t.Run("Setting Response", func(t *testing.T) {
+		mock := SurveyMock{}
+		mock.SetResponse(true)
+
+		prompt := &Confirm{
+			Message: "test",
+		}
+
+		var response bool
+		mock.AskOne(prompt, &response)
+
+		if !response {
+			t.Fatalf("Response was false but should have been true!")
+		}
+	})
+
+}
+
+func TestMockAsk(t *testing.T) {
+	t.Run("Setting Response", func(t *testing.T) {
+		mock := SurveyMock{}
+
+		test := make(map[string]interface{})
+		test["test"] = true
+
+		mock.SetResponse(test)
+
+		questions := []*Question{
+			{
+				Name: "test",
+				Prompt: &Confirm{
+					Message: "testing",
+				},
+			},
+		}
+
+		answer := struct {
+			Test bool
+		}{}
+		mock.Ask(questions, &answer)
+
+		if !answer.Test {
+			t.Fatalf("Response was false but should have been true!")
+		}
+	})
+}