summaryrefslogtreecommitdiff
path: root/vendor/github.com/golang/mock/gomock/controller_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/golang/mock/gomock/controller_test.go')
-rw-r--r--vendor/github.com/golang/mock/gomock/controller_test.go245
1 files changed, 241 insertions, 4 deletions
diff --git a/vendor/github.com/golang/mock/gomock/controller_test.go b/vendor/github.com/golang/mock/gomock/controller_test.go
index 57f7957..b3bb4de 100644
--- a/vendor/github.com/golang/mock/gomock/controller_test.go
+++ b/vendor/github.com/golang/mock/gomock/controller_test.go
@@ -19,6 +19,8 @@ import (
"reflect"
"testing"
+ "strings"
+
"github.com/golang/mock/gomock"
)
@@ -53,7 +55,7 @@ func (e *ErrorReporter) assertFail(msg string) {
}
// Use to check that code triggers a fatal test failure.
-func (e *ErrorReporter) assertFatal(fn func()) {
+func (e *ErrorReporter) assertFatal(fn func(), expectedErrMsgs ...string) {
defer func() {
err := recover()
if err == nil {
@@ -66,6 +68,18 @@ func (e *ErrorReporter) assertFatal(fn func()) {
e.t.Error("Expected fatal failure, but got a", actual)
} else if token, ok := err.(*struct{}); ok && token == &e.fatalToken {
// This is okay - the panic is from Fatalf().
+ if expectedErrMsgs != nil {
+ // assert that the actual error message
+ // contains expectedErrMsgs
+
+ // check the last actualErrMsg, because the previous messages come from previous errors
+ actualErrMsg := e.log[len(e.log)-1]
+ for _, expectedErrMsg := range expectedErrMsgs {
+ if !strings.Contains(actualErrMsg, expectedErrMsg) {
+ e.t.Errorf("Error message:\ngot: %q\nwant to contain: %q\n", actualErrMsg, expectedErrMsg)
+ }
+ }
+ }
return
} else {
// Some other panic.
@@ -119,6 +133,20 @@ func (s *Subject) BarMethod(arg string) int {
return 0
}
+func (s *Subject) VariadicMethod(arg int, vararg ...string) {}
+
+// A type purely for ActOnTestStructMethod
+type TestStruct struct {
+ Number int
+ Message string
+}
+
+func (s *Subject) ActOnTestStructMethod(arg TestStruct, arg1 int) int {
+ return 0
+}
+
+func (s *Subject) SetArgMethod(sliceArg []byte, ptrArg *int) {}
+
func assertEqual(t *testing.T, expected interface{}, actual interface{}) {
if !reflect.DeepEqual(expected, actual) {
t.Errorf("Expected %+v, but got %+v", expected, actual)
@@ -140,6 +168,31 @@ func TestNoCalls(t *testing.T) {
reporter.assertPass("No calls expected or made.")
}
+func TestNoRecordedCallsForAReceiver(t *testing.T) {
+ reporter, ctrl := createFixtures(t)
+ subject := new(Subject)
+
+ reporter.assertFatal(func() {
+ ctrl.Call(subject, "NotRecordedMethod", "argument")
+ }, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")
+ ctrl.Finish()
+}
+
+func TestNoRecordedMatchingMethodNameForAReceiver(t *testing.T) {
+ reporter, ctrl := createFixtures(t)
+ subject := new(Subject)
+
+ ctrl.RecordCall(subject, "FooMethod", "argument")
+ reporter.assertFatal(func() {
+ ctrl.Call(subject, "NotRecordedMethod", "argument")
+ }, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")
+ reporter.assertFatal(func() {
+ // The expected call wasn't made.
+ ctrl.Finish()
+ })
+}
+
+// This tests that a call with an arguments of some primitive type matches a recorded call.
func TestExpectedMethodCall(t *testing.T) {
reporter, ctrl := createFixtures(t)
subject := new(Subject)
@@ -187,11 +240,68 @@ func TestUnexpectedArgCount(t *testing.T) {
reporter.assertFatal(func() {
// This call is made with the wrong number of arguments...
ctrl.Call(subject, "FooMethod", "argument", "extra_argument")
- })
+ }, "Unexpected call to", "wrong number of arguments", "Got: 2, want: 1")
reporter.assertFatal(func() {
// ... so is this.
ctrl.Call(subject, "FooMethod")
+ }, "Unexpected call to", "wrong number of arguments", "Got: 0, want: 1")
+ reporter.assertFatal(func() {
+ // The expected call wasn't made.
+ ctrl.Finish()
+ })
+}
+
+// This tests that a call with complex arguments (a struct and some primitive type) matches a recorded call.
+func TestExpectedMethodCall_CustomStruct(t *testing.T) {
+ reporter, ctrl := createFixtures(t)
+ subject := new(Subject)
+
+ expectedArg0 := TestStruct{Number: 123, Message: "hello"}
+ ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)
+ ctrl.Call(subject, "ActOnTestStructMethod", expectedArg0, 15)
+
+ reporter.assertPass("Expected method call made.")
+}
+
+func TestUnexpectedArgValue_FirstArg(t *testing.T) {
+ reporter, ctrl := createFixtures(t)
+ defer reporter.recoverUnexpectedFatal()
+ subject := new(Subject)
+
+ expectedArg0 := TestStruct{Number: 123, Message: "hello"}
+ ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)
+
+ reporter.assertFatal(func() {
+ // the method argument (of TestStruct type) has 1 unexpected value (for the Message field)
+ ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "no message"}, 15)
+ }, "Unexpected call to", "doesn't match the argument at index 0",
+ "Got: {123 no message}\nWant: is equal to {123 hello}")
+
+ reporter.assertFatal(func() {
+ // the method argument (of TestStruct type) has 2 unexpected values (for both fields)
+ ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 11, Message: "no message"}, 15)
+ }, "Unexpected call to", "doesn't match the argument at index 0",
+ "Got: {11 no message}\nWant: is equal to {123 hello}")
+
+ reporter.assertFatal(func() {
+ // The expected call wasn't made.
+ ctrl.Finish()
})
+}
+
+func TestUnexpectedArgValue_SecondtArg(t *testing.T) {
+ reporter, ctrl := createFixtures(t)
+ defer reporter.recoverUnexpectedFatal()
+ subject := new(Subject)
+
+ expectedArg0 := TestStruct{Number: 123, Message: "hello"}
+ ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)
+
+ reporter.assertFatal(func() {
+ ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)
+ }, "Unexpected call to", "doesn't match the argument at index 1",
+ "Got: 3\nWant: is equal to 15")
+
reporter.assertFatal(func() {
// The expected call wasn't made.
ctrl.Finish()
@@ -317,6 +427,74 @@ func TestDo(t *testing.T) {
ctrl.Finish()
}
+func TestDoAndReturn(t *testing.T) {
+ _, ctrl := createFixtures(t)
+ subject := new(Subject)
+
+ doCalled := false
+ var argument string
+ ctrl.RecordCall(subject, "FooMethod", "argument").DoAndReturn(
+ func(arg string) int {
+ doCalled = true
+ argument = arg
+ return 5
+ })
+ if doCalled {
+ t.Error("Do() callback called too early.")
+ }
+
+ rets := ctrl.Call(subject, "FooMethod", "argument")
+
+ if !doCalled {
+ t.Error("Do() callback not called.")
+ }
+ if "argument" != argument {
+ t.Error("Do callback received wrong argument.")
+ }
+ if len(rets) != 1 {
+ t.Fatalf("Return values from Call: got %d, want 1", len(rets))
+ }
+ if ret, ok := rets[0].(int); !ok {
+ t.Fatalf("Return value is not an int")
+ } else if ret != 5 {
+ t.Errorf("DoAndReturn return value: got %d, want 5", ret)
+ }
+
+ ctrl.Finish()
+}
+
+func TestSetArgSlice(t *testing.T) {
+ _, ctrl := createFixtures(t)
+ subject := new(Subject)
+
+ var in = []byte{4, 5, 6}
+ var set = []byte{1, 2, 3}
+ ctrl.RecordCall(subject, "SetArgMethod", in, nil).SetArg(0, set)
+ ctrl.Call(subject, "SetArgMethod", in, nil)
+
+ if !reflect.DeepEqual(in, set) {
+ t.Error("Expected SetArg() to modify input slice argument")
+ }
+
+ ctrl.Finish()
+}
+
+func TestSetArgPtr(t *testing.T) {
+ _, ctrl := createFixtures(t)
+ subject := new(Subject)
+
+ var in int = 43
+ const set = 42
+ ctrl.RecordCall(subject, "SetArgMethod", nil, &in).SetArg(1, set)
+ ctrl.Call(subject, "SetArgMethod", nil, &in)
+
+ if in != set {
+ t.Error("Expected SetArg() to modify value pointed to by argument")
+ }
+
+ ctrl.Finish()
+}
+
func TestReturn(t *testing.T) {
_, ctrl := createFixtures(t)
subject := new(Subject)
@@ -393,11 +571,12 @@ func TestOrderedCallsInCorrect(t *testing.T) {
ctrl.Call(subjectOne, "FooMethod", "1")
reporter.assertFatal(func() {
+ // FooMethod(2) should be called before BarMethod(3)
ctrl.Call(subjectTwo, "BarMethod", "3")
- })
+ }, "Unexpected call to", "Subject.BarMethod([3])", "doesn't have a prerequisite call satisfied")
}
-// Test that calls that are prerequites to other calls but have maxCalls >
+// Test that calls that are prerequisites to other calls but have maxCalls >
// minCalls are removed from the expected call set.
func TestOrderedCallsWithPreReqMaxUnbounded(t *testing.T) {
reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t)
@@ -473,3 +652,61 @@ func TestTimes0(t *testing.T) {
ctrl.Call(s, "FooMethod", "arg")
})
}
+
+func TestVariadicMatching(t *testing.T) {
+ rep, ctrl := createFixtures(t)
+ defer rep.recoverUnexpectedFatal()
+
+ s := new(Subject)
+ ctrl.RecordCall(s, "VariadicMethod", 0, "1", "2")
+ ctrl.Call(s, "VariadicMethod", 0, "1", "2")
+ ctrl.Finish()
+ rep.assertPass("variadic matching works")
+}
+
+func TestVariadicNoMatch(t *testing.T) {
+ rep, ctrl := createFixtures(t)
+ defer rep.recoverUnexpectedFatal()
+
+ s := new(Subject)
+ ctrl.RecordCall(s, "VariadicMethod", 0)
+ rep.assertFatal(func() {
+ ctrl.Call(s, "VariadicMethod", 1)
+ }, "Expected call at", "doesn't match the argument at index 0",
+ "Got: 1\nWant: is equal to 0")
+ ctrl.Call(s, "VariadicMethod", 0)
+ ctrl.Finish()
+}
+
+func TestVariadicMatchingWithSlice(t *testing.T) {
+ testCases := [][]string{
+ {"1"},
+ {"1", "2"},
+ }
+ for _, tc := range testCases {
+ t.Run(fmt.Sprintf("%d arguments", len(tc)), func(t *testing.T) {
+ rep, ctrl := createFixtures(t)
+ defer rep.recoverUnexpectedFatal()
+
+ s := new(Subject)
+ ctrl.RecordCall(s, "VariadicMethod", 1, tc)
+ args := make([]interface{}, len(tc)+1)
+ args[0] = 1
+ for i, arg := range tc {
+ args[i+1] = arg
+ }
+ ctrl.Call(s, "VariadicMethod", args...)
+ ctrl.Finish()
+ rep.assertPass("slices can be used as matchers for variadic arguments")
+ })
+ }
+}
+
+func TestDuplicateFinishCallFails(t *testing.T) {
+ rep, ctrl := createFixtures(t)
+
+ ctrl.Finish()
+ rep.assertPass("the first Finish call should succeed")
+
+ rep.assertFatal(ctrl.Finish, "Controller.Finish was called more than once. It has to be called exactly once.")
+}