/* * Copyright (C) 2010 The Android Open Source Project * * 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.android.tradefed.config; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotSame; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static java.util.Map.entry; import com.android.tradefed.build.IBuildInfo; import com.android.tradefed.build.IBuildProvider; import com.android.tradefed.build.IDeviceBuildProvider; import com.android.tradefed.build.LocalDeviceBuildProvider; import com.android.tradefed.config.ConfigurationDef.ConfigObjectDef; import com.android.tradefed.config.ConfigurationFactory.ConfigId; import com.android.tradefed.config.remote.IRemoteFileResolver.ResolvedFile; import com.android.tradefed.log.ILeveledLogOutput; import com.android.tradefed.log.Log.LogLevel; import com.android.tradefed.log.LogUtil.CLog; import com.android.tradefed.targetprep.DeviceWiper; import com.android.tradefed.targetprep.ILabPreparer; import com.android.tradefed.targetprep.StubTargetPreparer; import com.android.tradefed.targetprep.multi.StubMultiTargetPreparer; import com.android.tradefed.util.FileUtil; import com.android.tradefed.util.StreamUtil; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.Mockito; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.PrintStream; import java.net.URI; import java.util.ArrayList; import java.util.Arrays; import java.util.Enumeration; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; /** Unit tests for {@link ConfigurationFactory} */ @RunWith(JUnit4.class) public class ConfigurationFactoryTest { private ConfigurationFactory mFactory; // Create a real instance for tests that checks the content of our configs. making it static to // reduce the runtime of reloading the config thanks to the caching of configurations. private static ConfigurationFactory mRealFactory = new ConfigurationFactory(); /** the test config name that is built into this jar */ private static final String TEST_CONFIG = "test-config"; private static final String GLOBAL_TEST_CONFIG = "global-config"; private static final String INCLUDE_CONFIG = "include-config"; private static final List JAR_TO_CHECK = new ArrayList<>(); static { JAR_TO_CHECK.add("tradefed-contrib.jar"); JAR_TO_CHECK.add("google-tradefed-contrib.jar"); } @Before public void setUp() throws Exception { mFactory = new ConfigurationFactory() { @Override protected String getConfigPrefix() { return "testconfigs/"; } }; } /** Initial test to ensure all config names on classpath are loadable */ @Test public void testLoadAllConfigs() throws Exception { ConfigurationFactory spyFactory = Mockito.spy(mRealFactory); Mockito.doReturn(new HashSet()).when(spyFactory).getConfigNamesFromTestCases(null); // we dry-run the templates otherwise it will always fail. spyFactory.loadAllConfigs(false); assertTrue(spyFactory.getMapConfig().size() > 0); Mockito.verify(spyFactory, Mockito.times(1)).getConfigNamesFromTestCases(null); // Verify that there is no cross-referencing between core and contrib: // core configs should not use any contrib object. Map configAndJar = spyFactory.getConfigSetFromClasspathFromJar(null); Map> classInContribJars = getClassInContribJar(); List exceptionConfigJar = new ArrayList<>(); for (Entry entry : spyFactory.getMapConfig().entrySet()) { String configName = entry.getKey().name; String jarName = configAndJar.get(configName); ConfigurationDef cDef = entry.getValue(); if (JAR_TO_CHECK.contains(jarName)) { continue; } for (List cObjects : cDef.getObjectClassMap().values()) { for (ConfigObjectDef o : cObjects) { for (String contribJar : classInContribJars.keySet()) { if (classInContribJars.get(contribJar).contains(o.mClassName)) { exceptionConfigJar.add( String.format( "%s is a core-configuration (%s). It shouldn't contain" + " a contrib objects '%s' from %s.", configName, jarName, o.mClassName, contribJar)); } } } } } if (!exceptionConfigJar.isEmpty()) { fail( String.format( "Found some dependencies of core on contrib:\n%s", String.join("\n", exceptionConfigJar))); } } /** Initial test to ensure all configs on classpath can be fully loaded and parsed */ @Test public void testLoadAndPrintAllConfigs() throws ConfigurationException { ConfigurationFactory spyFactory = Mockito.spy(mRealFactory); Mockito.doReturn(new HashSet()).when(spyFactory).getConfigNamesFromTestCases(null); // Printing the help involves more checks since it tries to resolve the config objects. spyFactory.loadAndPrintAllConfigs(); assertTrue(spyFactory.getMapConfig().size() > 0); Mockito.verify(spyFactory, Mockito.times(1)).getConfigNamesFromTestCases(null); } /** Test that a config xml defined in this test jar can be read as a built-in */ @Test public void testGetConfiguration_extension() throws ConfigurationException { assertConfigValid(TEST_CONFIG); } private Map buildMap(String... args) { if ((args.length % 2) != 0) { throw new IllegalArgumentException(String.format( "Expected an even number of args; got %d", args.length)); } final Map map = new HashMap(args.length / 2); for (int i = 0; i < args.length; i += 2) { map.put(args[i], args[i + 1]); } return map; } /** Make sure that ConfigId behaves in the right way to serve as a hash key */ @Test public void testConfigId_equals() { final ConfigId config1a = new ConfigId("one"); final ConfigId config1b = new ConfigId("one"); final ConfigId config2 = new ConfigId("two"); final ConfigId config3a = new ConfigId("one", buildMap("target", "foo")); final ConfigId config3b = new ConfigId("one", buildMap("target", "foo")); final ConfigId config4 = new ConfigId("two", buildMap("target", "bar")); assertEquals(config1a, config1b); assertEquals(config3a, config3b); // Check for false equivalences, and don't depend on #equals being commutative assertFalse(config1a.equals(config2)); assertFalse(config1a.equals(config3a)); assertFalse(config1a.equals(config4)); assertFalse(config2.equals(config1a)); assertFalse(config2.equals(config3a)); assertFalse(config2.equals(config4)); assertFalse(config3a.equals(config1a)); assertFalse(config3a.equals(config2)); assertFalse(config3a.equals(config4)); assertFalse(config4.equals(config1a)); assertFalse(config4.equals(config2)); assertFalse(config4.equals(config3a)); } /** Make sure that ConfigId behaves in the right way to serve as a hash key */ @Test public void testConfigId_hashKey() { final Map map = new HashMap<>(); final ConfigId config1a = new ConfigId("one"); final ConfigId config1b = new ConfigId("one"); final ConfigId config2 = new ConfigId("two"); final ConfigId config3a = new ConfigId("one", buildMap("target", "foo")); final ConfigId config3b = new ConfigId("one", buildMap("target", "foo")); final ConfigId config4 = new ConfigId("two", buildMap("target", "bar")); // Make sure that keys config1a and config1b behave identically map.put(config1a, "1a"); assertEquals("1a", map.get(config1a)); assertEquals("1a", map.get(config1b)); map.put(config1b, "1b"); assertEquals("1b", map.get(config1a)); assertEquals("1b", map.get(config1b)); assertFalse(map.containsKey(config2)); assertFalse(map.containsKey(config3a)); assertFalse(map.containsKey(config4)); // Make sure that keys config3a and config3b behave identically map.put(config3a, "3a"); assertEquals("3a", map.get(config3a)); assertEquals("3a", map.get(config3b)); map.put(config3b, "3b"); assertEquals("3b", map.get(config3a)); assertEquals("3b", map.get(config3b)); assertEquals(2, map.size()); assertFalse(map.containsKey(config2)); assertFalse(map.containsKey(config4)); // It's unlikely for these to fail if the above tests all passed, but just fill everything // out for completeness map.put(config2, "2"); map.put(config4, "4"); assertEquals(4, map.size()); assertEquals("1b", map.get(config1a)); assertEquals("1b", map.get(config1b)); assertEquals("2", map.get(config2)); assertEquals("3b", map.get(config3a)); assertEquals("3b", map.get(config3b)); assertEquals("4", map.get(config4)); } /** Test specifying a config xml by file path */ @Test public void testGetConfiguration_xmlpath() throws ConfigurationException, IOException { // extract the test-config.xml into a tmp file InputStream configStream = getClass().getResourceAsStream( String.format("/testconfigs/%s.xml", TEST_CONFIG)); File tmpFile = FileUtil.createTempFile(TEST_CONFIG, ".xml"); try { FileUtil.writeToFile(configStream, tmpFile); assertConfigValid(tmpFile.getAbsolutePath()); // check reading it again - should grab the cached version assertConfigValid(tmpFile.getAbsolutePath()); } finally { FileUtil.deleteFile(tmpFile); } } /** Test that a config xml defined in this test jar can be read as a built-in */ @Test public void testGetGlobalConfiguration_extension() throws ConfigurationException { assertGlobalConfigValid(GLOBAL_TEST_CONFIG); } /** Test specifying a config xml by file path */ @Test public void testGetGlobalConfiguration_xmlpath() throws ConfigurationException, IOException { // extract the test-config.xml into a tmp file InputStream configStream = getClass().getResourceAsStream( String.format("/testconfigs/%s.xml", GLOBAL_TEST_CONFIG)); File tmpFile = FileUtil.createTempFile(GLOBAL_TEST_CONFIG, ".xml"); try { FileUtil.writeToFile(configStream, tmpFile); assertGlobalConfigValid(tmpFile.getAbsolutePath()); // check reading it again - should grab the cached version assertGlobalConfigValid(tmpFile.getAbsolutePath()); } finally { FileUtil.deleteFile(tmpFile); } } /** * Checks all config attributes are non-null */ private void assertConfigValid(String name) throws ConfigurationException { IConfiguration config = mFactory.createConfigurationFromArgs(new String[] {name}); assertNotNull(config); } /** * Checks all config attributes are non-null */ private void assertGlobalConfigValid(String name) throws ConfigurationException { List unprocessed = new ArrayList(); IGlobalConfiguration config = mFactory.createGlobalConfigurationFromArgs(new String[] {name}, unprocessed); assertNotNull(config); assertNotNull(config.getDeviceMonitors()); assertNotNull(config.getWtfHandler()); assertTrue(unprocessed.isEmpty()); } /** * Test calling {@link ConfigurationFactory#createConfigurationFromArgs(String[])} with a name * that does not exist. */ @Test public void testCreateConfigurationFromArgs_missing() { try { mFactory.createConfigurationFromArgs(new String[] {"non existent"}); fail("did not throw ConfigurationException"); } catch (ConfigurationException e) { // expected } } /** * Test calling {@link ConfigurationFactory#createConfigurationFromArgs(String[])} with config * that has unset mandatory options. * *

Expect this to succeed, since mandatory option validation no longer happens at * configuration instantiation time. */ @Test public void testCreateConfigurationFromArgs_mandatory() throws ConfigurationException { assertNotNull(mFactory.createConfigurationFromArgs(new String[] {"mandatory-config"})); } /** * Test passing empty arg list to {@link * ConfigurationFactory#createConfigurationFromArgs(String[])}. */ @Test public void testCreateConfigurationFromArgs_empty() { try { mFactory.createConfigurationFromArgs(new String[] {}); fail("did not throw ConfigurationException"); } catch (ConfigurationException e) { // expected } } /** Test {@link ConfigurationFactory#createConfigurationFromArgs(String[])} using TEST_CONFIG */ @Test public void testCreateConfigurationFromArgs() throws ConfigurationException { // pick an arbitrary option to test to ensure it gets populated IConfiguration config = mFactory.createConfigurationFromArgs(new String[] {TEST_CONFIG, "--log-level", LogLevel.VERBOSE.getStringValue()}); ILeveledLogOutput logger = config.getLogOutput(); assertEquals(LogLevel.VERBOSE, logger.getLogLevel()); } /** * Test {@link ConfigurationFactory#createConfigurationFromArgs(String[])} when extra positional * arguments are supplied */ @Test public void testCreateConfigurationFromArgs_unprocessedArgs() { try { mFactory.createConfigurationFromArgs(new String[] {TEST_CONFIG, "--log-level", LogLevel.VERBOSE.getStringValue(), "blah"}); fail("ConfigurationException not thrown"); } catch (ConfigurationException e) { // expected } } /** Test {@link ConfigurationFactory#printHelp(PrintStream)} */ @Test public void testPrintHelp() { ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); PrintStream mockPrintStream = new PrintStream(outputStream); mRealFactory.printHelp(mockPrintStream); // verify all the instrument config names are present final String usageString = outputStream.toString(); assertTrue(usageString.contains("instrument")); } /** * Test {@link ConfigurationFactory#printHelpForConfig(String[], boolean, PrintStream)} when * config referenced by args exists */ @Test public void testPrintHelpForConfig_configExists() { String[] args = new String[] {TEST_CONFIG}; ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); PrintStream mockPrintStream = new PrintStream(outputStream); mFactory.printHelpForConfig(args, true, mockPrintStream); // verify the default configs name used is present final String usageString = outputStream.toString(); assertTrue(usageString.contains(TEST_CONFIG)); // TODO: add stricter verification } /** Test {@link ConfigurationFactory#getConfigList()} */ @Test public void testListAllConfigs() { List listConfigs = mRealFactory.getConfigList(); assertTrue(listConfigs.size() != 0); // Check that our basic configs are always here assertTrue(listConfigs.contains("empty")); assertTrue(listConfigs.contains("host")); assertTrue(listConfigs.contains("instrument")); } /** * Test {@link ConfigurationFactory#getConfigList(String, boolean)} where we list the config in * a sub path only */ @Test public void testListSubConfig() { final String subDir = "suite/"; List listConfigs = mRealFactory.getConfigList(subDir, false); assertTrue(listConfigs.size() != 0); // Check that our basic configs are always here assertTrue(listConfigs.contains("suite/stub1")); assertTrue(listConfigs.contains("suite/stub2")); // Validate that all listed config are indeed from the subdir. for (String config : listConfigs) { assertTrue(config.startsWith(subDir)); } } /** Test loading a config that includes another config. */ @Test public void testCreateConfigurationFromArgs_includeConfig() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{INCLUDE_CONFIG}); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); StubOptionTest fromTestConfig = (StubOptionTest) config.getTests().get(0); StubOptionTest fromIncludeConfig = (StubOptionTest) config.getTests().get(1); assertEquals("valueFromTestConfig", fromTestConfig.mOption); assertEquals("valueFromIncludeConfig", fromIncludeConfig.mOption); } /** * Test loading a config that uses the "default" attribute of a template-include tag to include * another config. */ @Test public void testCreateConfigurationFromArgs_defaultTemplateInclude_default() throws Exception { // The default behavior is to include test-config directly. Nesting is such that innermost // elements come first. IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"template-include-config-with-default"}); assertEquals(2, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); StubOptionTest innerConfig = (StubOptionTest) config.getTests().get(0); StubOptionTest outerConfig = (StubOptionTest) config.getTests().get(1); assertEquals("valueFromTestConfig", innerConfig.mOption); assertEquals("valueFromTemplateIncludeWithDefaultConfig", outerConfig.mOption); } /** * Test using {@code } to load a config that uses the "default" attribute of a * template-include tag to include a third config. */ @Test public void testCreateConfigurationFromArgs_includeTemplateIncludeWithDefault() throws Exception { // The default behavior is to include test-config directly. Nesting is such that innermost // elements come first. IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"include-template-config-with-default"}); assertEquals(3, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); assertTrue(config.getTests().get(2) instanceof StubOptionTest); StubOptionTest innerConfig = (StubOptionTest) config.getTests().get(0); StubOptionTest middleConfig = (StubOptionTest) config.getTests().get(1); StubOptionTest outerConfig = (StubOptionTest) config.getTests().get(2); assertEquals("valueFromTestConfig", innerConfig.mOption); assertEquals("valueFromTemplateIncludeWithDefaultConfig", middleConfig.mOption); assertEquals("valueFromIncludeTemplateConfigWithDefault", outerConfig.mOption); } /** * Test loading a config that uses the "default" attribute of a template-include tag to include * another config. In this case, we override the default attribute on the commandline. */ @Test public void testCreateConfigurationFromArgs_defaultTemplateInclude_alternate() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"template-include-config-with-default", "--template:map", "target", INCLUDE_CONFIG}); assertEquals(3, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); assertTrue(config.getTests().get(2) instanceof StubOptionTest); StubOptionTest innerConfig = (StubOptionTest) config.getTests().get(0); StubOptionTest middleConfig = (StubOptionTest) config.getTests().get(1); StubOptionTest outerConfig = (StubOptionTest) config.getTests().get(2); assertEquals("valueFromTestConfig", innerConfig.mOption); assertEquals("valueFromIncludeConfig", middleConfig.mOption); assertEquals("valueFromTemplateIncludeWithDefaultConfig", outerConfig.mOption); } /** Test loading a config that uses template-include to include another config. */ @Test public void testCreateConfigurationFromArgs_templateInclude() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"template-include-config", "--template:map", "target", "test-config"}); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); StubOptionTest fromTestConfig = (StubOptionTest) config.getTests().get(0); StubOptionTest fromTemplateIncludeConfig = (StubOptionTest) config.getTests().get(1); assertEquals("valueFromTestConfig", fromTestConfig.mOption); assertEquals("valueFromTemplateIncludeConfig", fromTemplateIncludeConfig.mOption); } @Test public void testCreateConfigurationFromArgs_repeatedTemplate() throws Exception { try { mFactory.createConfigurationFromArgs( new String[] {"repeated-template", "--template:map", "target", "empty"}); fail("Should have thrown an exception."); } catch (ConfigurationException expected) { assertEquals( "Failed to parse config xml 'repeated-template'. Reason: Template named " + "'target' appeared more than once.", expected.getMessage()); } } /** Test loading a config that uses template-include to include another config. */ @Test public void testCreateConfigurationFromArgs_templateInclude_multiKey() throws Exception { try { mFactory.createConfigurationFromArgs( new String[] { "template-include-config", "--template:map", "target", "test-config", "--template:map", "target", "test-config" }); fail("Should have thrown an exception."); } catch (ConfigurationException expected) { // Expected assertEquals( "More than one template specified for key 'target'", expected.getMessage()); } } /** Make sure that we throw a useful error when template-include usage is underspecified. */ @Test public void testCreateConfigurationFromArgs_templateInclude_unspecified() throws Exception { final String configName = "template-include-config"; try { mFactory.createConfigurationFromArgs(new String[]{configName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { // Make sure that we get the expected error message final String msg = e.getMessage(); assertNotNull(msg); assertTrue(String.format("Error message does not mention the name of the broken " + "config. msg was: %s", msg), msg.contains(configName)); // Error message should help people to resolve the problem assertTrue(String.format("Error message should help user to resolve the " + "template-include. msg was: %s", msg), msg.contains(String.format("--template:map %s", "target"))); CLog.e(msg); assertTrue( String.format( "Error message should mention the ability to specify a " + "default resolution. msg was: %s", msg), msg.contains("'default'")); } } /** * Make sure that we throw a useful error when template-include mentions a target configuration * that doesn't exist. */ @Test public void testCreateConfigurationFromArgs_templateInclude_missing() throws Exception { final String configName = "template-include-config"; final String includeName = "no-exist"; try { mFactory.createConfigurationFromArgs( new String[]{configName, "--template:map", "target", includeName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { // Make sure that we get the expected error message final String msg = e.getMessage(); assertNotNull(msg); assertTrue(String.format("Error message does not mention the name of the broken " + "config. msg was: %s", msg), msg.contains(configName)); assertTrue(String.format("Error message does not mention the name of the missing " + "include target. msg was: %s", msg), msg.contains(includeName)); } } /** Test loading a config that includes a local config. */ @Test public void testCreateConfigurationFromArgs_templateInclude_local() throws Exception { final String configName = "template-include-config"; InputStream configStream = getClass().getResourceAsStream( String.format("/testconfigs/%s.xml", INCLUDE_CONFIG)); File tmpConfig = FileUtil.createTempFile(INCLUDE_CONFIG, ".xml"); try { FileUtil.writeToFile(configStream, tmpConfig); final String includeName = tmpConfig.getAbsolutePath(); IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{configName, "--template:map", "target", includeName}); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); StubOptionTest fromTestConfig = (StubOptionTest) config.getTests().get(0); StubOptionTest fromIncludeConfig = (StubOptionTest) config.getTests().get(1); assertEquals("valueFromTestConfig", fromTestConfig.mOption); assertEquals("valueFromIncludeConfig", fromIncludeConfig.mOption); } finally { FileUtil.deleteFile(tmpConfig); } } /** * This unit test codifies the expectation that an inner {@code } tag is * properly found and replaced by a config containing another template that is resolved. MAIN * CONFIG -> Template 1 -> Template 2 = Works! */ @Test public void testCreateConfigurationFromArgs_templateInclude_dependent() throws Exception { final String configName = "depend-template-include-config"; final String depTargetName = "template-include-config"; final String targetName = "test-config"; IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { configName, "--template:map", "dep-target", depTargetName, "--template:map", "target", targetName }); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); } /** * This unit test codifies the expectation that an inner {@code } tag replaced * by a missing config raise a failure. MAIN CONFIG -> Template 1 -> Template 2(missing) = error */ @Test public void testCreateConfigurationFromArgs_templateInclude_dependent_missing() throws Exception { final String configName = "depend-template-include-config"; final String depTargetName = "template-include-config"; final String targetName = "test-config-missing"; final String expError = String.format( "Bundled config '%s' is including a config '%s' that's neither local nor bundled.", depTargetName, targetName); try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", "dep-target", depTargetName, "--template:map", "target", targetName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { // Make sure that we get the expected error message assertEquals(expError, e.getMessage()); } } /** * This unit test codifies the expectation that an inner {@code } tag that * doesn't have a default attribute will fail because cannot be resolved. MAIN CONFIG -> * Template 1 -> Template 2(no Default, no args override) = error */ @Test public void testCreateConfigurationFromArgs_templateInclude_dependent_nodefault() throws Exception { final String configName = "depend-template-include-config"; final String depTargetName = "template-include-config"; final String expError = String.format( "Failed to parse config xml '%s'. Reason: " + ConfigurationXmlParser.ConfigHandler.INNER_TEMPLATE_INCLUDE_ERROR, configName, configName, depTargetName); try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", "dep-target", depTargetName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { assertEquals(expError, e.getMessage()); } } /** * This unit test codifies the expectation that an inner {@code } tag that is * inside an include tag will be correctly replaced by arguments. Main Config -> Include 1 -> * Template 1 -> test-config.xml */ @Test public void testCreateConfigurationFromArgs_include_dependent() throws Exception { final String configName = "include-template-config"; final String targetName = "test-config"; try { IConfiguration config = mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", "target", targetName}); assertTrue(config.getTests().get(0) instanceof StubOptionTest); assertTrue(config.getTests().get(1) instanceof StubOptionTest); } catch (ConfigurationException e) { fail(e.getMessage()); } } /** * This unit test ensure that when a configuration use included configuration the top * configuration description is kept. */ @Test public void testTopDescriptionIsPreserved() throws ConfigurationException { final String configName = "top-config"; Map fakeTemplate = new HashMap<>(); fakeTemplate.put("target", "included-config"); ConfigurationDef test = mFactory.new ConfigLoader(false) .getConfigurationDef(configName, fakeTemplate); assertEquals("top config description", test.getDescription()); } /** * This unit test codifies the expectation that an inner {@code } tag that is * inside an include tag will be correctly rejected if no arguments can match it and no default * value is present. Main Config -> Include 1 -> Template 1 (No default, no args override) = * error */ @Test public void testCreateConfigurationFromArgs_include_dependent_nodefault() throws Exception { final String configName = "include-template-config"; final String includeTargetName = "template-include-config"; final String expError = String.format( "Failed to parse config xml '%s'. Reason: " + ConfigurationXmlParser.ConfigHandler.INNER_TEMPLATE_INCLUDE_ERROR, configName, configName, includeTargetName); try { mFactory.createConfigurationFromArgs(new String[]{configName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { assertEquals(expError, e.getMessage()); } } /** Test loading a config that tries to include itself */ @Test public void testCreateConfigurationFromArgs_recursiveInclude() throws Exception { try { mFactory.createConfigurationFromArgs(new String[] {"recursive-config"}); fail("ConfigurationException not thrown"); } catch (ConfigurationException e) { // expected } } /** * Test loading a config that tries to replace a template with itself will fail because it * creates a cycle of configuration. */ @Test public void testCreateConfigurationFromArgs_recursiveTemplate() throws Exception { final String configName = "depend-template-include-config"; final String depTargetName = "depend-template-include-config"; final String expError = String.format( "Circular configuration include: config '%s' is already included", depTargetName); try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", "dep-target", depTargetName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { assertEquals(expError, e.getMessage()); } } /** * Re-apply a template on a lower config level. Should result in a fail to parse because each * template:map can only be applied once. So missing the default will throw exception. */ @Test public void testCreateConfigurationFromArgs_template_multilevel() throws Exception { final String configName = "depend-template-include-config"; final String depTargetName = "template-include-config"; final String depTargetName2 = "template-collision-include-config"; final String expError = String.format( "Failed to parse config xml '%s'. Reason: " + ConfigurationXmlParser.ConfigHandler.INNER_TEMPLATE_INCLUDE_ERROR, configName, configName, depTargetName2); try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", "dep-target", depTargetName, "--template:map", "target", depTargetName2}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { assertEquals(expError, e.getMessage()); } } /** * Re-apply a template twice. Should result in an error only because the configs included have * several build_provider */ @Test public void testCreateConfigurationFromArgs_templateCollision() throws Exception { final String configName = "template-collision-include-config"; final String depTargetName = "template-include-config-with-default"; final String expError = "Failed to parse config xml 'template-collision-include-config'. Reason: " + "Template named 'target' appeared more than once."; try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", "target-col", depTargetName, "--template:map", "target-col2", depTargetName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { assertEquals(expError, e.getMessage()); } } /** Test loading a config that tries to include a non-bundled config. */ @Test public void testCreateConfigurationFromArgs_nonBundledInclude() throws Exception { try { mFactory.createConfigurationFromArgs(new String[] {"non-bundled-config"}); fail("ConfigurationException not thrown"); } catch (ConfigurationException e) { // expected } } /** Test reloading a config after it has been updated. */ @Test public void testCreateConfigurationFromArgs_localConfigReload() throws ConfigurationException, IOException { File localConfigFile = FileUtil.createTempFile("local-config", ".xml"); try { // Copy the config to the local filesystem InputStream source = getClass().getResourceAsStream("/testconfigs/local-config.xml"); FileUtil.writeToFile(source, localConfigFile); // Depending on the system, file modification times might not have greater than 1 second // resolution. Backdate the original contents so that when we write to the file later, // it shows up as a new change. localConfigFile.setLastModified(System.currentTimeMillis() - 5000); // Load the configuration from the local file IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { localConfigFile.getAbsolutePath() }); if (!(config.getTests().get(0) instanceof StubOptionTest)) { fail(String.format("Expected a StubOptionTest, but got %s", config.getTests().get(0).getClass().getName())); return; } StubOptionTest test = (StubOptionTest)config.getTests().get(0); assertEquals("valueFromOriginalConfig", test.mOption); // Change the contents of the local file source = getClass().getResourceAsStream("/testconfigs/local-config-update.xml"); FileUtil.writeToFile(source, localConfigFile); // Get the configuration again and verify that it picked up the update config = mFactory.createConfigurationFromArgs( new String[] { localConfigFile.getAbsolutePath() }); if (!(config.getTests().get(0) instanceof StubOptionTest)) { fail(String.format("Expected a StubOptionTest, but got %s", config.getTests().get(0).getClass().getName())); return; } test = (StubOptionTest)config.getTests().get(0); assertEquals("valueFromUpdatedConfig", test.mOption); } finally { FileUtil.deleteFile(localConfigFile); } } /** Test loading a config that has a circular include */ @Test public void testCreateConfigurationFromArgs_circularInclude() throws Exception { try { mFactory.createConfigurationFromArgs(new String[] {"circular-config"}); fail("ConfigurationException not thrown"); } catch (ConfigurationException e) { // expected } } /** * If a template:map argument is passed but doesn't match any {@code } tag a * configuration exception will be thrown for unmatched arguments. */ @Test public void testCreateConfigurationFromArgs_templateName_notExist() throws Exception { final String configName = "include-template-config-with-default"; final String targetName = "test-config"; final String missingNameTemplate = "NOTEXISTINGNAME"; Map expected = new HashMap(); expected.put(missingNameTemplate, targetName); final String expError = String.format( "Unused template:map parameters: %s", expected); try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", missingNameTemplate, targetName}); fail ("ConfigurationException not thrown"); } catch (ConfigurationException e) { // Make sure that we get the expected error message assertEquals(expError, e.getMessage()); } } /** * If a configuration is called a second time, ensure that the cached config is also properly * returned, and that template:map did not cause issues. */ @Test public void testCreateConfigurationFromArgs_templateName_notExistTest() throws Exception { final String configName = "template-include-config-with-default"; final String targetName = "local-config"; final String nameTemplate = "target"; IConfiguration tmp = null; try { tmp = mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", nameTemplate, targetName}); } catch (ConfigurationException e) { fail("ConfigurationException thrown: " + e.getMessage()); } assertTrue(tmp.getTests().size() == 2); // Call the same config a second time to make sure the cached version works. try { tmp = mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", nameTemplate, targetName}); } catch (ConfigurationException e) { fail("ConfigurationException thrown: " + e.getMessage()); } assertTrue(tmp.getTests().size() == 2); } /** * If a configuration is called a second time with bad template name, it should still throw the * unused config template:map */ @Test public void testCreateConfigurationFromArgs_templateName_stillThrow() throws Exception { final String configName = "template-include-config-with-default"; final String targetName = "local-config"; final String nameTemplate = "target_not_exist"; try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", nameTemplate, targetName}); fail("ConfigurationException should have been thrown"); } catch (ConfigurationException e) { // expected } // Call the same config a second time to make sure it is also rejected. try { mFactory.createConfigurationFromArgs(new String[]{configName, "--template:map", nameTemplate, targetName}); fail("ConfigurationException should have been thrown"); } catch (ConfigurationException e) { // expected } } /** Parse a config with 3 different device configuration specified. */ @Test public void testCreateConfigurationFromArgs_multidevice() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"multi-device"}); assertEquals(1, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); // Verify that all attributes are in the right place: assertNotNull(config.getDeviceConfigByName("device1")); assertEquals("10", config.getDeviceConfigByName("device1") .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName("device1") .getBuildProvider().getBuild().getTestTag()); assertEquals(0, config.getDeviceConfigByName("device1") .getTargetPreparers().size()); assertNotNull(config.getDeviceConfigByName("device2")); assertEquals("0", config.getDeviceConfigByName("device2") .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName("device2") .getBuildProvider().getBuild().getTestTag()); assertEquals(1, config.getDeviceConfigByName("device2") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device2") .getTargetPreparers().get(0) instanceof StubTargetPreparer); assertNotNull(config.getDeviceConfigByName("device3")); assertEquals("0", config.getDeviceConfigByName("device3") .getBuildProvider().getBuild().getBuildId()); assertEquals("build-flavor3", config.getDeviceConfigByName("device3") .getBuildProvider().getBuild().getBuildFlavor()); assertEquals(2, config.getDeviceConfigByName("device3") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device3") .getTargetPreparers().get(0) instanceof StubTargetPreparer); } /** * Test that if an object inside a tag is implementing {@link IConfigurationReceiver} * it will receives the config properly like non-device object. */ @Test public void testCreateConfigurationFromArgs_injectConfiguration() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs(new String[] {"multi-device"}); assertEquals(1, config.getTests().size()); assertNotNull(config.getDeviceConfigByName("device2")); assertEquals(1, config.getDeviceConfigByName("device2").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device2").getTargetPreparers().get(0) instanceof StubTargetPreparer); StubTargetPreparer stubDevice2 = (StubTargetPreparer) config.getDeviceConfigByName("device2").getTargetPreparers().get(0); assertEquals(config, stubDevice2.getConfiguration()); assertNotNull(config.getDeviceConfigByName("device3")); assertEquals(2, config.getDeviceConfigByName("device3").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device3").getTargetPreparers().get(0) instanceof StubTargetPreparer); StubTargetPreparer stubDevice3 = (StubTargetPreparer) config.getDeviceConfigByName("device3").getTargetPreparers().get(0); assertEquals(config, stubDevice3.getConfiguration()); } /** * Parse a config with 3 different device configuration specified. And apply a command line to * override some attributes. */ @Test public void testCreateConfigurationFromArgs_multidevice_applyCommandLine() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"multi-device", "--{device2}build-id","20", "--{device1}null-device", "--{device3}com.android.tradefed.build.StubBuildProvider:build-id","30"}); assertEquals(1, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); // Verify that all attributes are in the right place: assertNotNull(config.getDeviceConfigByName("device1")); assertEquals("10", config.getDeviceConfigByName("device1") .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName("device1") .getBuildProvider().getBuild().getTestTag()); assertEquals(0, config.getDeviceConfigByName("device1") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device1") .getDeviceRequirements().nullDeviceRequested()); assertNotNull(config.getDeviceConfigByName("device2")); // Device2 build provider is modified independently assertEquals("20", config.getDeviceConfigByName("device2") .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName("device2") .getBuildProvider().getBuild().getTestTag()); assertEquals(1, config.getDeviceConfigByName("device2") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device2") .getTargetPreparers().get(0) instanceof StubTargetPreparer); assertFalse(config.getDeviceConfigByName("device2") .getDeviceRequirements().nullDeviceRequested()); // Device3 build provider is modified independently assertNotNull(config.getDeviceConfigByName("device3")); assertEquals("30", config.getDeviceConfigByName("device3") .getBuildProvider().getBuild().getBuildId()); assertEquals("build-flavor3", config.getDeviceConfigByName("device3") .getBuildProvider().getBuild().getBuildFlavor()); assertEquals(2, config.getDeviceConfigByName("device3") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device3") .getTargetPreparers().get(0) instanceof StubTargetPreparer); assertFalse(config.getDeviceConfigByName("device3") .getDeviceRequirements().nullDeviceRequested()); } /** * Parse a config with 3 different device configuration specified. And apply a command line to * override some attributes. */ @Test public void testCreateConfigurationFromArgs_multidevice_singletag() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { "multi-device-empty", "--{device2}build-id", "20", "--{device1}null-device", "--{device3}com.android.tradefed.build.StubBuildProvider:build-id", "30" }); assertEquals(1, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); // Verify that all attributes are in the right place: assertNotNull(config.getDeviceConfigByName("device1")); assertEquals( "0", config.getDeviceConfigByName("device1").getBuildProvider().getBuild().getBuildId()); assertEquals( "stub", config.getDeviceConfigByName("device1").getBuildProvider().getBuild().getTestTag()); assertEquals(0, config.getDeviceConfigByName("device1").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device1") .getDeviceRequirements() .nullDeviceRequested()); assertNotNull(config.getDeviceConfigByName("device2")); // Device2 build provider is modified independently assertEquals( "20", config.getDeviceConfigByName("device2").getBuildProvider().getBuild().getBuildId()); assertEquals( "stub", config.getDeviceConfigByName("device2").getBuildProvider().getBuild().getTestTag()); assertEquals(0, config.getDeviceConfigByName("device2").getTargetPreparers().size()); assertFalse( config.getDeviceConfigByName("device2") .getDeviceRequirements() .nullDeviceRequested()); // Device3 build provider is modified independently assertNotNull(config.getDeviceConfigByName("device3")); assertEquals( "30", config.getDeviceConfigByName("device3").getBuildProvider().getBuild().getBuildId()); assertEquals(0, config.getDeviceConfigByName("device3").getTargetPreparers().size()); assertFalse( config.getDeviceConfigByName("device3") .getDeviceRequirements() .nullDeviceRequested()); } /** * Parse a config with 3 different device configuration specified. And apply a command line to * override all attributes. */ @Test public void testCreateConfigurationFromArgs_multidevice_applyCommandLineGlobal() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"multi-device", "--build-id","20"}); assertEquals(1, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); // Verify that all attributes are in the right place: // All build id are now modified since option had a global scope assertNotNull(config.getDeviceConfigByName("device1")); assertEquals("20", config.getDeviceConfigByName("device1") .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName("device1") .getBuildProvider().getBuild().getTestTag()); assertEquals(0, config.getDeviceConfigByName("device1") .getTargetPreparers().size()); assertNotNull(config.getDeviceConfigByName("device2")); assertEquals("20", config.getDeviceConfigByName("device2") .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName("device2") .getBuildProvider().getBuild().getTestTag()); assertEquals(1, config.getDeviceConfigByName("device2") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device2") .getTargetPreparers().get(0) instanceof StubTargetPreparer); assertNotNull(config.getDeviceConfigByName("device3")); assertEquals("20", config.getDeviceConfigByName("device3") .getBuildProvider().getBuild().getBuildId()); assertEquals("build-flavor3", config.getDeviceConfigByName("device3") .getBuildProvider().getBuild().getBuildFlavor()); assertEquals(2, config.getDeviceConfigByName("device3") .getTargetPreparers().size()); assertTrue(config.getDeviceConfigByName("device3") .getTargetPreparers().get(0) instanceof StubTargetPreparer); } /** * Test that when tags are out of order (device 1 - device 2 - device 1) and an option * is specified in the last device 1 with an increased frequency (a same class object from the * first device 1 or 2), the option is properly found and assigned. */ @Test public void testCreateConfigurationFromArgs_frequency() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs(new String[] {"multi-device-mix"}); assertNotNull(config.getDeviceConfigByName("device1")); assertEquals(3, config.getDeviceConfigByName("device1").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device1").getTargetPreparers().get(0) instanceof DeviceWiper); DeviceWiper prep1 = (DeviceWiper) config.getDeviceConfigByName("device1").getTargetPreparers().get(0); assertTrue(prep1.isDisabled()); assertTrue( config.getDeviceConfigByName("device1").getTargetPreparers().get(2) instanceof DeviceWiper); DeviceWiper prep3 = (DeviceWiper) config.getDeviceConfigByName("device1").getTargetPreparers().get(2); assertFalse(prep3.isDisabled()); assertNotNull(config.getDeviceConfigByName("device2")); assertEquals(1, config.getDeviceConfigByName("device2").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device2").getTargetPreparers().get(0) instanceof DeviceWiper); DeviceWiper prep2 = (DeviceWiper) config.getDeviceConfigByName("device2").getTargetPreparers().get(0); // Only device 1 preparer has been targeted. assertTrue(prep2.isDisabled()); } /** * Tests a different usage of options for a multi device interleaved config where options are * specified. */ @Test public void testCreateConfigurationFromArgs_frequency_withOptionOpen() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs(new String[] {"multi-device-mix-options"}); assertNotNull(config.getDeviceConfigByName("device1")); assertEquals(3, config.getDeviceConfigByName("device1").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device1").getTargetPreparers().get(0) instanceof DeviceWiper); DeviceWiper prep1 = (DeviceWiper) config.getDeviceConfigByName("device1").getTargetPreparers().get(0); assertTrue(prep1.isDisabled()); assertTrue( config.getDeviceConfigByName("device1").getTargetPreparers().get(2) instanceof DeviceWiper); DeviceWiper prep3 = (DeviceWiper) config.getDeviceConfigByName("device1").getTargetPreparers().get(2); assertFalse(prep3.isDisabled()); assertNotNull(config.getDeviceConfigByName("device2")); assertEquals(1, config.getDeviceConfigByName("device2").getTargetPreparers().size()); assertTrue( config.getDeviceConfigByName("device2").getTargetPreparers().get(0) instanceof DeviceWiper); DeviceWiper prep2 = (DeviceWiper) config.getDeviceConfigByName("device2").getTargetPreparers().get(0); // Only device 1 preparer has been targeted. assertTrue(prep2.isDisabled()); } /** * Configuration for multi device is wrong since it contains a build_provider tag outside the * devices tags. */ @Test public void testCreateConfigurationFromArgs_multidevice_exception() throws Exception { String expectedException = "You seem to want a multi-devices configuration but you have " + "[build_provider] tags outside the tags"; try { mFactory.createConfigurationFromArgs(new String[]{"multi-device-outside-tag"}); fail("Should have thrown a Configuration Exception"); } catch(ConfigurationException e) { assertEquals(expectedException, e.getMessage()); } } /** * Parse a config with no multi device config, and expect the new device holder to still be * there and adding a default device. */ @Test public void testCreateConfigurationFromArgs_old_config_with_deviceHolder() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[]{"test-config", "--build-id","20", "--serial", "test"}); assertEquals(1, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); // Verify that all attributes are in the right place: // All build id are now modified since option had a global scope assertNotNull(config.getDeviceConfigByName(ConfigurationDef.DEFAULT_DEVICE_NAME)); assertEquals("20", config.getDeviceConfigByName(ConfigurationDef.DEFAULT_DEVICE_NAME) .getBuildProvider().getBuild().getBuildId()); assertEquals("stub", config.getDeviceConfigByName(ConfigurationDef.DEFAULT_DEVICE_NAME) .getBuildProvider().getBuild().getTestTag()); assertEquals(1, config.getDeviceConfigByName(ConfigurationDef.DEFAULT_DEVICE_NAME) .getTargetPreparers().size()); List serials = new ArrayList(); serials.add("test"); assertEquals(serials, config.getDeviceRequirements().getSerials(null)); assertEquals( serials, config.getDeviceConfigByName(ConfigurationDef.DEFAULT_DEVICE_NAME) .getDeviceRequirements() .getSerials(null)); } /** * Test that when parsing command line options, boolean options with Device tag and namespace * are correctly assigned. */ @Test public void testCreateConfiguration_injectDeviceBooleanOption() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { "test-config-multi", "--{device1}no-test-boolean-option", "--{device1}test-boolean-option-false", // testing with namespace too "--{device2}stub-preparer:no-test-boolean-option", "--{device2}stub-preparer:test-boolean-option-false" }); assertEquals(2, config.getDeviceConfig().size()); IDeviceConfiguration device1 = config.getDeviceConfigByName("device1"); StubTargetPreparer deviceSetup1 = (StubTargetPreparer) device1.getTargetPreparers().get(0); // default value of test-boolean-option is true, we set it to false assertFalse(deviceSetup1.getTestBooleanOption()); // default value of test-boolean-option-false is false, we set it to true. assertTrue(deviceSetup1.getTestBooleanOptionFalse()); IDeviceConfiguration device2 = config.getDeviceConfigByName("device2"); StubTargetPreparer deviceSetup2 = (StubTargetPreparer) device2.getTargetPreparers().get(0); assertFalse(deviceSetup2.getTestBooleanOption()); assertTrue(deviceSetup2.getTestBooleanOptionFalse()); } /** Test that when an tag is used inside a tag we correctly resolve it. */ @Test public void testCreateConfiguration_includeInDevice() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[] {"test-config-multi-include", "--test-dir", "faketestdir"}); assertEquals(2, config.getDeviceConfig().size()); IDeviceConfiguration device1 = config.getDeviceConfigByName("device1"); assertTrue(device1.getTargetPreparers().get(0) instanceof StubTargetPreparer); // The included config in device2 loads a different build_provider IDeviceConfiguration device2 = config.getDeviceConfigByName("device2"); assertTrue(device2.getBuildProvider() instanceof LocalDeviceBuildProvider); LocalDeviceBuildProvider provider = (LocalDeviceBuildProvider) device2.getBuildProvider(); // command line options are properly propagated to the included object in device tag. assertEquals("faketestdir", provider.getTestDir().getName()); } /** * Test when an tag tries to load a tag inside another tag. This * should throw an exception. */ @Test public void testCreateConfiguration_includeInDevice_inDevice() throws Exception { try { mFactory.createConfigurationFromArgs( new String[] { "multi-device-incorrect-include", }); fail("Should have thrown an exception."); } catch (ConfigurationException expected) { assertEquals( " tag cannot be included inside another device", expected.getMessage()); } } /** Test that {@link ConfigurationFactory#reorderArgs(String[])} is properly reordering args. */ @Test public void testReorderArgs_check_ordering() throws Throwable { String[] args = new String[] { "config", "--option1", "o1", "--template:map", "tm=tm1", "--option2", "--option3", "o3", "--template:map", "tm", "tm2" }; String[] wantArgs = new String[] { "config", "--template:map", "tm=tm1", "--template:map", "tm", "tm2", "--option1", "o1", "--option2", "--option3", "o3" }; assertEquals(Arrays.toString(wantArgs), Arrays.toString(mFactory.reorderArgs(args))); } /** * Test that {@link ConfigurationFactory#reorderArgs(String[])} properly handles a short arg * after a template arg. */ @Test public void testReorderArgs_template_with_short_arg() throws Throwable { String[] args = new String[] { "config", "--option1", "o1", "--template:map", "tm=tm1", "-option2", "--option3", "o3", "--template:map", "tm", "tm2" }; String[] wantArgs = new String[] { "config", "--template:map", "tm=tm1", "--template:map", "tm", "tm2", "--option1", "o1", "-option2", "--option3", "o3" }; assertEquals(Arrays.toString(wantArgs), Arrays.toString(mFactory.reorderArgs(args))); } /** * Test that {@link ConfigurationFactory#reorderArgs(String[])} properly handles a incomplete * template arg. */ @Test public void testReorderArgs_incomplete_template_arg() throws Throwable { String[] args = new String[] { "config", "--option1", "o1", "--template:map", "tm=tm1", "-option2", "--option3", "o3", "--template:map", }; String[] wantArgs = new String[] { "config", "--template:map", "tm=tm1", "--template:map", "--option1", "o1", "-option2", "--option3", "o3" }; assertEquals(Arrays.toString(wantArgs), Arrays.toString(mFactory.reorderArgs(args))); } /** * Test that when doing a dry-run with keystore arguments, we skip the keystore validation. We * accept the argument, as long as the key exists. */ @Test public void testCreateConfigurationFromArgs_dryRun_keystore() throws Exception { IConfiguration res = mFactory.createConfigurationFromArgs( new String[] { "test-config", "--build-id", "USE_KEYSTORE@test_string", "--dry-run", "--online-wait-time=USE_KEYSTORE@test_long", "--min-battery-after-recovery", "USE_KEYSTORE@test_int", "--disable-unresponsive-reboot=USE_KEYSTORE@test_boolean", }); res.validateOptions(); // we still throw exception if the option itself doesn't exists. try { mFactory.createConfigurationFromArgs( new String[] { "test-config", "--does-not-exists", "USE_KEYSTORE@test_string", "--dry-run" }); fail("Should have thrown an exception."); } catch (ConfigurationException expected) { // expected } } /** * Test that when mandatory option are set with a keystore during a dry-run, they can still be * validated. */ @Test public void testCreateConfigurationFromArgs_dryRun_keystore_required_arg() throws Exception { IConfiguration res = mFactory.createConfigurationFromArgs( new String[] { "mandatory-config", "--build-dir", "USE_KEYSTORE@test_string", "--dry-run", }); // Check that mandatory option was properly set, otherwise it will throw. res.validateOptions(); } /** * This unit test ensures that the code will search for missing test configs in directories * specified in certain environment variables. */ @Test public void testSearchConfigFromEnvVar() throws IOException { File externalConfig = FileUtil.createTempFile("external-config", ".config"); String configName = FileUtil.getBaseName(externalConfig.getName()); File tmpDir = externalConfig.getParentFile(); ConfigurationFactory spyFactory = Mockito.spy(mFactory); Mockito.doReturn(Arrays.asList(tmpDir)).when(spyFactory).getExternalTestCasesDirs(); try { File config = spyFactory.getTestCaseConfigPath(configName); assertEquals(config.getAbsolutePath(), externalConfig.getAbsolutePath()); } finally { FileUtil.deleteFile(externalConfig); } } /** * This unit test ensures that the code will search for missing test configs in directories * specified in certain environment variables, and fail as the test config still can't be found. */ @Test public void testSearchConfigFromEnvVarFailed() throws Exception { File tmpDir = FileUtil.createTempDir("config-check-var"); try { ConfigurationFactory spyFactory = Mockito.spy(mFactory); Mockito.doReturn(Arrays.asList(tmpDir)).when(spyFactory).getExternalTestCasesDirs(); File config = spyFactory.getTestCaseConfigPath("non-exist"); assertNull(config); Mockito.verify(spyFactory, Mockito.times(1)).getExternalTestCasesDirs(); } finally { FileUtil.recursiveDelete(tmpDir); } } /** * Tests that {@link ConfigurationFactory#getConfigNamesFromTestCases(String)} returns the * proper files of the subpath only. */ @Test public void testGetConfigNamesFromTestCases_subpath() throws Exception { File tmpDir = FileUtil.createTempDir("test-config-dir"); try { File config1 = FileUtil.createTempFile("testconfig1", ".config", tmpDir); FileUtil.writeToFile("", config1); File subDir = FileUtil.createTempDir("subdir", tmpDir); File config2 = FileUtil.createTempFile("testconfig2", ".xml", subDir); FileUtil.writeToFile("", config2); ConfigurationFactory spyFactory = Mockito.spy(mFactory); Mockito.doReturn(Arrays.asList(tmpDir)).when(spyFactory).getExternalTestCasesDirs(); // looking at full path we get both configs Set res = spyFactory.getConfigNamesFromTestCases(null); assertEquals(2, res.size()); res = spyFactory.getConfigNamesFromTestCases(subDir.getName()); assertEquals(1, res.size()); assertTrue(res.iterator().next().contains("testconfig2")); } finally { FileUtil.recursiveDelete(tmpDir); } } /** * Test that if the base configuration is single device and a template attempt to make it * multi-devices, it will fail and provide a clear message about which tags are not in the right * place. */ @Test public void testCreateConfigurationFromArgs_singleDeviceTemplate_includeMulti() throws Exception { try { mFactory.createConfigurationFromArgs( new String[] { "local-preparer-base", "--template:map", "config", "test-config-multi" }); fail("Should have thrown an exception"); } catch (ConfigurationException expected) { assertEquals( "You seem to want a multi-devices configuration but you have " + "[target_preparer] tags outside the tags", expected.getMessage()); } } /** * Opposite scenario of {@link * #testCreateConfigurationFromArgs_singleDeviceTemplate_includeMulti()} where the base template * is multi-devices and the template included has a single device tag. */ @Test public void testCreateConfigurationFromArgs_multiDeviceTemplate_includeSingle() throws Exception { try { mFactory.createConfigurationFromArgs( new String[] { "multi-device", "--template:map", "preparers", "local-preparer-base" }); fail("Should have thrown an exception"); } catch (ConfigurationException expected) { assertEquals( "You seem to want a multi-devices configuration but you have " + "[target_preparer] tags outside the tags", expected.getMessage()); } } /** * Test that if we load a configuration with some unfound class, we throw an exception and * report the objects that did not load. */ @Test public void testCreateConfigurationFromArgs_failedToLoadClass() throws Exception { try { mFactory.createConfigurationFromArgs(new String[] {"multi-device-incorrect"}); fail("Should have thrown an exception"); } catch (ClassNotFoundConfigurationException expected) { assertTrue( expected.getMessage() .contains( "Failed to load some objects in the configuration " + "'multi-device-incorrect':")); assertEquals( "device1:build_provider", expected.getRejectedObjects().get("com.android.tradefed.build.doesnotexists")); assertEquals( "device3:target_preparer", expected.getRejectedObjects() .get("com.android.tradefed.targetprep.doesnotexistseither")); } } /** * Test that a configuration with one real device and one fake device (isFake=true) will be * loaded like a single device config: The objects outside the tags will be part of the * real device. */ @Test public void testCreateConfiguration_multiDevice_fake() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { "test-config-multi-fake", "--{device1}no-test-boolean-option", "--{device1}test-boolean-option-false", // testing with namespace too "--{device1}stub-preparer:no-test-boolean-option", "--{device1}stub-preparer:test-boolean-option-false" }); assertEquals(2, config.getDeviceConfig().size()); IDeviceConfiguration device1 = config.getDeviceConfigByName("device1"); // One target preparer from inside the device tag, one from outside. assertEquals(2, device1.getTargetPreparers().size()); StubTargetPreparer deviceSetup1 = (StubTargetPreparer) device1.getTargetPreparers().get(0); // default value of test-boolean-option is true, we set it to false assertFalse(deviceSetup1.getTestBooleanOption()); // default value of test-boolean-option-false is false, we set it to true. assertTrue(deviceSetup1.getTestBooleanOptionFalse()); // Check that the second preparer, outside device1 can still receive option as {device1}. StubTargetPreparer deviceSetup2 = (StubTargetPreparer) device1.getTargetPreparers().get(1); // default value of test-boolean-option is true, we set it to false assertFalse(deviceSetup2.getTestBooleanOption()); // default value of test-boolean-option-false is false, we set it to true. assertTrue(deviceSetup2.getTestBooleanOptionFalse()); assertFalse(config.isDeviceConfiguredFake("device1")); assertTrue(config.isDeviceConfiguredFake("device2")); } /** * Test when a single device configuration (standard flat) add a fake device. Configuration * objects should be added to the default device. */ @Test public void testCreateConfiguration_singleDeviceConfig_withFake() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { "single-config-and-fake", "--no-test-boolean-option", "--test-boolean-option-false", // testing with namespace too "--stub-preparer:no-test-boolean-option", "--stub-preparer:test-boolean-option-false" }); assertEquals(2, config.getDeviceConfig().size()); // Ensure the first device is the default one. assertEquals( ConfigurationDef.DEFAULT_DEVICE_NAME, config.getDeviceConfig().get(0).getDeviceName()); IDeviceConfiguration device1 = config.getDeviceConfigByName(ConfigurationDef.DEFAULT_DEVICE_NAME); // One target preparer from inside the device tag, one from outside. assertEquals(2, device1.getTargetPreparers().size()); StubTargetPreparer deviceSetup1 = (StubTargetPreparer) device1.getTargetPreparers().get(0); // default value of test-boolean-option is true, we set it to false assertFalse(deviceSetup1.getTestBooleanOption()); // default value of test-boolean-option-false is false, we set it to true. assertTrue(deviceSetup1.getTestBooleanOptionFalse()); assertTrue(device1.getDeviceRequirements().gceDeviceRequested()); assertFalse(device1.getDeviceRequirements().nullDeviceRequested()); // Check that the second preparer, outside device1 can still receive option as {device1}. StubTargetPreparer deviceSetup2 = (StubTargetPreparer) device1.getTargetPreparers().get(1); // default value of test-boolean-option is true, we set it to false assertFalse(deviceSetup2.getTestBooleanOption()); // default value of test-boolean-option-false is false, we set it to true. assertTrue(deviceSetup2.getTestBooleanOptionFalse()); assertFalse(config.isDeviceConfiguredFake(ConfigurationDef.DEFAULT_DEVICE_NAME)); assertTrue(config.isDeviceConfiguredFake("device2")); IDeviceConfiguration device2 = config.getDeviceConfigByName("device2"); assertFalse(device2.getDeviceRequirements().gceDeviceRequested()); assertTrue(device2.getDeviceRequirements().nullDeviceRequested()); } /** Test that a configuration with all the device marked as isReal=false will be rejected. */ @Test public void testCreateConfiguration_multiDevice_real_notReal() throws Exception { try { mFactory.createConfigurationFromArgs(new String[] {"test-config-real-not-real"}); fail("Should have thrown an exception"); } catch (ConfigurationException expected) { assertEquals( "Failed to parse config xml 'test-config-real-not-real'. Reason: Mismatch for " + "device 'device1'. It was defined once as isFake=false, once as " + "isFake=true", expected.getMessage()); } } /** * Test that a configuration with two real devices and one fake one (isFake=false) will reject * object that are at the root: We cannot decide where to put these objects. */ @Test public void testCreateConfiguration_multiDevice_twoReal_oneFake() throws Exception { try { mFactory.createConfigurationFromArgs(new String[] {"test-config-multi-3-fake"}); fail("Should have thrown an exception"); } catch (ConfigurationException expected) { assertEquals( "You seem to want a multi-devices configuration but you have [target_preparer] " + "tags outside the tags", expected.getMessage()); } } /** Class to test out lab preparer parsing */ public static final class TestLabPreparer extends StubTargetPreparer implements ILabPreparer {} @Test public void testParse_labPreparer() throws Exception { String normalConfig = "\n" + " \n" + " \n" + ""; File tmpConfig = FileUtil.createTempFile("tmp-config-tests", ".xml"); try { FileUtil.writeToFile(normalConfig, tmpConfig); IConfiguration config = mFactory.createConfigurationFromArgs( new String[] {tmpConfig.getAbsolutePath()}); assertEquals(1, config.getLabPreparers().size()); assertFalse( ((StubTargetPreparer) config.getLabPreparers().get(0)).getTestBooleanOption()); } finally { FileUtil.deleteFile(tmpConfig); } } /** * Test that even if multi_pre_target_prep and multi_target_prep share the same type, we do not * mix the objects internally. */ @Test public void testParse_multiTargetPrep() throws Exception { String normalConfig = "\n" + " \n" + " \n" + ""; File tmpConfig = FileUtil.createTempFile("tmp-config-tests", ".xml"); try { FileUtil.writeToFile(normalConfig, tmpConfig); IConfiguration config = mFactory.createConfigurationFromArgs( new String[] {tmpConfig.getAbsolutePath()}); assertEquals(1, config.getMultiPreTargetPreparers().size()); assertEquals(1, config.getMultiTargetPreparers().size()); // Different objects have been created for each. assertNotSame( config.getMultiPreTargetPreparers().get(0), config.getMultiTargetPreparers().get(0)); } finally { FileUtil.deleteFile(tmpConfig); } } /** Test that an unexpected extension for a config file doesn't parse. */ @Test public void testParseUnexpectedFormat() throws Exception { File testConfigFile = FileUtil.createTempFile("test-config-file", ".txt"); try { mFactory.createConfigurationFromArgs(new String[] {testConfigFile.getAbsolutePath()}); fail("Should have thrown an exception"); } catch (ConfigurationException expected) { assertTrue(expected.getMessage().contains("not supported.")); } finally { FileUtil.deleteFile(testConfigFile); } } /** Test that a YAML config command line parse correctly. */ @Test public void testCreateConfigurationFromArgs_yaml() throws Exception { IConfiguration config = mFactory.createConfigurationFromArgs( new String[] { "yaml/test-config.tf_yaml", "--build-id", "5", "--build-flavor", "test", "--branch", "main" }); assertNotNull(config); IBuildProvider provider = config.getBuildProvider(); assertTrue(provider instanceof IDeviceBuildProvider); IBuildInfo info = ((IDeviceBuildProvider) provider).getBuild(null); try { assertEquals("5", info.getBuildId()); assertEquals("test", info.getBuildFlavor()); assertEquals("main", info.getBuildBranch()); } finally { info.cleanUp(); } } /** * Test that the direct config regex is working as expected * *

This test contains examples that should fail the regex. */ @Test public void testIsDirectConfigurationFalses() throws Exception { Map testMatrixMap = Map.ofEntries( entry("yaml/test-config.tf_yaml", false), entry("suite/test-mapping", false), entry( "./out/host/linux-x86/testcases/HelloWorldHostTest/HelloWorldHostTest.config", false), entry("gs/proxy-config", false)); for (Map.Entry entry : testMatrixMap.entrySet()) { assertEquals(entry.getValue(), mFactory.isDirectConfiguration(entry.getKey())); } } /** * Test that the direct config regex is working as expected * *

This test contains examples that should match the regex. */ @Test public void testIsDirectConfigurationTrues() throws Exception { Map testMatrixMap = Map.ofEntries( entry("gs://tradefed_test_resources/configs/HelloWorldHostTest.xml", true), entry("gs://other_teams_bucket/SomeOtherTest.xml", true), entry( "https://android-build.googleplex.com/objects/configs/SomeABConfig.xml", true), entry("http://source.android.com/code/AConfig.config", true), entry("file://localhost/home/tradefed/config.xml", true)); for (Map.Entry entry : testMatrixMap.entrySet()) { assertEquals(entry.getValue(), mFactory.isDirectConfiguration(entry.getKey())); } } /** Test that the direct configuration method is minimally working */ @Test public void testLoadDirectConfiguration() throws Exception { ConfigurationFactory spyFactory = Mockito.spy(mRealFactory); // extract the test-config.xml into a tmp file InputStream configStream = getClass().getResourceAsStream(String.format("/testconfigs/%s.xml", TEST_CONFIG)); File tmpFile = FileUtil.createTempFile(TEST_CONFIG, ".xml"); ResolvedFile resolvedFile = new ResolvedFile(tmpFile); String cfgPath = "gs://tradefed_test_resources/configs/test-config.xml"; try { FileUtil.writeToFile(configStream, tmpFile); // Inject it into the direct config resolver, then try to load a direct config URI cfgUri = new URI(cfgPath); Mockito.doReturn(resolvedFile) .when(spyFactory) .resolveRemoteFile(Mockito.eq(cfgUri), Mockito.any()); String args[] = {cfgPath, "--null-device"}; IConfiguration config = spyFactory.createConfigurationFromArgs(args); assertNotNull(config); // ensure it looks like what we'd expect assertTrue(config.getDeviceRequirements().nullDeviceRequested()); assertEquals(1, config.getTests().size()); assertTrue(config.getTests().get(0) instanceof StubOptionTest); } finally { FileUtil.deleteFile(tmpFile); } } private static String getClassName(String name) { // -6 because of .class return name.substring(0, name.length() - 6).replace('/', '.'); } private Map> getClassInContribJar() throws IOException { Map> jarToObject = new LinkedHashMap>(); for (File jar : getListOfBuiltJars()) { List objects = new ArrayList<>(); JarFile jarFile = null; try { jarFile = new JarFile(jar); Enumeration e = jarFile.entries(); while (e.hasMoreElements()) { JarEntry je = e.nextElement(); if (je.isDirectory() || !je.getName().endsWith(".class") || je.getName().contains("$")) { continue; } String className = getClassName(je.getName()); objects.add(className); } } finally { StreamUtil.close(jarFile); } jarToObject.put(jar.getName(), objects); } return jarToObject; } private List getListOfBuiltJars() { // testJarPath is the path of the jar file that contains this test // class. We assume the other jars live in the same dir as this test // class' jar. String testJarPath = ConfigurationFactoryTest.class .getProtectionDomain() .getCodeSource() .getLocation() .getPath(); File jarFilePath = new File(testJarPath); String jarFileParentPath = jarFilePath.getParent(); List listOfJars = new ArrayList(); File jarToCheck; for (String jar : JAR_TO_CHECK) { jarToCheck = new File(jarFileParentPath, jar); if (jarToCheck.exists()) { listOfJars.add(jarToCheck); } } return listOfJars; } }