@Test
public void testAddArtifacts() {
final PublishArtifact publishArtifactConf1 = createNamedPublishArtifact("conf1");
Configuration configurationStub1 = createConfigurationStub(publishArtifactConf1);
final PublishArtifact publishArtifactConf2 = createNamedPublishArtifact("conf2");
Configuration configurationStub2 = createConfigurationStub(publishArtifactConf2);
final ArtifactsExtraAttributesStrategy artifactsExtraAttributesStrategyMock =
context.mock(ArtifactsExtraAttributesStrategy.class);
final Map<String, String> extraAttributesArtifact1 =
WrapUtil.toMap("name", publishArtifactConf1.getName());
final Map<String, String> extraAttributesArtifact2 =
WrapUtil.toMap("name", publishArtifactConf2.getName());
context.checking(
new Expectations() {
{
one(artifactsExtraAttributesStrategyMock).createExtraAttributes(publishArtifactConf1);
will(returnValue(extraAttributesArtifact1));
one(artifactsExtraAttributesStrategyMock).createExtraAttributes(publishArtifactConf2);
will(returnValue(extraAttributesArtifact2));
}
});
DefaultModuleDescriptor moduleDescriptor =
HelperUtil.createModuleDescriptor(
WrapUtil.toSet(configurationStub1.getName(), configurationStub2.getName()));
DefaultArtifactsToModuleDescriptorConverter artifactsToModuleDescriptorConverter =
new DefaultArtifactsToModuleDescriptorConverter(artifactsExtraAttributesStrategyMock);
artifactsToModuleDescriptorConverter.addArtifacts(
moduleDescriptor, WrapUtil.toSet(configurationStub1, configurationStub2));
assertArtifactIsAdded(configurationStub1, moduleDescriptor, extraAttributesArtifact1);
assertArtifactIsAdded(configurationStub2, moduleDescriptor, extraAttributesArtifact2);
assertThat(moduleDescriptor.getAllArtifacts().length, equalTo(2));
}
@org.junit.Test
public void testExcludes() {
assertSame(test, test.exclude(TEST_PATTERN_1, TEST_PATTERN_2));
assertEquals(WrapUtil.toList(TEST_PATTERN_1, TEST_PATTERN_2), test.getExcludes());
test.exclude(TEST_PATTERN_3);
assertEquals(
WrapUtil.toList(TEST_PATTERN_1, TEST_PATTERN_2, TEST_PATTERN_3), test.getExcludes());
}
@org.junit.Test
public void testUnmanagedClasspath() {
List<Object> list1 = WrapUtil.toList("a", new Object());
assertSame(test, test.unmanagedClasspath(list1.toArray(new Object[list1.size()])));
assertEquals(list1, test.getUnmanagedClasspath());
List list2 = WrapUtil.toList(WrapUtil.toList("b", "c"));
test.unmanagedClasspath(list2.toArray(new Object[list2.size()]));
assertEquals(GUtil.addLists(list1, GUtil.flatten(list2)), test.getUnmanagedClasspath());
}
private void configureEclipse() {
eclipseWtp.setDeployName("name");
eclipseWtp.setOutputDirectory("bin");
eclipseWtp.setWarLibs(WrapUtil.<Object>toList("lib\\b.jar", "lib/a.jar"));
eclipseWtp.setProjectDependencies(WrapUtil.toList(projectDependencyMock));
eclipseWtp.setWarResourceMappings(
WrapUtil.<String, List<Object>>toMap(
"WEB-INF/lib",
WrapUtil.<Object>toList(
new File(getProject().getProjectDir(), "conf1"), "conf2/child")));
}
protected void checkTransaction(
final Set<DefaultMavenDeployment> defaultMavenDeployments,
AttachedArtifact attachedArtifact,
PublishArtifact classifierArtifact)
throws IOException, PlexusContainerException {
final Set<File> protocolJars = WrapUtil.toLinkedSet(new File("jar1"), new File("jar1"));
context.checking(
new Expectations() {
{
allowing(configurationStub).resolve();
will(returnValue(protocolJars));
allowing(deployTaskFactoryMock).create();
will(returnValue(getInstallDeployTask()));
allowing(deployTaskMock).getContainer();
will(returnValue(plexusContainerMock));
for (File protocolProviderJar : protocolJars) {
one(plexusContainerMock).addJarResource(protocolProviderJar);
}
one(deployTaskMock).setUniqueVersion(mavenDeployer.isUniqueVersion());
one(deployTaskMock).addRemoteRepository(testRepository);
one(deployTaskMock).addRemoteSnapshotRepository(testSnapshotRepository);
}
});
super.checkTransaction(defaultMavenDeployments, attachedArtifact, classifierArtifact);
}
@Test
public void deployOrInstall() throws IOException, PlexusContainerException {
getMavenResolver().mavenSettingsSupplier = context.mock(MavenSettingsSupplier.class);
PublishArtifact classifierArtifact = artifact(new File("classifier.jar"));
final DefaultMavenDeployment deployment1 =
new DefaultMavenDeployment(
artifact(new File("pom1.pom")),
artifact(new File("artifact1.jar")),
Collections.<PublishArtifact>emptySet());
final DefaultMavenDeployment deployment2 =
new DefaultMavenDeployment(
artifact(new File("pom2.pom")),
artifact(new File("artifact2.jar")),
WrapUtil.toSet(classifierArtifact));
final Set<DefaultMavenDeployment> testDefaultMavenDeployments =
WrapUtil.toSet(deployment1, deployment2);
final AttachedArtifact attachedArtifact = new AttachedArtifact();
@SuppressWarnings("unchecked")
final Action<MavenDeployment> action = context.mock(Action.class);
context.checking(
new Expectations() {
{
allowing((CustomInstallDeployTaskSupport) getInstallDeployTask())
.clearAttachedArtifactsList();
allowing((CustomInstallDeployTaskSupport) getInstallDeployTask()).getSettings();
will(returnValue(mavenSettingsMock));
allowing((CustomInstallDeployTaskSupport) getInstallDeployTask()).getProject();
will(returnValue(AntUtil.createProject()));
allowing((CustomInstallDeployTaskSupport) getInstallDeployTask()).createAttach();
will(returnValue(attachedArtifact));
one(artifactPomContainerMock).addArtifact(TEST_ARTIFACT, TEST_JAR_FILE);
allowing(artifactPomContainerMock).createDeployableFilesInfos();
will(returnValue(testDefaultMavenDeployments));
one(action).execute(deployment1);
one(action).execute(deployment2);
}
});
getMavenResolver().beforeDeployment(action);
getMavenResolver().publish(TEST_IVY_ARTIFACT, TEST_IVY_FILE, true);
getMavenResolver().publish(TEST_ARTIFACT, TEST_JAR_FILE, true);
checkTransaction(testDefaultMavenDeployments, attachedArtifact, classifierArtifact);
assertSame(mavenSettingsMock, getMavenResolver().getSettings());
}
private IvyResolver createResolver(Set<String> schemes) {
if (schemes.isEmpty()) {
throw new InvalidUserDataException(
"You must specify a base url or at least one artifact pattern for an Ivy repository.");
}
if (!WrapUtil.toSet("http", "https", "file").containsAll(schemes)) {
throw new InvalidUserDataException(
"You may only specify 'file', 'http' and 'https' urls for an Ivy repository.");
}
if (WrapUtil.toSet("http", "https").containsAll(schemes)) {
return createResolver(transportFactory.createHttpTransport(getName(), getCredentials()));
}
if (WrapUtil.toSet("file").containsAll(schemes)) {
return createResolver(transportFactory.createFileTransport(getName()));
}
throw new InvalidUserDataException(
"You cannot mix file and http(s) urls for a single Ivy repository. Please declare 2 separate repositories.");
}
private void assertArtifactIsAdded(
Configuration configuration,
DefaultModuleDescriptor moduleDescriptor,
Map<String, String> extraAttributes) {
assertThat(
moduleDescriptor.getArtifacts(configuration.getName()),
equalTo(
WrapUtil.toArray(
expectedIvyArtifact(configuration, moduleDescriptor, extraAttributes))));
}
@Test(expected = GradleException.class)
public void generateWtpWithAbsoluteSourcePathInResourceMappings() throws IOException {
configureEclipse();
eclipseWtp
.getWarResourceMappings()
.put(
"someDeployPath",
WrapUtil.<Object>toList(
new File(getProject().getProjectDir() + "xxx", "conf3").getAbsolutePath()));
eclipseWtp.generateWtp();
}
@Test
public void testResolveStrategy() {
PublishArtifact publishArtifact = createNamedPublishArtifact("someName");
Map<String, String> expectedExtraAttributes =
WrapUtil.toMap(
DefaultIvyDependencyPublisher.FILE_PATH_EXTRA_ATTRIBUTE,
publishArtifact.getFile().getAbsolutePath());
assertThat(
DefaultArtifactsToModuleDescriptorConverter.RESOLVE_STRATEGY.createExtraAttributes(
publishArtifact),
equalTo(expectedExtraAttributes));
}
private List<DependencyResolver> getAllResolvers(
List<DependencyResolver> classpathResolvers,
List<DependencyResolver> otherResolvers,
RepositoryResolver buildResolver,
ChainResolver userResolverChain,
ClientModuleResolver clientModuleResolver,
ChainResolver outerChain) {
List<DependencyResolver> allResolvers = new ArrayList(otherResolvers);
allResolvers.addAll(classpathResolvers);
allResolvers.addAll(
WrapUtil.toList(buildResolver, outerChain, clientModuleResolver, userResolverChain));
return allResolvers;
}
private File downloadTimestampedVersion(Artifact artifact, String timestampedVersion)
throws IOException {
final ModuleRevisionId artifactModuleRevisionId = artifact.getModuleRevisionId();
final ModuleRevisionId moduleRevisionId =
ModuleRevisionId.newInstance(
artifactModuleRevisionId.getOrganisation(),
artifactModuleRevisionId.getName(),
artifactModuleRevisionId.getRevision(),
WrapUtil.toMap("timestamp", timestampedVersion));
final Artifact artifactWithResolvedModuleRevisionId =
DefaultArtifact.cloneWithAnotherMrid(artifact, moduleRevisionId);
return download(artifactWithResolvedModuleRevisionId);
}
private void overwriteIncludesIfSinglePropertyIsSet(final Test test) {
String singleTest = getTaskPrefixedProperty(test, "single");
if (singleTest == null) {
return;
}
test.doFirst(
new Action<Task>() {
public void execute(Task task) {
test.getLogger().info("Running single tests with pattern: {}", test.getIncludes());
}
});
test.setIncludes(WrapUtil.toSet(String.format("**/%s*.class", singleTest)));
failIfNoTestIsExecuted(test, singleTest);
}
@Test
public void createSettings() {
final File expectedSettingsDir = new File("settingsDir");
ScriptSource expectedScriptSource = context.mock(ScriptSource.class);
Map<String, String> expectedGradleProperties = WrapUtil.toMap("key", "myvalue");
IProjectDescriptorRegistry expectedProjectDescriptorRegistry =
new DefaultProjectDescriptorRegistry();
StartParameter expectedStartParameter = new StartParameter();
final ServiceRegistryFactory serviceRegistryFactory =
context.mock(ServiceRegistryFactory.class);
final SettingsInternallServiceRegistry settingsInternallServiceRegistry =
context.mock(SettingsInternallServiceRegistry.class);
context.checking(
new Expectations() {
{
one(serviceRegistryFactory).createFor(with(any(Settings.class)));
will(returnValue(settingsInternallServiceRegistry));
}
});
SettingsFactory settingsFactory =
new SettingsFactory(
expectedProjectDescriptorRegistry,
ThreadGlobalInstantiator.getOrCreate(),
serviceRegistryFactory);
final URLClassLoader urlClassLoader = new URLClassLoader(new URL[0]);
GradleInternal gradle = context.mock(GradleInternal.class);
DefaultSettings settings =
(DefaultSettings)
settingsFactory.createSettings(
gradle,
expectedSettingsDir,
expectedScriptSource,
expectedGradleProperties,
expectedStartParameter,
urlClassLoader);
assertSame(gradle, settings.getGradle());
assertSame(expectedProjectDescriptorRegistry, settings.getProjectDescriptorRegistry());
for (Map.Entry<String, String> entry : expectedGradleProperties.entrySet()) {
assertEquals(
entry.getValue(),
((DynamicObjectAware) settings).getAsDynamicObject().getProperty(entry.getKey()));
}
assertSame(expectedSettingsDir, settings.getSettingsDir());
assertSame(expectedScriptSource, settings.getSettingsScript());
assertSame(expectedStartParameter, settings.getStartParameter());
}
protected DependencyFactory createDependencyFactory() {
ClassGenerator classGenerator = get(ClassGenerator.class);
DefaultProjectDependencyFactory projectDependencyFactory =
new DefaultProjectDependencyFactory(
startParameter.getProjectDependenciesBuildInstruction(), classGenerator);
return new DefaultDependencyFactory(
WrapUtil.<IDependencyImplementationFactory>toSet(
new ModuleDependencyFactory(classGenerator),
new SelfResolvingDependencyFactory(classGenerator),
new ClassPathDependencyFactory(
classGenerator, get(ClassPathRegistry.class), new IdentityFileResolver()),
projectDependencyFactory),
new DefaultClientModuleFactory(classGenerator),
projectDependencyFactory);
}
private Artifact expectedIvyArtifact(
Configuration configuration,
ModuleDescriptor moduleDescriptor,
Map<String, String> additionalExtraAttributes) {
PublishArtifact publishArtifact = configuration.getArtifacts().iterator().next();
Map<String, String> extraAttributes =
WrapUtil.toMap(Dependency.CLASSIFIER, publishArtifact.getClassifier());
extraAttributes.putAll(additionalExtraAttributes);
return new DefaultArtifact(
moduleDescriptor.getModuleRevisionId(),
publishArtifact.getDate(),
publishArtifact.getName(),
publishArtifact.getType(),
publishArtifact.getExtension(),
extraAttributes);
}
@Test
public void testCheckInputs() throws IOException {
assertThat(
wrapper.getInputs().getProperties().keySet(),
equalTo(
WrapUtil.toSet(
"jarPath",
"archiveClassifier",
"distributionBase",
"archiveBase",
"distributionPath",
"archiveName",
"urlRoot",
"scriptDestinationPath",
"gradleVersion",
"archivePath")));
}
private void configureBasedOnSingleProperty(final Test test) {
String singleTest = getTaskPrefixedProperty(test, "single");
if (singleTest == null) {
// configure inputs so that the test task is skipped when there are no source files.
// unfortunately, this only applies when 'test.single' is *not* applied
// We should fix this distinction, the behavior with 'test.single' or without it should be the
// same
test.getInputs().source(test.getCandidateClassFiles());
return;
}
test.prependParallelSafeAction(
new Action<Task>() {
public void execute(Task task) {
test.getLogger().info("Running single tests with pattern: {}", test.getIncludes());
}
});
test.setIncludes(WrapUtil.toSet(String.format("**/%s*.class", singleTest)));
test.addTestListener(
new NoMatchingTestsReporter("Could not find matching test for pattern: " + singleTest));
}
protected DependencyFactory createDependencyFactory() {
Instantiator instantiator = get(Instantiator.class);
ProjectDependenciesBuildInstruction projectDependenciesBuildInstruction =
new ProjectDependenciesBuildInstruction(
get(StartParameter.class).isBuildProjectDependencies());
ProjectDependencyFactory projectDependencyFactory =
new ProjectDependencyFactory(projectDependenciesBuildInstruction, instantiator);
DependencyProjectNotationParser projParser =
new DependencyProjectNotationParser(projectDependenciesBuildInstruction, instantiator);
NotationParser<? extends Dependency> moduleMapParser =
new DependencyMapNotationParser<DefaultExternalModuleDependency>(
instantiator, DefaultExternalModuleDependency.class);
NotationParser<? extends Dependency> moduleStringParser =
new DependencyStringNotationParser<DefaultExternalModuleDependency>(
instantiator, DefaultExternalModuleDependency.class);
NotationParser<? extends Dependency> selfResolvingDependencyFactory =
new DependencyFilesNotationParser(instantiator);
List<NotationParser<? extends Dependency>> notationParsers =
WrapUtil.toList(
moduleStringParser,
moduleMapParser,
selfResolvingDependencyFactory,
projParser,
new DependencyClassPathNotationParser(
instantiator, get(ClassPathRegistry.class), new IdentityFileResolver()));
DependencyNotationParser dependencyNotationParser =
new DependencyNotationParser(notationParsers);
return new DefaultDependencyFactory(
dependencyNotationParser,
new ClientModuleNotationParser(instantiator),
projectDependencyFactory);
}
private ResolveOptions createResolveOptions(Configuration configuration) {
ResolveOptions resolveOptions = new ResolveOptions();
resolveOptions.setDownload(false);
resolveOptions.setConfs(WrapUtil.toArray(configuration.getName()));
return resolveOptions;
}
/** @author Hans Dockter */
public class TestTest extends AbstractConventionTaskTest {
static final String TEST_PATTERN_1 = "pattern1";
static final String TEST_PATTERN_2 = "pattern2";
static final String TEST_PATTERN_3 = "pattern3";
static final File TEST_ROOT_DIR = new File("ROOTDir");
static final File TEST_TEST_CLASSES_DIR = new File(TEST_ROOT_DIR, "testClassesDir");
static final File TEST_TEST_RESULTS_DIR = new File(TEST_ROOT_DIR, "resultDir");
static final File TEST_TEST_REPORT_DIR = new File(TEST_ROOT_DIR, "report/tests");
static final Set TEST_DEPENDENCY_MANAGER_CLASSPATH = WrapUtil.toSet(new File("jar1"));
static final List TEST_CONVERTED_UNMANAGED_CLASSPATH = WrapUtil.toList(new File("jar2"));
static final List TEST_UNMANAGED_CLASSPATH = WrapUtil.toList("jar2");
static final List TEST_CONVERTED_CLASSPATH =
GUtil.addLists(
WrapUtil.toList(TEST_TEST_CLASSES_DIR),
TEST_CONVERTED_UNMANAGED_CLASSPATH,
TEST_DEPENDENCY_MANAGER_CLASSPATH);
static final Set<String> okTestClassNames =
new HashSet<String>(Arrays.asList("test.HumanTest", "test.CarTest"));
private JUnit4Mockery context =
new JUnit4Mockery() {
{
setImposteriser(ClassImposteriser.INSTANCE);
}
};
TestFramework testFrameworkMock = context.mock(TestFramework.class);
private ClasspathConverter classpathConverterMock = context.mock(ClasspathConverter.class);
private ExistingDirsFilter existentDirsFilterMock = context.mock(ExistingDirsFilter.class);
private FileCollection configurationMock = context.mock(FileCollection.class);
private Test test;
@Before
public void setUp() {
super.setUp();
test = new Test(getProject(), AbstractTaskTest.TEST_TASK_NAME);
((AbstractProject) test.getProject()).setProjectDir(TEST_ROOT_DIR);
context.checking(
new Expectations() {
{
one(testFrameworkMock).initialize(getProject(), test);
}
});
test.useTestFramework(testFrameworkMock);
if (!TEST_TEST_CLASSES_DIR.exists()) assertTrue(TEST_TEST_CLASSES_DIR.mkdirs());
}
public AbstractTask getTask() {
return test;
}
@org.junit.Test
public void testInit() {
assertNotNull(test.getTestFramework());
assertNotNull(test.existingDirsFilter);
assertNotNull(test.classpathConverter);
assertNull(test.getTestClassesDir());
assertNull(test.getConfiguration());
assertNull(test.getTestResultsDir());
assertNull(test.getTestReportDir());
assertNull(test.getIncludes());
assertNull(test.getExcludes());
assertNull(test.getUnmanagedClasspath());
assert test.isStopAtFailuresOrErrors();
}
@org.junit.Test
public void testExecute() {
setUpMocks(test);
setExistingDirsFilter();
context.checking(
new Expectations() {
{
one(testFrameworkMock).prepare(getProject(), test);
one(testFrameworkMock).getTestClassNames();
will(returnValue(okTestClassNames));
one(testFrameworkMock)
.execute(getProject(), test, okTestClassNames, new ArrayList<String>());
one(testFrameworkMock).report(getProject(), test);
}
});
test.execute();
}
@org.junit.Test
public void testExecuteWithoutReporting() {
setUpMocks(test);
setExistingDirsFilter();
test.setTestReport(false);
context.checking(
new Expectations() {
{
one(testFrameworkMock).prepare(getProject(), test);
one(testFrameworkMock).getTestClassNames();
will(returnValue(okTestClassNames));
one(testFrameworkMock)
.execute(getProject(), test, okTestClassNames, new ArrayList<String>());
}
});
test.execute();
}
@org.junit.Test(expected = GradleException.class)
public void testExecuteWithTestFailuresAndStopAtFailures() {
setUpMocks(test);
setExistingDirsFilter();
context.checking(
new Expectations() {
{
one(testFrameworkMock).prepare(getProject(), test);
one(testFrameworkMock).getTestClassNames();
will(returnValue(okTestClassNames));
one(testFrameworkMock)
.execute(getProject(), test, okTestClassNames, new ArrayList<String>());
}
});
test.execute();
}
@org.junit.Test
public void testExecuteWithTestFailuresAndContinueWithFailures() {
setUpMocks(test);
setExistingDirsFilter();
test.setStopAtFailuresOrErrors(false);
context.checking(
new Expectations() {
{
one(testFrameworkMock).prepare(getProject(), test);
one(testFrameworkMock).getTestClassNames();
will(returnValue(okTestClassNames));
one(testFrameworkMock)
.execute(getProject(), test, okTestClassNames, new ArrayList<String>());
one(testFrameworkMock).report(getProject(), test);
}
});
test.execute();
}
@org.junit.Test
public void testGetClasspath() {
setUpMocks(test);
assertEquals(TEST_CONVERTED_CLASSPATH, test.getClasspath());
}
public void testExecuteWithUnspecifiedCompiledTestsDir() {
setUpMocks(test);
test.setTestClassesDir(null);
try {
test.execute();
fail();
} catch (Exception e) {
assertThat(e.getCause(), Matchers.instanceOf(InvalidUserDataException.class));
}
}
public void testExecuteWithUnspecifiedTestResultsDir() {
setUpMocks(test);
test.setTestResultsDir(null);
try {
test.execute();
fail();
} catch (Exception e) {
assertThat(e.getCause(), Matchers.instanceOf(InvalidUserDataException.class));
}
}
@org.junit.Test
public void testExecuteWithNonExistingCompiledTestsDir() {
setUpMocks(test);
test.setUnmanagedClasspath(null);
context.checking(
new Expectations() {
{
allowing(existentDirsFilterMock)
.checkExistenceAndThrowStopActionIfNot(TEST_TEST_CLASSES_DIR);
will(throwException(new StopActionException()));
}
});
test.existingDirsFilter = existentDirsFilterMock;
test.execute();
}
private void setUpMocks(final Test test) {
test.setTestClassesDir(TEST_TEST_CLASSES_DIR);
test.setTestResultsDir(TEST_TEST_RESULTS_DIR);
test.setTestReportDir(TEST_TEST_REPORT_DIR);
test.setUnmanagedClasspath(TEST_UNMANAGED_CLASSPATH);
test.setConfiguration(configurationMock);
test.classpathConverter = classpathConverterMock;
context.checking(
new Expectations() {
{
allowing(configurationMock).iterator();
will(returnIterator(TEST_DEPENDENCY_MANAGER_CLASSPATH));
allowing(classpathConverterMock)
.createFileClasspath(
TEST_ROOT_DIR,
GUtil.addLists(
WrapUtil.toList(TEST_TEST_CLASSES_DIR),
TEST_UNMANAGED_CLASSPATH,
TEST_DEPENDENCY_MANAGER_CLASSPATH));
will(returnValue(TEST_CONVERTED_CLASSPATH));
}
});
}
@org.junit.Test
public void testIncludes() {
assertSame(test, test.include(TEST_PATTERN_1, TEST_PATTERN_2));
assertEquals(WrapUtil.toList(TEST_PATTERN_1, TEST_PATTERN_2), test.getIncludes());
test.include(TEST_PATTERN_3);
assertEquals(
WrapUtil.toList(TEST_PATTERN_1, TEST_PATTERN_2, TEST_PATTERN_3), test.getIncludes());
}
@org.junit.Test
public void testExcludes() {
assertSame(test, test.exclude(TEST_PATTERN_1, TEST_PATTERN_2));
assertEquals(WrapUtil.toList(TEST_PATTERN_1, TEST_PATTERN_2), test.getExcludes());
test.exclude(TEST_PATTERN_3);
assertEquals(
WrapUtil.toList(TEST_PATTERN_1, TEST_PATTERN_2, TEST_PATTERN_3), test.getExcludes());
}
@org.junit.Test
public void testUnmanagedClasspath() {
List<Object> list1 = WrapUtil.toList("a", new Object());
assertSame(test, test.unmanagedClasspath(list1.toArray(new Object[list1.size()])));
assertEquals(list1, test.getUnmanagedClasspath());
List list2 = WrapUtil.toList(WrapUtil.toList("b", "c"));
test.unmanagedClasspath(list2.toArray(new Object[list2.size()]));
assertEquals(GUtil.addLists(list1, GUtil.flatten(list2)), test.getUnmanagedClasspath());
}
private void setExistingDirsFilter() {
context.checking(
new Expectations() {
{
allowing(existentDirsFilterMock)
.checkExistenceAndThrowStopActionIfNot(TEST_TEST_CLASSES_DIR);
}
});
test.existingDirsFilter = existentDirsFilterMock;
}
@After
public void tearDown() throws IOException {
FileUtils.deleteDirectory(TEST_ROOT_DIR);
}
}
public Gradle newInstance(StartParameter startParameter) {
loggingConfigurer.configure(startParameter.getLogLevel());
ImportsReader importsReader = new ImportsReader(startParameter.getDefaultImportsFile());
CachePropertiesHandler cachePropertiesHandler = new DefaultCachePropertiesHandler();
ISettingsFinder settingsFinder =
new EmbeddedScriptSettingsFinder(
new DefaultSettingsFinder(
WrapUtil.<ISettingsFileSearchStrategy>toList(
new MasterDirSettingsFinderStrategy(), new ParentDirSettingsFinderStrategy())));
ConfigurationContainerFactory configurationContainerFactory =
new DefaultConfigurationContainerFactory();
DefaultInternalRepository internalRepository = new DefaultInternalRepository();
DependencyFactory dependencyFactory =
new DefaultDependencyFactory(
WrapUtil.<IDependencyImplementationFactory>toSet(new ModuleDependencyFactory()),
new DefaultClientModuleFactory(),
new DefaultProjectDependencyFactory());
ResolverFactory resolverFactory = new DefaultResolverFactory();
DefaultProjectEvaluator projectEvaluator =
new DefaultProjectEvaluator(
importsReader,
new DefaultScriptProcessor(
new DefaultScriptCompilationHandler(
cachePropertiesHandler, new BuildScriptTransformer()),
startParameter.getCacheUsage()),
new DefaultProjectScriptMetaData());
Gradle gradle =
new Gradle(
startParameter,
settingsFinder,
new DefaultGradlePropertiesLoader(),
new ScriptLocatingSettingsProcessor(
new PropertiesLoadingSettingsProcessor(
new ScriptEvaluatingSettingsProcessor(
new DefaultSettingsScriptMetaData(),
new DefaultScriptProcessor(
new DefaultScriptCompilationHandler(cachePropertiesHandler),
startParameter.getCacheUsage()),
importsReader,
new SettingsFactory(
new DefaultProjectDescriptorRegistry(),
dependencyFactory,
new DefaultRepositoryHandler(resolverFactory, null),
configurationContainerFactory,
internalRepository,
new BuildSourceBuilder(
new DefaultGradleFactory(
new LoggingConfigurer() {
public void configure(LogLevel logLevel) {
// do nothing
}
}),
new DefaultCacheInvalidationStrategy()))))),
new BuildLoader(
new ProjectFactory(
new TaskFactory(),
configurationContainerFactory,
dependencyFactory,
new DefaultRepositoryHandlerFactory(resolverFactory),
new DefaultPublishArtifactFactory(),
internalRepository,
projectEvaluator,
new PluginRegistry(startParameter.getPluginPropertiesFile()),
startParameter.getBuildScriptSource(),
new DefaultAntBuilderFactory(new AntLoggingAdapter())),
internalRepository),
new BuildConfigurer(new ProjectDependencies2TaskResolver()));
gradle.addBuildListener(internalRepository);
gradle.addBuildListener(projectEvaluator);
return gradle;
}
public class CommandLineConverterTestSupport {
protected TestFile currentDir;
protected File expectedBuildFile;
protected File expectedGradleUserHome = new BuildLayoutParameters().getGradleUserHomeDir();
protected File expectedCurrentDir;
protected File expectedProjectDir;
protected List<String> expectedTaskNames = WrapUtil.toList();
protected Set<String> expectedExcludedTasks = WrapUtil.toSet();
protected boolean buildProjectDependencies = true;
protected Map<String, String> expectedSystemProperties = new HashMap<String, String>();
protected Map<String, String> expectedProjectProperties = new HashMap<String, String>();
protected List<File> expectedInitScripts = new ArrayList<File>();
protected boolean expectedSearchUpwards = true;
protected boolean expectedDryRun;
protected ShowStacktrace expectedShowStackTrace = ShowStacktrace.INTERNAL_EXCEPTIONS;
protected LogLevel expectedLogLevel = LogLevel.LIFECYCLE;
protected boolean expectedColorOutput = true;
protected ConsoleOutput expectedConsoleOutput = ConsoleOutput.Auto;
protected StartParameter actualStartParameter;
protected boolean expectedProfile;
protected File expectedProjectCacheDir;
protected boolean expectedRefreshDependencies;
protected boolean expectedRerunTasks;
protected final DefaultCommandLineConverter commandLineConverter =
new DefaultCommandLineConverter();
protected boolean expectedContinue;
protected boolean expectedOffline;
protected boolean expectedRecompileScripts;
protected boolean expectedParallelProjectExecution;
protected int expectedParallelExecutorCount;
protected int expectedMaxWorkersCount = Runtime.getRuntime().availableProcessors();
protected boolean expectedConfigureOnDemand;
protected boolean expectedContinuous;
protected void checkConversion(String... args) {
actualStartParameter = new StartParameter();
actualStartParameter.setCurrentDir(currentDir);
commandLineConverter.convert(Arrays.asList(args), actualStartParameter);
// We check the params passed to the build factory
checkStartParameter(actualStartParameter);
}
protected void checkStartParameter(StartParameter startParameter) {
assertEquals(expectedBuildFile, startParameter.getBuildFile());
assertEquals(expectedTaskNames, startParameter.getTaskNames());
assertEquals(buildProjectDependencies, startParameter.isBuildProjectDependencies());
if (expectedCurrentDir != null) {
assertEquals(
expectedCurrentDir.getAbsoluteFile(), startParameter.getCurrentDir().getAbsoluteFile());
}
assertEquals(expectedProjectDir, startParameter.getProjectDir());
assertEquals(expectedSearchUpwards, startParameter.isSearchUpwards());
assertEquals(expectedProjectProperties, startParameter.getProjectProperties());
assertEquals(expectedSystemProperties, startParameter.getSystemPropertiesArgs());
assertEquals(
expectedGradleUserHome.getAbsoluteFile(),
startParameter.getGradleUserHomeDir().getAbsoluteFile());
assertEquals(expectedLogLevel, startParameter.getLogLevel());
assertEquals(expectedColorOutput, startParameter.isColorOutput());
assertEquals(expectedConsoleOutput, startParameter.getConsoleOutput());
assertEquals(expectedDryRun, startParameter.isDryRun());
assertEquals(expectedShowStackTrace, startParameter.getShowStacktrace());
assertEquals(expectedExcludedTasks, startParameter.getExcludedTaskNames());
assertEquals(expectedInitScripts, startParameter.getInitScripts());
assertEquals(expectedProfile, startParameter.isProfile());
assertEquals(expectedContinue, startParameter.isContinueOnFailure());
assertEquals(expectedOffline, startParameter.isOffline());
assertEquals(expectedRecompileScripts, startParameter.isRecompileScripts());
assertEquals(expectedRerunTasks, startParameter.isRerunTasks());
assertEquals(expectedRefreshDependencies, startParameter.isRefreshDependencies());
assertEquals(expectedProjectCacheDir, startParameter.getProjectCacheDir());
assertEquals(expectedParallelExecutorCount, startParameter.getParallelThreadCount());
assertEquals(expectedConfigureOnDemand, startParameter.isConfigureOnDemand());
assertEquals(expectedMaxWorkersCount, startParameter.getMaxWorkerCount());
assertEquals(expectedContinuous, startParameter.isContinuous());
}
}