From 621e49bb465f500cc46d47e39e828cf76d6381d7 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 24 Jul 2018 14:35:44 +0200 Subject: update vendor --- .../golang/mock/gomock/controller_test.go | 245 ++++++++++++++++++++- 1 file changed, 241 insertions(+), 4 deletions(-) (limited to 'vendor/github.com/golang/mock/gomock/controller_test.go') 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.") +} -- cgit v1.2.3