Finished service test with a mock.

csharp/ProtocolBuffers.Test/ServiceTest.cs

@@ -2,6 +2,8 @@
 using Google.ProtocolBuffers.Descriptors;
 using Google.ProtocolBuffers.TestProtos;
 using NUnit.Framework;
+using Rhino.Mocks;
+using Rhino.Mocks.Constraints;
 
 namespace Google.ProtocolBuffers {
 
@@ -12,33 +14,150 @@ namespace Google.ProtocolBuffers {
   [TestFixture]
   public class ServiceTest {
 
+    delegate void Action<T1, T2>(T1 t1, T2 t2);
+
     private static readonly MethodDescriptor FooDescriptor = TestService.Descriptor.Methods[0];
     private static readonly MethodDescriptor BarDescriptor = TestService.Descriptor.Methods[1];
 
     [Test]
     public void GetRequestPrototype() {
-      TestService mockService = new TestServiceImpl();
+      TestService service = new TestServiceImpl();
 
-      Assert.AreSame(mockService.GetRequestPrototype(FooDescriptor), FooRequest.DefaultInstance);
-      Assert.AreSame(mockService.GetRequestPrototype(BarDescriptor), BarRequest.DefaultInstance);
+      Assert.AreSame(service.GetRequestPrototype(FooDescriptor), FooRequest.DefaultInstance);
+      Assert.AreSame(service.GetRequestPrototype(BarDescriptor), BarRequest.DefaultInstance);
     }
 
     [Test]
     public void GetResponsePrototype() {
-      TestService mockService = new TestServiceImpl();
+      TestService service = new TestServiceImpl();
+
+      Assert.AreSame(service.GetResponsePrototype(FooDescriptor), FooResponse.DefaultInstance);
+      Assert.AreSame(service.GetResponsePrototype(BarDescriptor), BarResponse.DefaultInstance);
+    }
+
+    [Test]
+    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();
+    }
+
+    delegate void CallFooDelegate(MethodDescriptor descriptor, IRpcController controller,
+        IMessage request, IMessage response, Action<IMessage> doneHandler);
+
+    /// <summary>
+    /// Tests the generated stub handling of Foo. By this stage we're reasonably confident
+    /// that the choice between Foo and Bar is arbitrary, hence the lack of a corresponding Bar
+    /// test.
+    /// </summary>
+    [Test]
+    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);
+      }
 
-      Assert.AreSame(mockService.GetResponsePrototype(FooDescriptor), FooResponse.DefaultInstance);
-      Assert.AreSame(mockService.GetResponsePrototype(BarDescriptor), BarResponse.DefaultInstance);
+      service.Foo(mockController, fooRequest, doneHandler);
+
+      mocks.VerifyAll();
+    }
+
+    [Test]
+    public void CallMethodBar() {
+      MockRepository mocks = new MockRepository();
+      BarRequest barRequest = BarRequest.CreateBuilder().Build();
+      BarResponse barResponse = BarResponse.CreateBuilder().Build();
+      IRpcController controller = mocks.StrictMock<IRpcController>();
+
+      bool barCalled = false;
+
+      TestService service = new TestServiceImpl(null, (request, responseAction) => {
+        Assert.AreSame(barRequest, request);
+        barCalled = true;
+        responseAction(barResponse);
+      }, controller);
+
+      bool doneHandlerCalled = false;
+      Action<IMessage> doneHandler = (response => {
+        Assert.AreSame(barResponse, response);
+        doneHandlerCalled = true;
+      });
+
+      using (mocks.Record()) {
+        // No mock interactions to record
+      }
+
+      service.CallMethod(BarDescriptor, controller, barRequest, doneHandler);
+
+      Assert.IsTrue(doneHandlerCalled);
+      Assert.IsTrue(barCalled);
+      mocks.VerifyAll();
     }
     
+    
     class TestServiceImpl : TestService {
+      private readonly Action<FooRequest, Action<FooResponse>> fooHandler;
+      private readonly Action<BarRequest, Action<BarResponse>> barHandler;
+      private readonly IRpcController expectedController;
+
+      internal TestServiceImpl() {
+      }
+
+      internal TestServiceImpl(Action<FooRequest, Action<FooResponse>> fooHandler,
+          Action<BarRequest, Action<BarResponse>> barHandler,
+          IRpcController expectedController) {
+        this.fooHandler = fooHandler;
+        this.barHandler = barHandler;
+        this.expectedController = expectedController;
+      }
+
       public override void Foo(IRpcController controller, FooRequest request, Action<FooResponse> done) {
-        throw new System.NotImplementedException();
+        Assert.AreSame(expectedController, controller);
+        fooHandler(request, done);
       }
 
       public override void Bar(IRpcController controller, BarRequest request, Action<BarResponse> done) {
-        throw new System.NotImplementedException();
+        Assert.AreSame(expectedController, controller);
+        barHandler(request, done);
       }
-    }
+    }    
   }
 }

csharp/ProtocolBuffers.Test/lib/nunit-license.txt

+Copyright © 2002-2007 Charlie Poole
+Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov
+Copyright © 2000-2002 Philip A. Craig
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required.
+
+Portions Copyright © 2002-2007 Charlie Poole or Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright © 2000-2002 Philip A. Craig
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

csharp/ProtocolBuffers.Test/lib/rhino-license.txt

+Copyright (c) 2005 - 2008 Ayende Rahien (ayende@ayende.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+    * Neither the name of Ayende Rahien nor the names of its
+    contributors may be used to endorse or promote products derived from this
+    software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file