| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.web.bindery.requestfactory.gwt.client; |
| |
| import com.google.gwt.core.client.GWT; |
| import com.google.web.bindery.event.shared.SimpleEventBus; |
| import com.google.web.bindery.requestfactory.shared.ProxyFor; |
| import com.google.web.bindery.requestfactory.shared.Receiver; |
| import com.google.web.bindery.requestfactory.shared.Request; |
| import com.google.web.bindery.requestfactory.shared.RequestContext; |
| import com.google.web.bindery.requestfactory.shared.RequestFactory; |
| import com.google.web.bindery.requestfactory.shared.Service; |
| import com.google.web.bindery.requestfactory.shared.SimpleBarProxy; |
| import com.google.web.bindery.requestfactory.shared.SimpleBarRequest; |
| import com.google.web.bindery.requestfactory.shared.SimpleFooProxy; |
| import com.google.web.bindery.requestfactory.shared.SimpleFooRequest; |
| import com.google.web.bindery.requestfactory.shared.ValueProxy; |
| |
| /** |
| * Tests various aspects of how {@code RequestContext.append()} behaves. |
| */ |
| public class RequestFactoryChainedContextTest extends RequestFactoryTestBase { |
| /** |
| * A RequestFactory where the contained RequestContext types have disjoint |
| * reachable proxy types. |
| */ |
| protected interface Factory extends RequestFactory { |
| ACtx a(); |
| |
| BCtx b(); |
| } |
| |
| /** |
| * Mandatory javadoc comment. |
| */ |
| public static class A { |
| public static A a() { |
| return new A(); |
| } |
| } |
| |
| @Service(A.class) |
| interface ACtx extends RequestContext { |
| Request<AProxy> a(); |
| } |
| |
| @ProxyFor(A.class) |
| interface AProxy extends ValueProxy { |
| } |
| |
| /** |
| * Mandatory javadoc comment. |
| */ |
| public static class B { |
| public static B b() { |
| return new B(); |
| } |
| } |
| |
| @Service(B.class) |
| interface BCtx extends RequestContext { |
| Request<BProxy> b(); |
| } |
| |
| @ProxyFor(B.class) |
| interface BProxy extends ValueProxy { |
| } |
| |
| private static final int DELAY_TEST_FINISH = 5000; |
| |
| @Override |
| public String getModuleName() { |
| return "com.google.web.bindery.requestfactory.gwt.RequestFactorySuite"; |
| } |
| |
| /** |
| * Basic functional test of the append method. |
| */ |
| public void testAppend() { |
| delayTestFinish(DELAY_TEST_FINISH); |
| SimpleFooRequest fooCtx1 = req.simpleFooRequest(); |
| SimpleFooProxy foo1 = fooCtx1.create(SimpleFooProxy.class); |
| SimpleBarRequest barCtx = fooCtx1.append(req.simpleBarRequest()); |
| SimpleFooRequest fooCtx2 = barCtx.append(req.simpleFooRequest()); |
| |
| assertNotSame(fooCtx1, fooCtx2); |
| assertSame(foo1, barCtx.edit(foo1)); |
| assertSame(foo1, fooCtx2.edit(foo1)); |
| |
| SimpleBarProxy foo2 = barCtx.create(SimpleBarProxy.class); |
| assertSame(foo2, fooCtx1.edit(foo2)); |
| assertSame(foo2, fooCtx2.edit(foo2)); |
| |
| SimpleFooProxy foo3 = fooCtx2.create(SimpleFooProxy.class); |
| assertSame(foo3, fooCtx1.edit(foo3)); |
| assertSame(foo3, barCtx.edit(foo3)); |
| |
| try { |
| // Throws exception because c3 has already accumulated some state |
| req.simpleValueContext().append(fooCtx2); |
| fail("Should have thrown IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| |
| try { |
| // Throws exception because a different RequestFactory instance is used |
| fooCtx2.append(createFactory().simpleFooRequest()); |
| fail("Should have thrown IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| |
| // Queue up two invocations, and test that both Receivers are called |
| final boolean[] seen = {false, false}; |
| fooCtx1.add(1, 2).to(new Receiver<Integer>() { |
| @Override |
| public void onSuccess(Integer response) { |
| seen[0] = true; |
| assertEquals(3, response.intValue()); |
| } |
| }); |
| barCtx.countSimpleBar().to(new Receiver<Long>() { |
| @Override |
| public void onSuccess(Long response) { |
| seen[1] = true; |
| assertEquals(2, response.longValue()); |
| } |
| }); |
| |
| // It doesn't matter which context instance is fired |
| barCtx.fire(new Receiver<Void>() { |
| @Override |
| public void onSuccess(Void response) { |
| assertTrue(seen[0]); |
| assertTrue(seen[1]); |
| finishTestAndReset(); |
| } |
| }); |
| |
| /* |
| * Since the common State has been locked, calling any other |
| * context-mutation methods should fail. |
| */ |
| try { |
| fooCtx1.fire(); |
| fail("Should have thrown exception"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| fooCtx2.fire(); |
| fail("Should have thrown exception"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| fooCtx2.create(SimpleFooProxy.class); |
| fail("Should have thrown exception"); |
| } catch (IllegalStateException expected) { |
| } |
| } |
| |
| /** |
| * Ensure that a method invoked on an appended context can result in the |
| * creation of a proxy not reachable from canonical context. |
| */ |
| public void testChainedProxyInstantiation() { |
| delayTestFinish(DELAY_TEST_FINISH); |
| Factory f = createChainedFactory(); |
| |
| ACtx aCtx = f.a(); |
| checkReachableTypes(aCtx, AProxy.class, BProxy.class); |
| |
| RequestContext ctx = aCtx.a().to(new Receiver<AProxy>() { |
| @Override |
| public void onSuccess(AProxy response) { |
| assertNotNull(response); |
| } |
| }); |
| |
| BCtx bCtx = ctx.append(f.b()); |
| checkReachableTypes(aCtx, AProxy.class, BProxy.class); |
| checkReachableTypes(bCtx, BProxy.class, AProxy.class); |
| |
| bCtx.b().to(new Receiver<BProxy>() { |
| @Override |
| public void onSuccess(BProxy response) { |
| assertNotNull(response); |
| } |
| }); |
| ctx.fire(new Receiver<Void>() { |
| @Override |
| public void onSuccess(Void response) { |
| finishTest(); |
| } |
| }); |
| } |
| |
| protected Factory createChainedFactory() { |
| Factory f = GWT.create(Factory.class); |
| f.initialize(new SimpleEventBus()); |
| return f; |
| } |
| } |