[Major] Refactored StrolchConfiguration.xml to use environments

Now the agent requires an environment parameter to start, and the
configuration of that environment is used to load different sections of
the configuration file

src/main/java/li/strolch/agent/api/StrolchAgent.java

@@ -82,12 +82,12 @@ public class StrolchAgent {
 			this.container.destroy();
 	}
 
-	public void setup(File path) {
+	public void setup(String environment, File path) {
 
 		String msg = "Setting up Strolch Container from root {0}"; //$NON-NLS-1$
 		logger.info(MessageFormat.format(msg, path.getAbsolutePath()));
 
-		this.strolchConfiguration = ConfigurationParser.parseConfiguration(path);
+		this.strolchConfiguration = ConfigurationParser.parseConfiguration(environment, path);
 
 		ComponentContainerImpl container = new ComponentContainerImpl(this);
 		container.setup(strolchConfiguration);

src/main/java/li/strolch/runtime/configuration/ConfigurationParser.java

@@ -19,6 +19,7 @@ import java.io.File;
 import java.text.MessageFormat;
 
 import li.strolch.runtime.configuration.ConfigurationSaxParser.ConfigurationBuilder;
+import ch.eitchnet.utils.dbc.DBC;
 import ch.eitchnet.utils.helper.XmlHelper;
 
 public class ConfigurationParser {
@@ -27,7 +28,10 @@ public class ConfigurationParser {
 
 	// private static final Logger logger = LoggerFactory.getLogger(ConfigurationParser.class);
 
-	public static StrolchConfiguration parseConfiguration(File rootPathF) {
+	public static StrolchConfiguration parseConfiguration(String environment, File rootPathF) {
+		DBC.PRE.assertNotEmpty("environment value must be set!", environment);
+		DBC.PRE.assertNotNull("roothPath must be set!", rootPathF);
+		DBC.PRE.assertNotEquals("environment must be a value other than 'global'!", "global", environment);
 
 		if (!rootPathF.isDirectory() || !rootPathF.canRead()) {
 			String msg = "Root path is not readable at {0}"; //$NON-NLS-1$
@@ -50,11 +54,20 @@ public class ConfigurationParser {
 		}
 
 		// parse the configuration file
-		ConfigurationSaxParser configurationParser = new ConfigurationSaxParser();
+		ConfigurationSaxParser configurationParser = new ConfigurationSaxParser(environment);
 		XmlHelper.parseDocument(configurationFile, configurationParser);
-		ConfigurationBuilder configurationBuilder = configurationParser.getConfigurationBuilder();
 
-		StrolchConfiguration strolchConfiguration = configurationBuilder.build(rootPathF);
+		ConfigurationBuilder globalEnvBuilder = configurationParser.getGlobalEnvBuilder();
+		ConfigurationBuilder envBuilder = configurationParser.getEnvBuilder();
+		if (envBuilder == null) {
+			String msg = "The environment {0} does not exist!"; //$NON-NLS-1$
+			msg = MessageFormat.format(msg, environment);
+			throw new StrolchConfigurationException(msg);
+		}
+
+		globalEnvBuilder.merge(envBuilder);
+
+		StrolchConfiguration strolchConfiguration = globalEnvBuilder.build(rootPathF);
 		return strolchConfiguration;
 	}
 }

src/main/java/li/strolch/runtime/configuration/ConfigurationSaxParser.java

@@ -33,24 +33,54 @@ import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;
 
+import ch.eitchnet.utils.dbc.DBC;
 import ch.eitchnet.utils.helper.StringHelper;
 
 public class ConfigurationSaxParser extends DefaultHandler {
 
 	//private static final Logger logger = LoggerFactory.getLogger(ConfigurationSaxParser.class);
 
-	private ConfigurationBuilder configurationBuilder;
+	private static final String ENV_GLOBAL = "global";
+	private final String environment;
+	private String currentEnvironment;
+
+	private ConfigurationBuilder globalEnvBuilder;
+	private Map<String, ConfigurationBuilder> envBuilders;
 	private LocatorBuilder locatorBuilder;
 	private Deque<ElementHandler> delegateHandlers;
 
-	public ConfigurationSaxParser() {
+	public ConfigurationSaxParser(String environment) {
+		this.environment = environment;
 		this.locatorBuilder = new LocatorBuilder();
 		this.delegateHandlers = new ArrayDeque<>();
-		this.configurationBuilder = new ConfigurationBuilder();
+		this.globalEnvBuilder = new ConfigurationBuilder();
+		this.envBuilders = new HashMap<>();
 	}
 
-	public ConfigurationBuilder getConfigurationBuilder() {
-		return this.configurationBuilder;
+	public ConfigurationBuilder getGlobalEnvBuilder() {
+		return this.globalEnvBuilder;
+	}
+
+	public ConfigurationBuilder getEnvBuilder() {
+		return this.envBuilders.get(this.environment);
+	}
+
+	public String getEnvironment() {
+		return this.environment;
+	}
+
+	public String getCurrentEnvironment() {
+		return this.currentEnvironment;
+	}
+
+	@Override
+	public void characters(char[] ch, int start, int length) throws SAXException {
+		if (!this.delegateHandlers.isEmpty())
+			this.delegateHandlers.peek().characters(ch, start, length);
+	}
+
+	private boolean isRequiredEnv(String env) {
+		return env.equals(ENV_GLOBAL) || env.equals(this.environment);
 	}
 
 	@Override
@@ -62,27 +92,52 @@ public class ConfigurationSaxParser extends DefaultHandler {
 
 		switch (locator.toString()) {
 
-		case "StrolchConfiguration/Runtime": //$NON-NLS-1$
-			RuntimeHandler runtimeHandler = new RuntimeHandler(this.configurationBuilder, locator);
-			this.delegateHandlers.push(runtimeHandler);
+		case "StrolchConfiguration/env": //$NON-NLS-1$
+			String env = attributes.getValue("id");
+			DBC.PRE.assertNotEmpty("attribute 'id' must be set on element 'env'", env);
+			if (this.envBuilders.containsKey(env)) {
+				String msg = "Environment {0} already exists!";
+				throw new IllegalStateException(MessageFormat.format(msg, env));
+			}
+			this.currentEnvironment = env;
+			ConfigurationBuilder newEnvBuilder = new ConfigurationBuilder();
+			newEnvBuilder.runtimeBuilder().setEnvironment(currentEnvironment);
+			this.envBuilders.put(env, newEnvBuilder);
 			break;
 
-		case "StrolchConfiguration/Runtime/Properties": //$NON-NLS-1$
-			PropertiesHandler runtimePropertiesHandler = new PropertiesHandler(this.configurationBuilder, locator);
-			this.delegateHandlers.push(runtimePropertiesHandler);
-			this.configurationBuilder.setPropertyBuilder(this.configurationBuilder.runtimeBuilder());
+		case "StrolchConfiguration/env/Runtime": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				ConfigurationBuilder configurationBuilder = getEnvBuilder(this.currentEnvironment);
+				RuntimeHandler runtimeHandler = new RuntimeHandler(configurationBuilder, locator);
+				this.delegateHandlers.push(runtimeHandler);
+			}
 			break;
 
-		case "StrolchConfiguration/Component": //$NON-NLS-1$
-			this.configurationBuilder.nextComponentBuilder();
-			ComponentHandler componentHandler = new ComponentHandler(this.configurationBuilder, locator);
-			this.delegateHandlers.push(componentHandler);
+		case "StrolchConfiguration/env/Runtime/Properties": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				ConfigurationBuilder configurationBuilder = getEnvBuilder(this.currentEnvironment);
+				PropertiesHandler runtimePropertiesHandler = new PropertiesHandler(configurationBuilder, locator);
+				this.delegateHandlers.push(runtimePropertiesHandler);
+				configurationBuilder.setPropertyBuilder(configurationBuilder.runtimeBuilder());
+			}
 			break;
 
-		case "StrolchConfiguration/Component/Properties": //$NON-NLS-1$
-			PropertiesHandler componentPropertiesHandler = new PropertiesHandler(this.configurationBuilder, locator);
-			this.delegateHandlers.push(componentPropertiesHandler);
-			this.configurationBuilder.setPropertyBuilder(this.configurationBuilder.componentBuilder());
+		case "StrolchConfiguration/env/Component": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				ConfigurationBuilder configurationBuilder = getEnvBuilder(this.currentEnvironment);
+				configurationBuilder.nextComponentBuilder();
+				ComponentHandler componentHandler = new ComponentHandler(configurationBuilder, locator);
+				this.delegateHandlers.push(componentHandler);
+			}
+			break;
+
+		case "StrolchConfiguration/env/Component/Properties": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				ConfigurationBuilder configurationBuilder = getEnvBuilder(this.currentEnvironment);
+				PropertiesHandler componentPropertiesHandler = new PropertiesHandler(configurationBuilder, locator);
+				this.delegateHandlers.push(componentPropertiesHandler);
+				configurationBuilder.setPropertyBuilder(configurationBuilder.componentBuilder());
+			}
 			break;
 
 		default:
@@ -91,10 +146,17 @@ public class ConfigurationSaxParser extends DefaultHandler {
 		}
 	}
 
-	@Override
-	public void characters(char[] ch, int start, int length) throws SAXException {
-		if (!this.delegateHandlers.isEmpty())
-			this.delegateHandlers.peek().characters(ch, start, length);
+	private ConfigurationBuilder getEnvBuilder(String environment) {
+		if (StringHelper.isEmpty(environment))
+			throw new IllegalStateException("environment must be set!");
+		else if (environment.equals(ENV_GLOBAL))
+			return globalEnvBuilder;
+
+		ConfigurationBuilder envBuilder = this.envBuilders.get(environment);
+		if (envBuilder == null)
+			throw new IllegalStateException("No ConfigurationBuilder exists for env " + environment);
+
+		return envBuilder;
 	}
 
 	@Override
@@ -105,22 +167,35 @@ public class ConfigurationSaxParser extends DefaultHandler {
 
 		switch (locator.toString()) {
 
-		case "StrolchConfiguration/Runtime": //$NON-NLS-1$
-			assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
+		case "StrolchConfiguration/env": //$NON-NLS-1$
 			break;
 
-		case "StrolchConfiguration/Runtime/Properties": //$NON-NLS-1$
-			assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
-			this.configurationBuilder.setPropertyBuilder(null);
+		case "StrolchConfiguration/env/Runtime": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
+			}
 			break;
 
-		case "StrolchConfiguration/Component": //$NON-NLS-1$
-			assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
+		case "StrolchConfiguration/env/Runtime/Properties": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				ConfigurationBuilder configurationBuilder = getEnvBuilder(this.currentEnvironment);
+				assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
+				configurationBuilder.setPropertyBuilder(null);
+			}
 			break;
 
-		case "StrolchConfiguration/Component/Properties": //$NON-NLS-1$
-			assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
-			this.configurationBuilder.setPropertyBuilder(null);
+		case "StrolchConfiguration/env/Component": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
+			}
+			break;
+
+		case "StrolchConfiguration/env/Component/Properties": //$NON-NLS-1$
+			if (isRequiredEnv(this.currentEnvironment)) {
+				ConfigurationBuilder configurationBuilder = getEnvBuilder(this.currentEnvironment);
+				assertExpectedLocator(locator, this.delegateHandlers.pop().getLocator());
+				configurationBuilder.setPropertyBuilder(null);
+			}
 			break;
 
 		default:
@@ -145,6 +220,8 @@ public class ConfigurationSaxParser extends DefaultHandler {
 		protected StringBuilder valueBuffer;
 
 		public ElementHandler(ConfigurationBuilder configurationBuilder, Locator locator) {
+			DBC.PRE.assertNotNull("configurationBuilder must be set!", configurationBuilder);
+			DBC.PRE.assertNotNull("locator must be set!", locator);
 			this.configurationBuilder = configurationBuilder;
 			this.locator = locator;
 		}
@@ -283,6 +360,7 @@ public class ConfigurationSaxParser extends DefaultHandler {
 
 		public ConfigurationBuilder() {
 			this.componentBuilders = new ArrayList<>();
+			this.runtimeBuilder = new RuntimeBuilder();
 		}
 
 		public void setPropertyBuilder(PropertyBuilder propertyBuilder) {
@@ -294,8 +372,6 @@ public class ConfigurationSaxParser extends DefaultHandler {
 		}
 
 		public RuntimeBuilder runtimeBuilder() {
-			if (this.runtimeBuilder == null)
-				this.runtimeBuilder = new RuntimeBuilder();
 			return this.runtimeBuilder;
 		}
 
@@ -324,6 +400,44 @@ public class ConfigurationSaxParser extends DefaultHandler {
 
 			return strolchConfiguration;
 		}
+
+		/**
+		 * Merge the given {@link ConfigurationBuilder ConfigurationBuilder's} values into this configuration builder
+		 * 
+		 * @param otherConfBuilder
+		 *            the {@link ConfigurationBuilder} to be merged into this
+		 */
+		public void merge(ConfigurationBuilder otherConfBuilder) {
+
+			runtimeBuilder().setEnvironment(otherConfBuilder.runtimeBuilder().getEnvironment());
+
+			if (otherConfBuilder.runtimeBuilder != null) {
+				RuntimeBuilder thisRuntime = this.runtimeBuilder;
+				RuntimeBuilder other = otherConfBuilder.runtimeBuilder;
+				if (StringHelper.isNotEmpty(other.getApplicationName()))
+					thisRuntime.setApplicationName(other.getApplicationName());
+				if (!other.getProperties().isEmpty()) {
+					thisRuntime.getProperties().putAll(other.getProperties());
+				}
+			}
+
+			if (!otherConfBuilder.componentBuilders.isEmpty()) {
+				Map<String, ComponentBuilder> thisComponentBuilders = new HashMap<>();
+				for (ComponentBuilder thisComponentBuilder : this.componentBuilders) {
+					thisComponentBuilders.put(thisComponentBuilder.getName(), thisComponentBuilder);
+				}
+
+				List<ComponentBuilder> otherComponents = otherConfBuilder.componentBuilders;
+				for (ComponentBuilder otherComponentBuilder : otherComponents) {
+					ComponentBuilder thisComponentBuilder = thisComponentBuilders.get(otherComponentBuilder.getName());
+					if (thisComponentBuilder == null) {
+						this.componentBuilders.add(otherComponentBuilder);
+					} else {
+						thisComponentBuilder.getProperties().putAll(otherComponentBuilder.getProperties());
+					}
+				}
+			}
+		}
 	}
 
 	public abstract class PropertyBuilder {
@@ -347,14 +461,19 @@ public class ConfigurationSaxParser extends DefaultHandler {
 	public class RuntimeBuilder extends PropertyBuilder {
 
 		private String applicationName;
+		private String environment;
 
 		public String getApplicationName() {
 			return this.applicationName;
 		}
 
+		public String getEnvironment() {
+			return this.environment;
+		}
+
 		public RuntimeConfiguration build(File rootPathF) {
-			RuntimeConfiguration configuration = new RuntimeConfiguration(this.applicationName, getProperties(),
-					rootPathF);
+			RuntimeConfiguration configuration = new RuntimeConfiguration(this.applicationName, environment,
+					getProperties(), rootPathF);
 			return configuration;
 		}
 
@@ -362,6 +481,11 @@ public class ConfigurationSaxParser extends DefaultHandler {
 			this.applicationName = applicationName;
 			return this;
 		}
+
+		public RuntimeBuilder setEnvironment(String environment) {
+			this.environment = environment;
+			return this;
+		}
 	}
 
 	public class ComponentBuilder extends PropertyBuilder {

src/main/java/li/strolch/runtime/configuration/RuntimeConfiguration.java

@@ -28,12 +28,15 @@ public class RuntimeConfiguration extends AbstractionConfiguration {
 	public static final String PATH_DATA = "data"; //$NON-NLS-1$
 
 	private final String applicationName;
-	private Locale locale;
+	private final String environment;
 	private final File rootPath;
 	private final File configPath;
 	private final File dataPath;
 
-	public RuntimeConfiguration(String applicationName, Map<String, String> configurationValues, File rootPathF) {
+	private Locale locale;
+
+	public RuntimeConfiguration(String applicationName, String environment, Map<String, String> configurationValues,
+			File rootPathF) {
 		super(RUNTIME, configurationValues);
 
 		if (!rootPathF.isDirectory() || !rootPathF.canRead()) {
@@ -62,6 +65,8 @@ public class RuntimeConfiguration extends AbstractionConfiguration {
 		}
 
 		this.applicationName = applicationName;
+		this.environment = environment;
+
 		this.rootPath = rootPathF;
 		this.configPath = configPathF;
 		this.dataPath = dataPathF;
@@ -73,6 +78,10 @@ public class RuntimeConfiguration extends AbstractionConfiguration {
 		return this.applicationName;
 	}
 
+	public String getEnvironment() {
+		return this.environment;
+	}
+
 	public File getRootPath() {
 		return this.rootPath;
 	}

src/main/java/li/strolch/runtime/main/MainStarter.java

@@ -41,6 +41,7 @@ public class MainStarter {
 	private static final Logger logger = LoggerFactory.getLogger(MainStarter.class);
 
 	private static final String OPT_ROOT_PATH = "root-path";
+	private static final String OPT_ENV = "env";
 
 	private Options options;
 	private StrolchAgent agent;
@@ -51,6 +52,11 @@ public class MainStarter {
 		rootPathOption.setOptionalArg(false);
 		rootPathOption.setRequired(true);
 		op.addOption(rootPathOption);
+
+		Option envOption = new Option("e", OPT_ENV, true, "environment to load from configuration file");
+		envOption.setOptionalArg(false);
+		envOption.setRequired(true);
+		op.addOption(envOption);
 		this.options = op;
 	}
 
@@ -69,6 +75,8 @@ public class MainStarter {
 			return 1;
 		}
 
+		String env = line.getOptionValue(OPT_ENV);
+
 		String pathS = line.getOptionValue(OPT_ROOT_PATH);
 		File pathF = new File(pathS);
 		if (!pathF.exists()) {
@@ -79,7 +87,7 @@ public class MainStarter {
 
 		logger.info("Starting Agent...");
 		this.setAgent(new StrolchAgent());
-		this.getAgent().setup(pathF);
+		this.getAgent().setup(env, pathF);
 		this.getAgent().initialize();
 		this.getAgent().start();
 

src/test/java/li/strolch/agent/ComponentContainerTest.java

@@ -264,7 +264,7 @@ public class ComponentContainerTest {
 
 	public static StrolchAgent startContainer(File rootPathF) {
 		StrolchAgent agent = new StrolchAgent();
-		agent.setup(rootPathF);
+		agent.setup("dev", rootPathF);
 		agent.initialize();
 		agent.start();
 

src/test/java/li/strolch/runtime/configuration/ConfigurationParserTest.java

@@ -21,21 +21,16 @@ import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 
-import li.strolch.runtime.configuration.ComponentConfiguration;
-import li.strolch.runtime.configuration.ConfigurationParser;
-import li.strolch.runtime.configuration.RuntimeConfiguration;
-import li.strolch.runtime.configuration.StrolchConfiguration;
-
 import org.junit.Test;
 
 @SuppressWarnings("nls")
 public class ConfigurationParserTest {
 
 	@Test
-	public void shouldParseConfigurationFile() {
+	public void shouldParseConfigurationFileForDevEnv() {
 
 		File rootPathF = new File("src/test/resources/configtest");
-		StrolchConfiguration strolchConfiguration = ConfigurationParser.parseConfiguration(rootPathF);
+		StrolchConfiguration strolchConfiguration = ConfigurationParser.parseConfiguration("dev", rootPathF);
 		assertNotNull("Should have created a configuration object", strolchConfiguration);
 
 		//	<Runtime>
@@ -47,6 +42,7 @@ public class ConfigurationParserTest {
 		RuntimeConfiguration runtimeConfiguration = strolchConfiguration.getRuntimeConfiguration();
 		assertNotNull("Should have created a runtime configuration", runtimeConfiguration);
 		assertEquals("StrolchRuntimeTest", runtimeConfiguration.getApplicationName());
+		assertEquals("dev", runtimeConfiguration.getEnvironment());
 		assertEquals(true, runtimeConfiguration.getBoolean("verbose", null));
 
 		//	<Component>
@@ -103,5 +99,84 @@ public class ConfigurationParserTest {
 				persistenceHandlerConfiguration.getImpl());
 		assertEquals(1, persistenceHandlerConfiguration.getPropertyKeys().size());
 		assertEquals(true, persistenceHandlerConfiguration.getBoolean("verbose", null));
+
+		//	<env id="global">
+		//		<Component>
+		//			<name>RealmHandler</name>
+		// 			<api>li.strolch.agent.api.RealmHandler</api>
+		// 			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+		//		</Component>
+		//	<env id="dev">
+		//		<Component>
+		//			<name>RealmHandler</name>
+		//			<Properties>
+		//				<foo>bar</foo>
+		//			</Properties>
+		//		</Component>
+		ComponentConfiguration realmHandlerConfiguration = strolchConfiguration
+				.getComponentConfiguration("RealmHandler");
+		assertNotNull("Should have created a RealmHandler Configuration", realmHandlerConfiguration);
+		assertEquals("RealmHandler", realmHandlerConfiguration.getName());
+		assertEquals("li.strolch.agent.api.RealmHandler", realmHandlerConfiguration.getApi());
+		assertEquals("li.strolch.agent.impl.DefaultRealmHandler", realmHandlerConfiguration.getImpl());
+		assertEquals(2, realmHandlerConfiguration.getPropertyKeys().size());
+		assertEquals("EMPTY", realmHandlerConfiguration.getString("dataStoreMode", null));
+		assertEquals("bar", realmHandlerConfiguration.getString("foo", null));
+
+		//		<Component>
+		//			<name>AdditionalServiceHandler</name>
+		//			<api>li.strolch.service.api.ServiceHandler</api>
+		//			<impl>li.strolch.service.SimpleServiceHandler</impl>
+		//			<Properties>
+		//				<foo>bar</foo>
+		//			</Properties>
+		//		</Component>
+		//	</env>
+		ComponentConfiguration additionalServiceHandlerConfiguration = strolchConfiguration
+				.getComponentConfiguration("AdditionalServiceHandler");
+		assertNotNull("Should have created a AdditionalServiceHandler Configuration",
+				additionalServiceHandlerConfiguration);
+		assertEquals("AdditionalServiceHandler", additionalServiceHandlerConfiguration.getName());
+		assertEquals("li.strolch.service.api.ServiceHandler", additionalServiceHandlerConfiguration.getApi());
+		assertEquals("li.strolch.service.SimpleServiceHandler", additionalServiceHandlerConfiguration.getImpl());
+		assertEquals(1, additionalServiceHandlerConfiguration.getPropertyKeys().size());
+		assertEquals("bar", additionalServiceHandlerConfiguration.getString("foo", null));
+	}
+
+	@Test
+	public void shouldParseConfigurationFileForTestEnv() {
+
+		File rootPathF = new File("src/test/resources/configtest");
+		StrolchConfiguration strolchConfiguration = ConfigurationParser.parseConfiguration("test", rootPathF);
+		assertNotNull("Should have created a configuration object", strolchConfiguration);
+
+		RuntimeConfiguration runtimeConfiguration = strolchConfiguration.getRuntimeConfiguration();
+		assertNotNull("Should have created a runtime configuration", runtimeConfiguration);
+		assertEquals("StrolchRuntimeTest", runtimeConfiguration.getApplicationName());
+		assertEquals("test", runtimeConfiguration.getEnvironment());
+		assertEquals(true, runtimeConfiguration.getBoolean("verbose", null));
+
+		//	<env id="global">
+		//		<Component>
+		//			<name>RealmHandler</name>
+		// 			<api>li.strolch.agent.api.RealmHandler</api>
+		// 			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+		//		</Component>
+		//	<env id="test">
+		//		<Component>
+		//			<name>RealmHandler</name>
+		//			<Properties>
+		//				<foo>noob</foo>
+		//			</Properties>
+		//		</Component>
+		ComponentConfiguration realmHandlerConfiguration = strolchConfiguration
+				.getComponentConfiguration("RealmHandler");
+		assertNotNull("Should have created a RealmHandler Configuration", realmHandlerConfiguration);
+		assertEquals("RealmHandler", realmHandlerConfiguration.getName());
+		assertEquals("li.strolch.agent.api.RealmHandler", realmHandlerConfiguration.getApi());
+		assertEquals("li.strolch.agent.impl.DefaultRealmHandler", realmHandlerConfiguration.getImpl());
+		assertEquals(2, realmHandlerConfiguration.getPropertyKeys().size());
+		assertEquals("EMPTY", realmHandlerConfiguration.getString("dataStoreMode", null));
+		assertEquals("noob", realmHandlerConfiguration.getString("foo", null));
 	}
 }

src/test/java/li/strolch/runtime/configuration/ControllerDependencyTest.java

@@ -170,7 +170,7 @@ public class ControllerDependencyTest {
 		//
 
 		File rootPathF = new File("src/test/resources/configtest");
-		this.strolchConfiguration = ConfigurationParser.parseConfiguration(rootPathF);
+		this.strolchConfiguration = ConfigurationParser.parseConfiguration("dev", rootPathF);
 
 		this.controllerMap = new HashMap<>();
 

src/test/resources/cachedtest/config/StrolchConfiguration.xml

@@ -1,40 +1,42 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <StrolchConfiguration>
-	<Runtime>
-		<applicationName>StrolchRuntimeTest</applicationName>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Runtime>
-	<Component>
-		<name>RealmHandler</name>
-		<api>li.strolch.agent.api.RealmHandler</api>
-		<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
-		<depends>PersistenceHandler</depends>
-		<Properties>
-			<dataStoreMode>CACHED</dataStoreMode>
-			<dataStoreFile>StrolchModel.xml</dataStoreFile>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ServiceHandler</name>
-		<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PostInitializer</name>
-		<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
-		<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
-		<depends>ServiceHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PersistenceHandler</name>
-		<api>li.strolch.persistence.api.PersistenceHandler</api>
-		<impl>li.strolch.persistence.inmemory.InMemoryPersistenceHandler</impl>
-	</Component>
+	<env id="dev">
+		<Runtime>
+			<applicationName>StrolchRuntimeTest</applicationName>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Runtime>
+		<Component>
+			<name>RealmHandler</name>
+			<api>li.strolch.agent.api.RealmHandler</api>
+			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+			<depends>PersistenceHandler</depends>
+			<Properties>
+				<dataStoreMode>CACHED</dataStoreMode>
+				<dataStoreFile>StrolchModel.xml</dataStoreFile>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ServiceHandler</name>
+			<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PostInitializer</name>
+			<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
+			<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
+			<depends>ServiceHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PersistenceHandler</name>
+			<api>li.strolch.persistence.api.PersistenceHandler</api>
+			<impl>li.strolch.persistence.inmemory.InMemoryPersistenceHandler</impl>
+		</Component>
+	</env>
 </StrolchConfiguration>

src/test/resources/configtest/config/StrolchConfiguration.xml

@@ -1,44 +1,72 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <StrolchConfiguration>
-	<Runtime>
-		<applicationName>StrolchRuntimeTest</applicationName>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Runtime>
-	<Component>
-		<name>RealmHandler</name>
-		<api>li.strolch.agent.api.RealmHandler</api>
-		<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
-		<Properties>
-			<dataStoreMode>EMPTY</dataStoreMode>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ServiceHandler</name>
-		<api>li.strolch.service.api.ServiceHandler</api>
-		<impl>li.strolch.service.SimpleServiceHandler</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PrivilegeHandler</name>
-		<api>li.strolch.runtime.privilege.DefaultStrolchPrivilegeHandler</api>
-		<impl>li.strolch.runtime.privilege.DefaultStrolchPrivilegeHandler</impl>
-		<depends>PersistenceHandler</depends>
-		<Properties>
-			<privilegeConfigFile>PrivilegeConfig.xml</privilegeConfigFile>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ResourceGeneratorHandler</name>
-		<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
-		<depends>PersistenceHandler</depends>
-		<depends>ServiceHandler</depends>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Component>
+	<env id="global">
+		<Runtime>
+			<applicationName>StrolchRuntimeTest</applicationName>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Runtime>
+		<Component>
+			<name>RealmHandler</name>
+			<api>li.strolch.agent.api.RealmHandler</api>
+			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+			<Properties>
+				<dataStoreMode>EMPTY</dataStoreMode>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ServiceHandler</name>
+			<api>li.strolch.service.api.ServiceHandler</api>
+			<impl>li.strolch.service.SimpleServiceHandler</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PrivilegeHandler</name>
+			<api>li.strolch.runtime.privilege.DefaultStrolchPrivilegeHandler</api>
+			<impl>li.strolch.runtime.privilege.DefaultStrolchPrivilegeHandler</impl>
+			<depends>PersistenceHandler</depends>
+			<Properties>
+				<privilegeConfigFile>PrivilegeConfig.xml</privilegeConfigFile>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ResourceGeneratorHandler</name>
+			<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
+			<depends>PersistenceHandler</depends>
+			<depends>ServiceHandler</depends>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Component>
+	</env>
+	<env id="dev">
+		<Component>
+			<name>RealmHandler</name>
+			<Properties>
+				<foo>bar</foo>
+			</Properties>
+		</Component>
+
+		<Component>
+			<name>AdditionalServiceHandler</name>
+			<api>li.strolch.service.api.ServiceHandler</api>
+			<impl>li.strolch.service.SimpleServiceHandler</impl>
+			<Properties>
+				<foo>bar</foo>
+			</Properties>
+		</Component>
+	</env>
+	<env id="test">
+		<Component>
+			<name>RealmHandler</name>
+			<Properties>
+				<foo>noob</foo>
+			</Properties>
+		</Component>
+	</env>
+
 </StrolchConfiguration>

src/test/resources/emptytest/config/StrolchConfiguration.xml

@@ -1,33 +1,35 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <StrolchConfiguration>
-	<Runtime>
-		<applicationName>StrolchRuntimeTest</applicationName>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Runtime>
-	<Component>
-		<name>RealmHandler</name>
-		<api>li.strolch.agent.api.RealmHandler</api>
-		<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
-		<Properties>
-			<dataStoreMode>EMPTY</dataStoreMode>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ServiceHandler</name>
-		<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ResourceGeneratorHandler</name>
-		<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Component>
+	<env id="dev">
+		<Runtime>
+			<applicationName>StrolchRuntimeTest</applicationName>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Runtime>
+		<Component>
+			<name>RealmHandler</name>
+			<api>li.strolch.agent.api.RealmHandler</api>
+			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+			<Properties>
+				<dataStoreMode>EMPTY</dataStoreMode>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ServiceHandler</name>
+			<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ResourceGeneratorHandler</name>
+			<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Component>
+	</env>
 </StrolchConfiguration>

src/test/resources/realmtest/config/StrolchConfiguration.xml

@@ -1,56 +1,58 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <StrolchConfiguration>
-	<Runtime>
-		<applicationName>StrolchRuntimeTest</applicationName>
-		<Properties>
-			<dataStoreMode>TRANSIENT</dataStoreMode>
-			<verbose>true</verbose>
-		</Properties>
-	</Runtime>
-	<Component>
-		<name>RealmHandler</name>
-		<api>li.strolch.agent.api.RealmHandler</api>
-		<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
-		<Properties>
-			<realms>defaultRealm, myRealm, otherRealm, cachedRealm, transactionalRealm, emptyRealm</realms>
-			<dataStoreMode>TRANSIENT</dataStoreMode>
-			<dataStoreFile>DefaultRealm.xml</dataStoreFile>
-			<dataStoreMode.myRealm>TRANSIENT</dataStoreMode.myRealm>
-			<dataStoreFile.myRealm>MyRealm.xml</dataStoreFile.myRealm>
-			<dataStoreMode.otherRealm>TRANSIENT</dataStoreMode.otherRealm>
-			<dataStoreFile.otherRealm>OtherRealm.xml</dataStoreFile.otherRealm>
-			<dataStoreMode.transactionalRealm>TRANSACTIONAL</dataStoreMode.transactionalRealm>
-			<dataStoreMode.cachedRealm>CACHED</dataStoreMode.cachedRealm>
-			<dataStoreMode.emptyRealm>EMPTY</dataStoreMode.emptyRealm>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ServiceHandler</name>
-		<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PostInitializer</name>
-		<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
-		<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
-		<depends>ServiceHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ResourceGeneratorHandler</name>
-		<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PersistenceHandler</name>
-		<api>li.strolch.persistence.api.PersistenceHandler</api>
-		<impl>li.strolch.persistence.inmemory.InMemoryPersistenceHandler</impl>
-	</Component>
+	<env id="dev">
+		<Runtime>
+			<applicationName>StrolchRuntimeTest</applicationName>
+			<Properties>
+				<dataStoreMode>TRANSIENT</dataStoreMode>
+				<verbose>true</verbose>
+			</Properties>
+		</Runtime>
+		<Component>
+			<name>RealmHandler</name>
+			<api>li.strolch.agent.api.RealmHandler</api>
+			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+			<Properties>
+				<realms>defaultRealm, myRealm, otherRealm, cachedRealm, transactionalRealm, emptyRealm</realms>
+				<dataStoreMode>TRANSIENT</dataStoreMode>
+				<dataStoreFile>DefaultRealm.xml</dataStoreFile>
+				<dataStoreMode.myRealm>TRANSIENT</dataStoreMode.myRealm>
+				<dataStoreFile.myRealm>MyRealm.xml</dataStoreFile.myRealm>
+				<dataStoreMode.otherRealm>TRANSIENT</dataStoreMode.otherRealm>
+				<dataStoreFile.otherRealm>OtherRealm.xml</dataStoreFile.otherRealm>
+				<dataStoreMode.transactionalRealm>TRANSACTIONAL</dataStoreMode.transactionalRealm>
+				<dataStoreMode.cachedRealm>CACHED</dataStoreMode.cachedRealm>
+				<dataStoreMode.emptyRealm>EMPTY</dataStoreMode.emptyRealm>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ServiceHandler</name>
+			<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PostInitializer</name>
+			<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
+			<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
+			<depends>ServiceHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ResourceGeneratorHandler</name>
+			<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PersistenceHandler</name>
+			<api>li.strolch.persistence.api.PersistenceHandler</api>
+			<impl>li.strolch.persistence.inmemory.InMemoryPersistenceHandler</impl>
+		</Component>
+	</env>
 </StrolchConfiguration>

src/test/resources/transactionaltest/config/StrolchConfiguration.xml

@@ -1,40 +1,42 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <StrolchConfiguration>
-	<Runtime>
-		<applicationName>StrolchRuntimeTest</applicationName>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Runtime>
-	<Component>
-		<name>RealmHandler</name>
-		<api>li.strolch.agent.api.RealmHandler</api>
-		<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
-		<depends>PersistenceHandler</depends>
-		<Properties>
-			<dataStoreMode>TRANSACTIONAL</dataStoreMode>
-			<dataStoreFile>StrolchModel.xml</dataStoreFile>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ServiceHandler</name>
-		<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PostInitializer</name>
-		<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
-		<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
-		<depends>ServiceHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PersistenceHandler</name>
-		<api>li.strolch.persistence.api.PersistenceHandler</api>
-		<impl>li.strolch.persistence.inmemory.InMemoryPersistenceHandler</impl>
-	</Component>
+	<env id="dev">
+		<Runtime>
+			<applicationName>StrolchRuntimeTest</applicationName>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Runtime>
+		<Component>
+			<name>RealmHandler</name>
+			<api>li.strolch.agent.api.RealmHandler</api>
+			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+			<depends>PersistenceHandler</depends>
+			<Properties>
+				<dataStoreMode>TRANSACTIONAL</dataStoreMode>
+				<dataStoreFile>StrolchModel.xml</dataStoreFile>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ServiceHandler</name>
+			<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PostInitializer</name>
+			<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
+			<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
+			<depends>ServiceHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PersistenceHandler</name>
+			<api>li.strolch.persistence.api.PersistenceHandler</api>
+			<impl>li.strolch.persistence.inmemory.InMemoryPersistenceHandler</impl>
+		</Component>
+	</env>
 </StrolchConfiguration>

src/test/resources/transienttest/config/StrolchConfiguration.xml

@@ -1,55 +1,57 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <StrolchConfiguration>
-	<Runtime>
-		<applicationName>StrolchRuntimeTest</applicationName>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Runtime>
-	<Component>
-		<name>RealmHandler</name>
-		<api>li.strolch.agent.api.RealmHandler</api>
-		<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
-		<!-- depends>PersistenceHandler</depends-->
-		<Properties>
-			<dataStoreMode>TRANSIENT</dataStoreMode>
-			<dataStoreFile>StrolchModel.xml</dataStoreFile>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ServiceHandler</name>
-		<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>PostInitializer</name>
-		<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
-		<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
-		<depends>ServiceHandler</depends>
-		<Properties>
-		</Properties>
-	</Component>
-	<Component>
-		<name>ResourceGeneratorHandler</name>
-		<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
-		<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
-		<Properties>
-			<verbose>true</verbose>
-		</Properties>
-	</Component>
-	<Component>
-		<name>EnumHandler</name>
-		<api>li.strolch.runtime.query.enums.EnumHandler</api>
-		<impl>li.strolch.runtime.query.enums.DefaultEnumHandler</impl>
-		<depends>RealmHandler</depends>
-		<Properties>
-			<realm>defaultRealm</realm>
-			<salutations>Resource/Enumeration/salutations</salutations>
-			<sex>Resource/Enumeration/sex</sex>
-			<religions>Resource/Enumeration/religions</religions>
-		</Properties>
-	</Component>
+	<env id="dev">
+		<Runtime>
+			<applicationName>StrolchRuntimeTest</applicationName>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Runtime>
+		<Component>
+			<name>RealmHandler</name>
+			<api>li.strolch.agent.api.RealmHandler</api>
+			<impl>li.strolch.agent.impl.DefaultRealmHandler</impl>
+			<!-- depends>PersistenceHandler</depends -->
+			<Properties>
+				<dataStoreMode>TRANSIENT</dataStoreMode>
+				<dataStoreFile>StrolchModel.xml</dataStoreFile>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ServiceHandler</name>
+			<api>li.strolch.runtime.configuration.model.ServiceHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ServiceHandlerTestImpl</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>PostInitializer</name>
+			<api>li.strolch.runtime.configuration.model.PostInitializerTest</api>
+			<impl>li.strolch.runtime.configuration.model.PostInitializerTestImpl</impl>
+			<depends>ServiceHandler</depends>
+			<Properties>
+			</Properties>
+		</Component>
+		<Component>
+			<name>ResourceGeneratorHandler</name>
+			<api>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTest</api>
+			<impl>li.strolch.runtime.configuration.model.ResourceGeneratorHandlerTestImpl</impl>
+			<Properties>
+				<verbose>true</verbose>
+			</Properties>
+		</Component>
+		<Component>
+			<name>EnumHandler</name>
+			<api>li.strolch.runtime.query.enums.EnumHandler</api>
+			<impl>li.strolch.runtime.query.enums.DefaultEnumHandler</impl>
+			<depends>RealmHandler</depends>
+			<Properties>
+				<realm>defaultRealm</realm>
+				<salutations>Resource/Enumeration/salutations</salutations>
+				<sex>Resource/Enumeration/sex</sex>
+				<religions>Resource/Enumeration/religions</religions>
+			</Properties>
+		</Component>
+	</env>
 </StrolchConfiguration>