HierarchicalTest.java

/*
 * Copyright 2008 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.gwt.inject.client.hierarchical;

import com.google.gwt.core.client.GWT;
import com.google.gwt.inject.client.AbstractGinModule;
import com.google.gwt.inject.client.GinModules;
import com.google.gwt.inject.client.Ginjector;
import com.google.gwt.inject.client.SimpleObject;
import com.google.gwt.junit.client.GWTTestCase;
import com.google.inject.Inject;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.google.inject.TypeLiteral;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Gin tests using a {@code Ginjector} type hierarchy.
 */
public class HierarchicalTest extends GWTTestCase {
  public void testHierarchicalInjector() {
    HierarchicalMyAppGinjector injector = GWT.create(HierarchicalMyAppGinjector.class);

    SimpleObject simple = injector.getSimple();
    assertNotNull(simple);

    SimpleObject unnamedSimple = injector.getUnnamedSimple();
    assertNotNull(unnamedSimple);
    assertSame(simple, unnamedSimple);

    SimpleObject purple = injector.getSimplePurple();
    assertNotNull(purple);
    assertSame(simple, purple);

    SimpleObject red = injector.getSimpleRed();
    assertNotNull(red);
    assertSame(purple, red);

    SimpleObject blue = injector.getSimpleBlue();
    assertNotNull(blue);
    assertSame(blue, red);
  }

  public void testOverlappingModules() {
    ChildGinjector ginjector = GWT.create(ChildGinjector.class);

    assertEquals("foo", ginjector.getRed());
    assertEquals("bar", ginjector.getBlue());
    assertEquals("baz", ginjector.getGreen());
  }

  public void testModuleInitializationOrder() {
    ChildGinjector ginjector = GWT.create(ChildGinjector.class);

    List<?> expectedOrder = Arrays.asList(GinModuleA.class, GinModuleC.class, GinModuleB.class);
    assertEquals(expectedOrder, ginjector.getModuleInitializationList());
  }

  public void testInheritedNonGinjector() {
    InheritingGinjector ginjector = GWT.create(InheritingGinjector.class);
    assertEquals("foo", ginjector.getString());
  }

  public String getModuleName() {
    return "com.google.gwt.inject.InjectTest";
  }


  @Singleton
  public static class ModuleInitializationList extends ArrayList<Object> {}

  public static class InitializationMarker<T> {
    @Inject
    InitializationMarker(T module, ModuleInitializationList list) {
      list.add(module.getClass());
    }
  }

  public static class GinModuleA extends AbstractGinModule {
    @Override
    protected void configure() {
      bindConstant().annotatedWith(Names.named("red")).to("foo");
      bind(new TypeLiteral<InitializationMarker<GinModuleA>>(){}).asEagerSingleton();
    }
  }

  public static class GinModuleB extends AbstractGinModule {
    @Override
    protected void configure() {
      bindConstant().annotatedWith(Names.named("blue")).to("bar");
      bind(new TypeLiteral<InitializationMarker<GinModuleB>>(){}).asEagerSingleton();
    }
  }

  public static class GinModuleC extends AbstractGinModule {
    @Override
    protected void configure() {
      bindConstant().annotatedWith(Names.named("green")).to("baz");
      bind(new TypeLiteral<InitializationMarker<GinModuleC>>(){}).asEagerSingleton();
    }
  }

  @GinModules({GinModuleA.class, GinModuleC.class})
  public static interface SuperGinjector extends Ginjector {
    @Named("red") String getRed();

    @Named("green") String getGreen();

    ModuleInitializationList getModuleInitializationList();
  }

  @GinModules({GinModuleB.class, GinModuleC.class})
  public static interface ChildGinjector extends SuperGinjector {
    @Named("blue") String getBlue();
  }

  static class SimpleGinModule extends AbstractGinModule {

    @Override
    protected void configure() {}

    @Provides
    String provideString() {
      return "foo";
    }
  }

  interface RandomInterface {
    String getString();
  }

  @GinModules(SimpleGinModule.class)
  interface InheritingGinjector extends RandomInterface, Ginjector {}
}