@Test
  public void testIgnoreModulesByFilter() {
    final ContainerAdaptor defaultAdaptor = mock(ContainerAdaptor.class);
    ProcessorA a = new ProcessorA();
    final ProcessorB b = new ProcessorB();
    ProcessorC c = new ProcessorC();
    List<ApplicationProcessor> processors = new ArrayList<ApplicationProcessor>();
    processors.add(a);
    processors.add(b);
    processors.add(c);
    when(defaultAdaptor.getInstancesOfType(ApplicationProcessor.class)).thenReturn(processors);
    ca = defaultAdaptor;
    builder.setModulesProviderClass(MockContainerAdaptorFactory.class);
    builder.addApplicationProcessorClass(ApplicationProcessor.class);
    MultiModule.Filter filter =
        new MultiModule.Filter() {

          @Override
          public boolean isAppreciable(MultiModule aMultiModule) {
            if (aMultiModule == b) {
              return false;
            }
            return true;
          }
        };
    builder.filter(filter);
    Modules modules = builder.buildModules(resolver, defaultAdaptor);
    List<ApplicationProcessor> actual = modules.getApplicationProcessors();
    log.debug(actual.toString());
    assertThat(actual.size(), is(2));
  }
 @Test
 public void testModuleClassUndefined() {
   thrown.expect(AssertionFailureException.class);
   builder.setModulesProviderClass(MockModulesProvidingContainerAdaptorFactory.class);
   Modules modules = builder.buildModules(resolver, adaptor);
   modules.getInvoker();
 }
 @Test
 public void testOptionalModulesFound() {
   ContainerAdaptor defaultAdaptor = mock(ContainerAdaptor.class);
   ApplicationProcessor foundProcessor = mock(ApplicationProcessor.class);
   List<ApplicationProcessor> processors = Arrays.asList(foundProcessor);
   when(defaultAdaptor.getInstancesOfType(ApplicationProcessor.class)).thenReturn(processors);
   builder.addApplicationProcessorClass(ApplicationProcessor.class);
   builder.setModulesProviderClass(MockModulesProvidingContainerAdaptorFactory.class);
   Modules modules = builder.buildModules(resolver, defaultAdaptor);
   adaptor.unregister(ApplicationProcessor.class);
   List<ApplicationProcessor> actual = modules.getApplicationProcessors();
   log.debug(actual.toString());
   assertThat(actual.size(), is(1));
   assertThat(actual.get(0), is(foundProcessor));
 }
 @Test
 @SuppressWarnings("unchecked")
 public void testOptionalModuleFound() {
   ContainerAdaptor defaultAdaptor = mock(ContainerAdaptor.class);
   Invoker foundInvoker = mock(Invoker.class);
   InvokerFactory factory = mock(InvokerFactory.class);
   when(factory.createInvoker(isA(List.class))).thenReturn(foundInvoker);
   when(defaultAdaptor.getInstanceOfType(InvokerFactory.class)).thenReturn(factory);
   builder.setInvokerFactoryClass(InvokerFactory.class);
   builder.setModulesProviderClass(MockModulesProvidingContainerAdaptorFactory.class);
   Modules modules = builder.buildModules(resolver, defaultAdaptor);
   adaptor.unregister(Invoker.class);
   builder.setTypeMapperContextClass(typeMapperContext.getClass());
   Invoker actual = modules.getInvoker();
   log.debug(actual.toString());
   assertThat(actual, is(foundInvoker));
 }
 @Test
 public void testIgnoreModules() {
   final ContainerAdaptor defaultAdaptor = mock(ContainerAdaptor.class);
   List<ApplicationProcessor> processors = new ArrayList<ApplicationProcessor>();
   processors.add(new ProcessorA());
   processors.add(new ProcessorB());
   processors.add(new ProcessorC());
   when(defaultAdaptor.getInstancesOfType(ApplicationProcessor.class)).thenReturn(processors);
   ca = defaultAdaptor;
   builder.setModulesProviderClass(MockContainerAdaptorFactory.class);
   builder.addApplicationProcessorClass(ApplicationProcessor.class);
   Modules modules = builder.buildModules(resolver, defaultAdaptor);
   List<ApplicationProcessor> actual = modules.getApplicationProcessors();
   log.debug(actual.toString());
   assertThat(actual.size(), is(3));
   builder.ignore(ProcessorB.class);
   modules = builder.buildModules(resolver, defaultAdaptor);
   actual = modules.getApplicationProcessors();
   log.debug(actual.toString());
   assertThat(actual.size(), is(1));
 }
  @Test
  public void testModulesNotFound() {
    thrown.expect(
        new NoDescribeMatcher<MissingModuleException>() {

          @Override
          public boolean matches(Object arg0) {
            if (arg0 instanceof MissingModuleException) {
              MissingModuleException mm = (MissingModuleException) arg0;
              assertThat(
                  mm.getRequiredModuleClass().getCanonicalName(),
                  is(InvokerFactory.class.getCanonicalName()));
              return true;
            }
            return false;
          }
        });
    builder.setModulesProviderClass(MockModulesProvidingContainerAdaptorFactory.class);
    builder.setInvokerFactoryClass(InvokerFactory.class);
    Modules modules = builder.buildModules(resolver, adaptor);
    modules.getInvoker();
  }
 @Test
 @SuppressWarnings({"rawtypes", "unchecked"})
 public void testIgnoreTypesUndefined() {
   thrown.expect(AssertionFailureException.class);
   builder.ignore((Class) null);
 }
 @Test
 public void testClearMultipleModules() {
   builder.addInvocationMetadataFactoriesClass(invocationMetadataFactory.getClass());
   builder.addApplicationProcessorClass(invocationProcessor.getClass());
   builder.addAttributesHandlerClass(attributesHandler.getClass());
   assertThat(builder.getInvocationMetadataFactoryClasses().size(), is(1));
   assertThat(builder.getApplicationProcessorClasses().size(), is(1));
   assertThat(builder.getAttributesHandlerClasses().size(), is(1));
   assertSame(builder, builder.clearInvocationMetadataFactoriesClass());
   assertTrue(builder.getInvocationMetadataFactoryClasses().isEmpty());
   assertSame(builder, builder.clearApplicationProcessorClass());
   assertTrue(builder.getApplicationProcessorClasses().isEmpty());
   assertSame(builder, builder.clearAttributesHanderClass());
   assertTrue(builder.getAttributesHandlerClasses().isEmpty());
 }
 @Test
 public void testBuildModulesWithNullContainerAdaptorFactory() {
   thrown.expect(MissingModulesProviderException.class);
   builder.setModulesProviderClass(MockNullContainerAdaptorFactory.class);
   builder.buildModules(resolver, adaptor);
 }
 @SuppressWarnings("unchecked")
 @Test
 public void testBuildModules() {
   builder.setModulesProviderClass(MockModulesProvidingContainerAdaptorFactory.class);
   builder.setInvocationFactoryClass(invocationFactory.getClass());
   builder.setInvocationInstanceProviderClass(
       (Class<? extends ContainerAdaptorFactory<? extends ContainerAdaptor>>)
           containerAdaptorFactory.getClass());
   builder.setInvokerFactoryClass(invokerFactory.getClass());
   builder.setResponseHandlerClass(directiontHandler.getClass());
   builder.setRenderableResolverClass(directionResolver.getClass());
   builder.addApplicationProcessorClass(invocationProcessor.getClass());
   builder.addInvocationInterceptorClass(invocationInterceptor.getClass());
   builder.addInvocationMetadataFactoriesClass(invocationMetadataFactory.getClass());
   builder.addAttributesHandlerClass(attributesHandler.getClass());
   builder.setExceptionHandlerClass(exceptionHandler.getClass());
   builder.setTypeMapperContextClass(typeMapperContext.getClass());
   Renderable mapToResponse = mock(Renderable.class);
   builder.addResponseFormatterClass(mapToResponse.getClass(), directionFormatter.getClass());
   Modules modules = builder.buildModules(resolver, adaptor);
   assertSame(modules.getInvocationMetadataFactories().get(0), invocationMetadataFactory);
   assertSame(modules.getInvocationInstanceProvider(), containerAdaptor);
   // same instance.
   assertSame(modules.getInvocationInstanceProvider(), containerAdaptor);
   assertSame(modules.getInvocationFactory(), invocationFactory);
   assertSame(modules.getResponseResolver(), directionResolver);
   assertSame(modules.getResponseHandler(), directiontHandler);
   assertSame(modules.getApplicationProcessors().get(0), invocationProcessor);
   assertSame(modules.getInvocationInterceptors().get(0), invocationInterceptor);
   assertSame(modules.getExceptionHandler(), exceptionHandler);
   assertSame(modules.getTypeMapperContext(), typeMapperContext);
   assertSame(modules.findResponseFormatter(mapToResponse.getClass()), directionFormatter);
 }