8. Developer examples

package com.greenpepper.extensions.guice;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Module;
import com.greenpepper.reflect.DefaultFixture;
import com.greenpepper.reflect.Fixture;
import com.greenpepper.systemunderdevelopment.DefaultSystemUnderDevelopment;

public class GuiceSystemUnderDevelopment extends DefaultSystemUnderDevelopment
{

	private Injector injector;
	private List<String> moduleNames = new ArrayList<String>();

	public GuiceSystemUnderDevelopment()
	{
	}

	public GuiceSystemUnderDevelopment(String... moduleNames)
	{
		Collections.addAll(this.moduleNames, moduleNames);
	}

	@Override
	public Fixture getFixture(String name, String... params)
			throws Throwable
	{
		lazilyInstantiateModulesAndInjector();

		Fixture fixture;

		if (params.length != 0)
		{
			// When params are used, we use the PlainOldSystemUnderDevelopment to instantiate the fixture
			// these params are passed to the constructor
			// Then we use Guice to inject members
			fixture = super.getFixture(name, params);
			injector.injectMembers(fixture.getTarget());
		}
		else
		{
			// Use Guice to instantiate
			Class<?> klass = loadType(name).getUnderlyingClass();
			Object target = injector.getInstance(klass);
			fixture = new DefaultFixture(target);
		}

		return fixture;
	}

	private void lazilyInstantiateModulesAndInjector()
			throws Exception
	{
		if (injector == null)
		{
			List<Module> modules = convertModuleNamesToModules();
			injector = Guice.createInjector(modules);
		}
	}

	private List<Module> convertModuleNamesToModules()
			throws Exception
	{
		List<Module> modules = new ArrayList<Module>(moduleNames.size());
		for (String moduleName : moduleNames)
		{
			Class<?> klass = loadType(moduleName).getUnderlyingClass();
			modules.add((Module)klass.newInstance());
		}
		return modules;
	}

	public void addModules(String... moduleNames)
	{
		if (injector == null)
		{
			Collections.addAll(this.moduleNames, moduleNames);
		}
		else
		{
			throw new IllegalStateException("Cannot add module after a fixture has been instantiated");
		}
	}
}

package com.greenpepper.extensions.spring;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;

import com.greenpepper.reflect.DefaultFixture;
import com.greenpepper.reflect.Fixture;
import com.greenpepper.systemunderdevelopment.DefaultSystemUnderDevelopment;

public class SpringSystemUnderDevelopment extends DefaultSystemUnderDevelopment
{
    private BeanFactory beanFactory;

    public SpringSystemUnderDevelopment(String... applicationCtxes)
    {
        this.beanFactory = new GreenPepperXMLAplicationContext(applicationCtxes).getBeanFactory();
    }
	
    public SpringSystemUnderDevelopment(BeanFactory beanFactory)
    {
        this.beanFactory = beanFactory;
    }

    @Override
    public Fixture getFixture(String fixtureName, String... params) throws Throwable
    {
		Fixture fixture;
		if (params.length != 0)
        {
		    // When params are used, we use the PlainOldSystemUnderDevelopment to instantiate the fixture
			// these params are passed to the constructor
            fixture = super.getFixture(fixtureName, params);
        }
		else
		{
	        try
	        {
	            fixture = new DefaultFixture(beanFactory.getBean(fixtureName));
	        }
	        catch (NoSuchBeanDefinitionException e)
	        {
	            fixture = new DefaultFixture(instantiateAsAutowiredBean(fixtureName));
	        }
		}
		
		return fixture;
    }

    private Object instantiateAsAutowiredBean(String fixtureName) throws Exception
    {
        Class fixtureClass = loadType(fixtureName).getUnderlyingClass();

        BeanDefinition beanDef = new RootBeanDefinition(fixtureClass, RootBeanDefinition.AUTOWIRE_AUTODETECT);
        
        DefaultListableBeanFactory fallFactory = new DefaultListableBeanFactory(beanFactory);
        fallFactory.registerBeanDefinition(fixtureName, beanDef);

        return fallFactory.getBean(fixtureName);
    }
}

<configuration>
    <components>
        <component id="Windsor.HelloWorld" type="GreenPepper.WindsorCastle.Fixtures.WindsorHelloWorld, GreenPepper.Extensions">
            <parameters>
            	<injectedConstructor>hello constructor</injectedConstructor>
                <injectedProperty>hello property</injectedProperty>
            </parameters>
        </component>

        <component id="Windsor.component1" 
        	type="GreenPepper.WindsorCastle.Fixtures.MyComponent1, GreenPepper.Extensions">
        </component>
        
        <component id="Windsor.component2"
        	type="GreenPepper.WindsorCastle.Fixtures.MyComponent2, GreenPepper.Extensions">
        </component>
        
        <component id="Windsor.AutoWired" type="GreenPepper.WindsorCastle.Fixtures.WindsorAutoWiredFixture, GreenPepper.Extensions" />
    </components>
</configuration>

using System;
using Castle.MicroKernel;
using Castle.Windsor;
using GreenPepper.Fixtures;
using GreenPepper.Reflect;

namespace GreenPepper.WindsorCastle
{
    public class WindsorSystemUnderDevelopment : PlainOldSystemUnderDevelopment
    {
        private IWindsorContainer container;

        public WindsorSystemUnderDevelopment(IWindsorContainer container)
        {
            this.container = container;
        }

        public WindsorSystemUnderDevelopment():this(new WindsorContainer())
        {    
        }

        public WindsorSystemUnderDevelopment(params string[] xmlConfigurationFile)
            : this(new WindsorContainer(xmlConfigurationFile[0]))
        {
        }

        public override IFixture GetFixture(string fixtureName, params string[] parameters)
        {
            try
            {
                Type type = TypeForName(fixtureName);
                container.AddComponent(type.FullName, type);
                return new DefaultFixture(container.Resolve(type));
            }
            catch (Exception)
            {
                try
                {
                    return new DefaultFixture(container.Resolve(fixtureName));   
                }
                catch (ComponentNotFoundException)
                {
                    return base.GetFixture(fixtureName, parameters);
                }
            }
        }
    }
}