public void CallMethodFoo()
        {
            MockRepository mocks       = new MockRepository();
            FooRequest     fooRequest  = FooRequest.CreateBuilder().Build();
            FooResponse    fooResponse = FooResponse.CreateBuilder().Build();
            IRpcController controller  = mocks.StrictMock <IRpcController>();

            bool fooCalled = false;

            TestService service = new TestServiceImpl((request, responseAction) => {
                Assert.AreSame(fooRequest, request);
                fooCalled = true;
                responseAction(fooResponse);
            }, null, controller);

            bool doneHandlerCalled        = false;
            Action <IMessage> doneHandler = (response => {
                Assert.AreSame(fooResponse, response);
                doneHandlerCalled = true;
            });

            using (mocks.Record()) {
                // No mock interactions to record
            }

            service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler);

            Assert.IsTrue(doneHandlerCalled);
            Assert.IsTrue(fooCalled);
            mocks.VerifyAll();
        }
        public void CallMethodFoo()
        {
            FooRequest     fooRequest  = FooRequest.CreateBuilder().Build();
            FooResponse    fooResponse = FooResponse.CreateBuilder().Build();
            IRpcController controller  = new RpcTestController();

            bool fooCalled = false;

            TestGenericService service = new TestServiceImpl((request, responseAction) =>
            {
                Assert.AreSame(fooRequest, request);
                fooCalled = true;
                responseAction(fooResponse);
            }, null, controller);

            bool doneHandlerCalled        = false;
            Action <IMessage> doneHandler = (response =>
            {
                Assert.AreSame(fooResponse, response);
                doneHandlerCalled = true;
            });

            service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler);

            Assert.IsTrue(doneHandlerCalled);
            Assert.IsTrue(fooCalled);
        }
        public void GeneratedStubFooCall()
        {
            FooRequest           fooRequest     = FooRequest.CreateBuilder().Build();
            MockRepository       mocks          = new MockRepository();
            IRpcChannel          mockChannel    = mocks.StrictMock <IRpcChannel>();
            IRpcController       mockController = mocks.StrictMock <IRpcController>();
            TestService          service        = TestService.CreateStub(mockChannel);
            Action <FooResponse> doneHandler    = mocks.StrictMock <Action <FooResponse> >();

            using (mocks.Record()) {
                // Nasty way of mocking out "the channel calls the done handler".
                Expect.Call(() => mockChannel.CallMethod(null, null, null, null, null))
                .IgnoreArguments()
                .Constraints(Is.Same(FooDescriptor), Is.Same(mockController), Is.Same(fooRequest),
                             Is.Same(FooResponse.DefaultInstance), Is.Anything())
                .Do((CallFooDelegate)((p1, p2, p3, response, done) => done(response)));
                doneHandler.Invoke(FooResponse.DefaultInstance);
            }

            service.Foo(mockController, fooRequest, doneHandler);

            mocks.VerifyAll();
        }