1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2008 Google Inc. All rights reserved. 3 // http://code.google.com/p/protobuf/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 package com.google.protobuf; 32 33 import com.google.protobuf.Descriptors.FileDescriptor; 34 import com.google.protobuf.Descriptors.MethodDescriptor; 35 import google.protobuf.no_generic_services_test.UnittestNoGenericServices; 36 import protobuf_unittest.MessageWithNoOuter; 37 import protobuf_unittest.ServiceWithNoOuter; 38 import protobuf_unittest.UnittestProto.TestAllTypes; 39 import protobuf_unittest.UnittestProto.TestService; 40 import protobuf_unittest.UnittestProto.FooRequest; 41 import protobuf_unittest.UnittestProto.FooResponse; 42 import protobuf_unittest.UnittestProto.BarRequest; 43 import protobuf_unittest.UnittestProto.BarResponse; 44 45 import org.easymock.classextension.EasyMock; 46 import org.easymock.classextension.IMocksControl; 47 import org.easymock.IArgumentMatcher; 48 49 import java.util.HashSet; 50 import java.util.Set; 51 52 import junit.framework.TestCase; 53 54 /** 55 * Tests services and stubs. 56 * 57 * @author kenton@google.com Kenton Varda 58 */ 59 public class ServiceTest extends TestCase { 60 private IMocksControl control; 61 private RpcController mockController; 62 63 private final Descriptors.MethodDescriptor fooDescriptor = 64 TestService.getDescriptor().getMethods().get(0); 65 private final Descriptors.MethodDescriptor barDescriptor = 66 TestService.getDescriptor().getMethods().get(1); 67 68 @Override setUp()69 protected void setUp() throws Exception { 70 super.setUp(); 71 control = EasyMock.createStrictControl(); 72 mockController = control.createMock(RpcController.class); 73 } 74 75 // ================================================================= 76 77 /** Tests Service.callMethod(). */ testCallMethod()78 public void testCallMethod() throws Exception { 79 FooRequest fooRequest = FooRequest.newBuilder().build(); 80 BarRequest barRequest = BarRequest.newBuilder().build(); 81 MockCallback<Message> fooCallback = new MockCallback<Message>(); 82 MockCallback<Message> barCallback = new MockCallback<Message>(); 83 TestService mockService = control.createMock(TestService.class); 84 85 mockService.foo(EasyMock.same(mockController), EasyMock.same(fooRequest), 86 this.<FooResponse>wrapsCallback(fooCallback)); 87 mockService.bar(EasyMock.same(mockController), EasyMock.same(barRequest), 88 this.<BarResponse>wrapsCallback(barCallback)); 89 control.replay(); 90 91 mockService.callMethod(fooDescriptor, mockController, 92 fooRequest, fooCallback); 93 mockService.callMethod(barDescriptor, mockController, 94 barRequest, barCallback); 95 control.verify(); 96 } 97 98 /** Tests Service.get{Request,Response}Prototype(). */ testGetPrototype()99 public void testGetPrototype() throws Exception { 100 TestService mockService = control.createMock(TestService.class); 101 102 assertSame(mockService.getRequestPrototype(fooDescriptor), 103 FooRequest.getDefaultInstance()); 104 assertSame(mockService.getResponsePrototype(fooDescriptor), 105 FooResponse.getDefaultInstance()); 106 assertSame(mockService.getRequestPrototype(barDescriptor), 107 BarRequest.getDefaultInstance()); 108 assertSame(mockService.getResponsePrototype(barDescriptor), 109 BarResponse.getDefaultInstance()); 110 } 111 112 /** Tests generated stubs. */ testStub()113 public void testStub() throws Exception { 114 FooRequest fooRequest = FooRequest.newBuilder().build(); 115 BarRequest barRequest = BarRequest.newBuilder().build(); 116 MockCallback<FooResponse> fooCallback = new MockCallback<FooResponse>(); 117 MockCallback<BarResponse> barCallback = new MockCallback<BarResponse>(); 118 RpcChannel mockChannel = control.createMock(RpcChannel.class); 119 TestService stub = TestService.newStub(mockChannel); 120 121 mockChannel.callMethod( 122 EasyMock.same(fooDescriptor), 123 EasyMock.same(mockController), 124 EasyMock.same(fooRequest), 125 EasyMock.same(FooResponse.getDefaultInstance()), 126 this.<Message>wrapsCallback(fooCallback)); 127 mockChannel.callMethod( 128 EasyMock.same(barDescriptor), 129 EasyMock.same(mockController), 130 EasyMock.same(barRequest), 131 EasyMock.same(BarResponse.getDefaultInstance()), 132 this.<Message>wrapsCallback(barCallback)); 133 control.replay(); 134 135 stub.foo(mockController, fooRequest, fooCallback); 136 stub.bar(mockController, barRequest, barCallback); 137 control.verify(); 138 } 139 140 /** Tests generated blocking stubs. */ testBlockingStub()141 public void testBlockingStub() throws Exception { 142 FooRequest fooRequest = FooRequest.newBuilder().build(); 143 BarRequest barRequest = BarRequest.newBuilder().build(); 144 BlockingRpcChannel mockChannel = 145 control.createMock(BlockingRpcChannel.class); 146 TestService.BlockingInterface stub = 147 TestService.newBlockingStub(mockChannel); 148 149 FooResponse fooResponse = FooResponse.newBuilder().build(); 150 BarResponse barResponse = BarResponse.newBuilder().build(); 151 152 EasyMock.expect(mockChannel.callBlockingMethod( 153 EasyMock.same(fooDescriptor), 154 EasyMock.same(mockController), 155 EasyMock.same(fooRequest), 156 EasyMock.same(FooResponse.getDefaultInstance()))).andReturn(fooResponse); 157 EasyMock.expect(mockChannel.callBlockingMethod( 158 EasyMock.same(barDescriptor), 159 EasyMock.same(mockController), 160 EasyMock.same(barRequest), 161 EasyMock.same(BarResponse.getDefaultInstance()))).andReturn(barResponse); 162 control.replay(); 163 164 assertSame(fooResponse, stub.foo(mockController, fooRequest)); 165 assertSame(barResponse, stub.bar(mockController, barRequest)); 166 control.verify(); 167 } 168 testNewReflectiveService()169 public void testNewReflectiveService() { 170 ServiceWithNoOuter.Interface impl = 171 control.createMock(ServiceWithNoOuter.Interface.class); 172 RpcController controller = control.createMock(RpcController.class); 173 Service service = ServiceWithNoOuter.newReflectiveService(impl); 174 175 MethodDescriptor fooMethod = 176 ServiceWithNoOuter.getDescriptor().findMethodByName("Foo"); 177 MessageWithNoOuter request = MessageWithNoOuter.getDefaultInstance(); 178 RpcCallback<Message> callback = new RpcCallback<Message>() { 179 public void run(Message parameter) { 180 // No reason this should be run. 181 fail(); 182 } 183 }; 184 RpcCallback<TestAllTypes> specializedCallback = 185 RpcUtil.specializeCallback(callback); 186 187 impl.foo(EasyMock.same(controller), EasyMock.same(request), 188 EasyMock.same(specializedCallback)); 189 EasyMock.expectLastCall(); 190 191 control.replay(); 192 193 service.callMethod(fooMethod, controller, request, callback); 194 195 control.verify(); 196 } 197 testNewReflectiveBlockingService()198 public void testNewReflectiveBlockingService() throws ServiceException { 199 ServiceWithNoOuter.BlockingInterface impl = 200 control.createMock(ServiceWithNoOuter.BlockingInterface.class); 201 RpcController controller = control.createMock(RpcController.class); 202 BlockingService service = 203 ServiceWithNoOuter.newReflectiveBlockingService(impl); 204 205 MethodDescriptor fooMethod = 206 ServiceWithNoOuter.getDescriptor().findMethodByName("Foo"); 207 MessageWithNoOuter request = MessageWithNoOuter.getDefaultInstance(); 208 RpcCallback<Message> callback = new RpcCallback<Message>() { 209 public void run(Message parameter) { 210 // No reason this should be run. 211 fail(); 212 } 213 }; 214 215 TestAllTypes expectedResponse = TestAllTypes.getDefaultInstance(); 216 EasyMock.expect(impl.foo(EasyMock.same(controller), EasyMock.same(request))) 217 .andReturn(expectedResponse); 218 219 control.replay(); 220 221 Message response = 222 service.callBlockingMethod(fooMethod, controller, request); 223 assertEquals(expectedResponse, response); 224 225 control.verify(); 226 } 227 testNoGenericServices()228 public void testNoGenericServices() throws Exception { 229 // Non-services should be usable. 230 UnittestNoGenericServices.TestMessage message = 231 UnittestNoGenericServices.TestMessage.newBuilder() 232 .setA(123) 233 .setExtension(UnittestNoGenericServices.testExtension, 456) 234 .build(); 235 assertEquals(123, message.getA()); 236 assertEquals(1, UnittestNoGenericServices.TestEnum.FOO.getNumber()); 237 238 // Build a list of the class names nested in UnittestNoGenericServices. 239 String outerName = "google.protobuf.no_generic_services_test." + 240 "UnittestNoGenericServices"; 241 Class<?> outerClass = Class.forName(outerName); 242 243 Set<String> innerClassNames = new HashSet<String>(); 244 for (Class<?> innerClass : outerClass.getClasses()) { 245 String fullName = innerClass.getName(); 246 // Figure out the unqualified name of the inner class. 247 // Note: Surprisingly, the full name of an inner class will be separated 248 // from the outer class name by a '$' rather than a '.'. This is not 249 // mentioned in the documentation for java.lang.Class. I don't want to 250 // make assumptions, so I'm just going to accept any character as the 251 // separator. 252 assertTrue(fullName.startsWith(outerName)); 253 innerClassNames.add(fullName.substring(outerName.length() + 1)); 254 } 255 256 // No service class should have been generated. 257 assertTrue(innerClassNames.contains("TestMessage")); 258 assertTrue(innerClassNames.contains("TestEnum")); 259 assertFalse(innerClassNames.contains("TestService")); 260 261 // But descriptors are there. 262 FileDescriptor file = UnittestNoGenericServices.getDescriptor(); 263 assertEquals(1, file.getServices().size()); 264 assertEquals("TestService", file.getServices().get(0).getName()); 265 assertEquals(1, file.getServices().get(0).getMethods().size()); 266 assertEquals("Foo", 267 file.getServices().get(0).getMethods().get(0).getName()); 268 } 269 270 // ================================================================= 271 272 /** 273 * wrapsCallback() is an EasyMock argument predicate. wrapsCallback(c) 274 * matches a callback if calling that callback causes c to be called. 275 * In other words, c wraps the given callback. 276 */ wrapsCallback( MockCallback<?> callback)277 private <Type extends Message> RpcCallback<Type> wrapsCallback( 278 MockCallback<?> callback) { 279 EasyMock.reportMatcher(new WrapsCallback(callback)); 280 return null; 281 } 282 283 /** The parameter to wrapsCallback() must be a MockCallback. */ 284 private static class MockCallback<Type extends Message> 285 implements RpcCallback<Type> { 286 private boolean called = false; 287 isCalled()288 public boolean isCalled() { return called; } 289 reset()290 public void reset() { called = false; } run(Type message)291 public void run(Type message) { called = true; } 292 } 293 294 /** Implementation of the wrapsCallback() argument matcher. */ 295 private static class WrapsCallback implements IArgumentMatcher { 296 private MockCallback<?> callback; 297 WrapsCallback(MockCallback<?> callback)298 public WrapsCallback(MockCallback<?> callback) { 299 this.callback = callback; 300 } 301 302 @SuppressWarnings("unchecked") matches(Object actual)303 public boolean matches(Object actual) { 304 if (!(actual instanceof RpcCallback)) { 305 return false; 306 } 307 RpcCallback actualCallback = (RpcCallback)actual; 308 309 callback.reset(); 310 actualCallback.run(null); 311 return callback.isCalled(); 312 } 313 appendTo(StringBuffer buffer)314 public void appendTo(StringBuffer buffer) { 315 buffer.append("wrapsCallback(mockCallback)"); 316 } 317 } 318 } 319