user/test/com/google/web/bindery/requestfactory/gwt/client/RequestFactoryChainedContextTest.java

/*
 * 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;
  }
}