AbstractInjectTestCase.java

/*
 * Copyright 2013 eXo Platform SAS
 *
 * 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 inject;

import juzu.Scope;
import juzu.Handler;
import juzu.impl.inject.Scoped;
import juzu.impl.fs.spi.ReadFileSystem;
import juzu.impl.fs.spi.disk.DiskFileSystem;
import juzu.impl.inject.spi.Injector;
import juzu.impl.inject.spi.InjectorProvider;
import juzu.impl.inject.spi.InjectionContext;

import java.io.File;

/** @author <a href="mailto:julien.viet@exoplatform.com">Julien Viet</a> */
public abstract class AbstractInjectTestCase<B, I> extends juzu.test.AbstractInjectTestCase {

  /** . */
  protected Injector bootstrap;

  /** . */
  protected InjectionContext<B, I> mgr;

  /** . */
  protected ReadFileSystem<?> fs;

  /** . */
  protected ScopingContextImpl scopingContext;

  public AbstractInjectTestCase(InjectorProvider di) {
    super(di);
  }

  protected final void init() throws Exception {
    init(getClass().getPackage().getName());
  }

  protected final void init(String pkg) throws Exception {
    File root = new File(AbstractInjectTestCase.class.getProtectionDomain().getCodeSource().getLocation().toURI());
    assertTrue(root.exists());
    assertTrue(root.isDirectory());
    init(new DiskFileSystem(root, pkg), Thread.currentThread().getContextClassLoader());
  }

  protected final void init(ReadFileSystem<?> fs, ClassLoader classLoader) throws Exception {
    Injector bootstrap = getManager();
    bootstrap.addFileSystem(fs);
    bootstrap.setClassLoader(classLoader);

    //
    this.bootstrap = bootstrap;
    this.fs = fs;
  }

  protected final void boot(Scope... scopes) throws Exception {
    boot((Handler<Class<?>, Boolean>)null, scopes);
  }

  protected final void boot(Handler<Class<?>, Boolean> filter, Scope... scopes) throws Exception {
    mgr = boot(bootstrap, filter, scopes);
  }

  protected static <B, I> InjectionContext<B, I> boot(Injector injector, Scope... scopes) throws Exception {
    return boot(injector, null, scopes);
  }

  protected static <B, I> InjectionContext<B, I> boot(Injector injector, Handler<Class<?>, Boolean> filter, Scope... scopes) throws Exception {
    for (Scope scope : scopes) {
      injector.addScope(scope);
    }
    if (filter == null) {
      return (InjectionContext<B, I>)injector.create();
    } else {
      return (InjectionContext<B, I>)injector.create(filter);
    }
  }

  protected final <T> T getBean(Class<T> beanType) throws Exception {
    return getBean(mgr, beanType);
  }

  protected static <B, I, T> T getBean(InjectionContext<B, I> context, Class<T> beanType) throws Exception {
    B bean = context.resolveBean(beanType);
    assertNotNull("Could not resolve bean of type " + beanType, bean);
    I beanInstance = context.createContext(bean);
    assertNotNull("Could not create bean instance of type " + beanType + " from bean " + bean, beanInstance);
    Object o = context.getInstance(bean, beanInstance);
    assertNotNull("Could not obtain bean object from bean instance " + beanInstance + " of type " + beanType, o);
    return beanType.cast(o);
  }

  protected final Object getBean(String beanName) throws Exception {
    B bean = mgr.resolveBean(beanName);
    assertNotNull("Could not find bean " + beanName, bean);
    I beanInstance = mgr.createContext(bean);
    assertNotNull(beanInstance);
    return mgr.getInstance(bean, beanInstance);
  }

  protected final void beginScoping() throws Exception {
    if (scopingContext != null) {
      throw failure("Already scoping");
    }
    mgr.getScopeController().begin(scopingContext = new ScopingContextImpl());
  }

  protected final void endScoping() throws Exception {
    if (scopingContext == null) {
      throw failure("Not scoping");
    }
    mgr.getScopeController().end();
    for (Scoped scoped : scopingContext.getEntries().values()) {
      scoped.destroy();
    }
    scopingContext = null;
  }

  protected final Injector getManager() throws Exception {
    return getDI().get();
  }
}