Ejemplo n.º 1
0
  @org.junit.Test
  public void testAddsDefaultIncludeAndExcludePatternsWhenTestScanningIsOff() {
    configureTask();
    test.setScanForTestClasses(false);

    ConfigurableFileTree files = (ConfigurableFileTree) test.getCandidateClassFiles();
    assertThat(files.getDir(), equalTo(classesDir));
    assertThat(files.getIncludes(), equalTo(toSet("**/*Tests.class", "**/*Test.class")));
    assertThat(files.getExcludes(), equalTo(toSet("**/Abstract*.class")));
  }
Ejemplo n.º 2
0
 public ExecutionFailure assertThatCause(final Matcher<String> matcher) {
   if (failure instanceof LocationAwareException) {
     LocationAwareException exception = (LocationAwareException) failure;
     assertThat(exception.getReportableCauses(), hasItem(hasMessage(matcher)));
   } else {
     assertThat(failure.getCause(), notNullValue());
     assertThat(failure.getCause().getMessage(), matcher);
   }
   return this;
 }
Ejemplo n.º 3
0
 @org.junit.Test
 public void testInit() {
   assertThat(test.getTestFramework(), instanceOf(JUnitTestFramework.class));
   assertNull(test.getTestClassesDir());
   assertNull(test.getClasspath());
   assertNull(test.getTestResultsDir());
   assertNull(test.getTestReportDir());
   assertThat(test.getIncludes(), isEmpty());
   assertThat(test.getExcludes(), isEmpty());
   assertFalse(test.isIgnoreFailures());
 }
Ejemplo n.º 4
0
  @org.junit.Test
  public void testScansForTestClassesInTheTestClassesDir() {
    configureTask();
    test.include("include");
    test.exclude("exclude");

    FileTree classFiles = test.getCandidateClassFiles();
    assertThat(classFiles, instanceOf(ConfigurableFileTree.class));
    ConfigurableFileTree files = (ConfigurableFileTree) classFiles;
    assertThat(files.getDir(), equalTo(classesDir));
    assertThat(files.getIncludes(), equalTo(toSet("include")));
    assertThat(files.getExcludes(), equalTo(toSet("exclude")));
  }
Ejemplo n.º 5
0
  @Test
  public void copyActionCanChangeFileDestinationPath() {
    FileCopyDetails copyDetails = expectActionExecutedWhenFileVisited();

    RelativePath newPath = new RelativePath(true, "new");
    copyDetails.setRelativePath(newPath);
    assertThat(copyDetails.getRelativePath(), equalTo(newPath));

    copyDetails.setPath("/a/b");
    assertThat(copyDetails.getRelativePath(), equalTo(new RelativePath(true, "a", "b")));

    copyDetails.setName("new name");
    assertThat(copyDetails.getRelativePath(), equalTo(new RelativePath(true, "a", "new name")));
  }
  private void assertMatches(final String pattern, String matches, String... otherNames) {
    final Task task1 = task(matches);
    final Task task2 = task(matches);
    final Set<Task> tasks = new HashSet<Task>();
    tasks.add(task2);
    for (String name : otherNames) {
      tasks.add(task(name));
    }
    tasks.add(task("."));
    tasks.add(task("other"));

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName(pattern, true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(tasks));
            one(taskExecuter).addTasks(toSet(task1, task2));
          }
        });

    TaskNameResolvingBuildExecuter executer = new TaskNameResolvingBuildExecuter(toList(pattern));
    executer.select(gradle);
    assertThat(executer.getDisplayName(), equalTo(String.format("primary task '%s'", matches)));
  }
  @Test
  public void failsWhenUnknownTaskNameIsProvided() {
    final Task task1 = task("t1");
    final Task task2 = task("t2");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("b3", true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1, task2)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet()));
          }
        });

    BuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("b3"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(e.getMessage(), equalTo("Task 'b3' not found in [project]."));
    }
  }
  @Test
  public void treatsEachProvidedNameAsASeparateGroup() {
    final Task task1 = task("name1");
    final Task task2 = task("name2");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("name1", true);
            will(returnValue(toSet(task1)));
            one(project).getTasksByName("name2", true);
            will(returnValue(toSet(task2)));

            Sequence sequence = context.sequence("tasks");

            one(taskExecuter).addTasks(toSet(task1));
            inSequence(sequence);

            one(taskExecuter).addTasks(toSet(task2));
            inSequence(sequence);

            one(taskExecuter).execute();
            inSequence(sequence);
          }
        });

    TaskNameResolvingBuildExecuter executer =
        new TaskNameResolvingBuildExecuter(toList("name1", "name2"));
    executer.select(gradle);
    assertThat(executer.getDisplayName(), equalTo("primary tasks 'name1', 'name2'"));
    executer.execute();
  }
  @Test
  public void reportsTyposInTaskName() {
    final Task task1 = task("someTask");
    final Task task2 = task("someTasks");
    final Task task3 = task("sometask");
    final Task task4 = task("other");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("ssomeTask", true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1, task2)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet(task3, task4)));
          }
        });

    TaskNameResolvingBuildExecuter executer =
        new TaskNameResolvingBuildExecuter(toList("ssomeTask"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(
          e.getMessage(),
          equalTo(
              "Task 'ssomeTask' not found in [project]. Some candidates are: 'someTask', 'someTasks', 'sometask'."));
    }
  }
  @Test
  public void failsWhenProvidedNameIsAmbiguous() {
    final Task task1 = task("someTask");
    final Task task2 = task("someTasks");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("soTa", true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet(task2)));
          }
        });

    TaskNameResolvingBuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("soTa"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(
          e.getMessage(),
          equalTo(
              "Task 'soTa' is ambiguous in [project]. Candidates are: 'someTask', 'someTasks'."));
    }
  }
  @Test
  public void testGetModuleDependencies() throws IOException, ParseException {
    prepareResolveReport();
    final ResolvedDependency root = context.mock(ResolvedDependency.class, "root");
    final ResolvedDependency resolvedDependency1 =
        context.mock(ResolvedDependency.class, "resolved1");
    final ResolvedDependency resolvedDependency2 =
        context.mock(ResolvedDependency.class, "resolved2");
    final Set<ResolvedDependency> resolvedDependenciesSet =
        toSet(resolvedDependency1, resolvedDependency2);

    context.checking(
        new Expectations() {
          {
            allowing(conversionResultStub).getRoot();
            will(returnValue(root));
            allowing(root).getChildren();
            will(returnValue(resolvedDependenciesSet));
          }
        });

    ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
    prepareTestsThatRetrieveDependencies(moduleDescriptor);

    Set<ResolvedDependency> actualFirstLevelModuleDependencies =
        ivyDependencyResolver.resolve(configurationStub).getFirstLevelModuleDependencies();
    assertThat(actualFirstLevelModuleDependencies, equalTo(resolvedDependenciesSet));
  }
  @Test
  public void testResolveAndRethrowFailureWithMissingDependenciesShouldThrowResolveException()
      throws IOException, ParseException {
    ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
    prepareTestsThatRetrieveDependencies(moduleDescriptor);
    Exception failure = new Exception("broken");
    prepareResolveReportWithError(failure);
    ResolvedConfiguration configuration = ivyDependencyResolver.resolve(configurationStub);

    assertTrue(configuration.hasError());
    try {
      configuration.rethrowFailure();
      fail();
    } catch (ResolveException e) {
      assertThat(
          e.getMessage(), startsWith("Could not resolve all dependencies for <configuration>"));
      assertThat(e.getCause(), sameInstance((Throwable) failure));
    }
  }
Ejemplo n.º 13
0
 @org.junit.Test
 public void testExecuteWithTestFailuresAndStopAtFailures() {
   configureTask();
   expectTestsFail();
   try {
     test.executeTests();
     fail();
   } catch (GradleException e) {
     assertThat(e.getMessage(), startsWith("There were failing tests. See the report at"));
   }
 }
Ejemplo n.º 14
0
    public void beforeExecute(Task task) {
      assertThat(current, nullValue());
      assertTrue(planned.contains(task));
      current = task;

      String taskPath = path(task);
      if (taskPath.startsWith(":buildSrc:")) {
        return;
      }

      executedTasks.add(taskPath);
    }
Ejemplo n.º 15
0
    public void afterExecute(Task task, TaskState state) {
      assertThat(task, sameInstance(current));
      current = null;

      String taskPath = path(task);
      if (taskPath.startsWith(":buildSrc:")) {
        return;
      }

      if (state.getSkipped()) {
        skippedTasks.add(taskPath);
      }
    }
Ejemplo n.º 16
0
  @Test
  public void visitFileInvokesEachCopyAction() {
    final Action<FileCopyDetails> action1 = context.mock(Action.class, "action1");
    final Action<FileCopyDetails> action2 = context.mock(Action.class, "action2");
    final Collector<FileCopyDetails> collectDetails1 = collector();
    final Collector<Object> collectDetails2 = collector();
    final Collector<Object> collectDetails3 = collector();

    context.checking(
        new Expectations() {
          {
            Sequence seq = context.sequence("seq");
            one(delegate).visitSpec(spec);
            inSequence(seq);

            allowing(spec).getAllCopyActions();
            will(returnValue(toList(action1, action2)));

            one(action1).execute(with(notNullValue(FileCopyDetails.class)));
            inSequence(seq);
            will(collectTo(collectDetails1));

            one(action2).execute(with(notNullValue(FileCopyDetails.class)));
            inSequence(seq);
            will(collectTo(collectDetails2));

            one(delegate).visitFile(with(not(sameInstance(details))));
            inSequence(seq);
            will(collectTo(collectDetails3));
          }
        });

    visitor.visitSpec(spec);
    visitor.visitFile(details);

    assertThat(collectDetails1.get(), sameInstance(collectDetails2.get()));
    assertThat(collectDetails1.get(), sameInstance(collectDetails3.get()));
  }
 @Test
 public void testResolveAndGetFilesWithMissingDependenciesShouldThrowResolveException()
     throws IOException, ParseException {
   ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
   prepareTestsThatRetrieveDependencies(moduleDescriptor);
   Exception failure = new Exception("broken");
   prepareResolveReportWithError(failure);
   ResolvedConfiguration configuration = ivyDependencyResolver.resolve(configurationStub);
   context.checking(
       new Expectations() {
         {
           allowing(configurationStub).getAllDependencies();
         }
       });
   try {
     configuration.getFiles(Specs.SATISFIES_ALL);
     fail();
   } catch (ResolveException e) {
     assertThat(
         e.getMessage(), startsWith("Could not resolve all dependencies for <configuration>"));
     assertThat(e.getCause(), sameInstance((Throwable) failure));
   }
 }
Ejemplo n.º 18
0
  @Test
  public void wrappedFileElementDelegatesToSourceForRemainingMethods() {
    final FileVisitDetails mappedDetails = expectSpecAndFileVisited();
    final File file = new File("file");

    context.checking(
        new Expectations() {
          {
            one(details).getFile();
            will(returnValue(file));
          }
        });

    assertThat(mappedDetails.getFile(), sameInstance(file));
  }
Ejemplo n.º 19
0
  @Test
  public void getSizeReturnsSizeOfFilteredContent() {
    final FileCopyDetails mappedDetails = expectActionExecutedWhenFileVisited();

    context.checking(
        new Expectations() {
          {
            one(details).open();
            will(returnValue(new ByteArrayInputStream("content".getBytes())));
          }
        });

    mappedDetails.filter(HelperUtil.toClosure("{ 'PREFIX: ' + it } "));

    assertThat(mappedDetails.getSize(), equalTo(15L));
  }
Ejemplo n.º 20
0
  @Test
  public void relativePathForDirIsSpecPathPlusFilePath() {
    FileVisitDetails visitDetails = expectSpecAndDirVisited();

    context.checking(
        new Expectations() {
          {
            allowing(spec).getDestPath();
            will(returnValue(new RelativePath(false, "spec")));
            allowing(details).getRelativePath();
            will(returnValue(new RelativePath(false, "dir")));
          }
        });

    assertThat(visitDetails.getRelativePath(), equalTo(new RelativePath(false, "spec", "dir")));
  }
Ejemplo n.º 21
0
  @Test
  public void initialRelativePathForFileIsSpecPathPlusFilePath() {
    FileCopyDetails copyDetails = expectActionExecutedWhenFileVisited();

    context.checking(
        new Expectations() {
          {
            allowing(spec).getDestPath();
            will(returnValue(new RelativePath(false, "spec")));
            allowing(details).getRelativePath();
            will(returnValue(new RelativePath(true, "file")));
          }
        });

    assertThat(copyDetails.getRelativePath(), equalTo(new RelativePath(true, "spec", "file")));
  }
 @Test
 public void testGetResolvedArtifacts() throws IOException, ParseException {
   prepareResolveReport();
   final ResolvedArtifact resolvedArtifactDummy = context.mock(ResolvedArtifact.class);
   final Set<ResolvedArtifact> resolvedArtifacts = toSet(resolvedArtifactDummy);
   context.checking(
       new Expectations() {
         {
           allowing(conversionResultStub).getResolvedArtifacts();
           will(returnValue(resolvedArtifacts));
         }
       });
   ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
   prepareTestsThatRetrieveDependencies(moduleDescriptor);
   assertThat(
       ivyDependencyResolver.resolve(configurationStub).getResolvedArtifacts(),
       equalTo(resolvedArtifacts));
 }
Ejemplo n.º 23
0
  @Test
  public void copyActionCanFilterContentWhenFileIsCopiedToStream() {
    final FileCopyDetails mappedDetails = expectActionExecutedWhenFileVisited();

    context.checking(
        new Expectations() {
          {
            one(details).open();
            will(returnValue(new ByteArrayInputStream("content".getBytes())));
          }
        });

    mappedDetails.filter(HelperUtil.toClosure("{ 'PREFIX: ' + it } "));

    ByteArrayOutputStream outstr = new ByteArrayOutputStream();
    mappedDetails.copyTo(outstr);
    assertThat(new String(outstr.toByteArray()), equalTo("PREFIX: content"));
  }
  @Test
  public void failsWhenUnknownTaskPathIsProvided() {
    context.checking(
        new Expectations() {
          {
            one(project).findProject("a");
            will(returnValue(null));
          }
        });

    BuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("a:b", "name2"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(e.getMessage(), equalTo("Project 'a' not found in [project]."));
    }
  }
  @Test
  public void selectsAllTasksWithTheProvidedNameInCurrentProjectAndSubprojects() {
    final Task task1 = task("name");
    final Task task2 = task("name");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("name", true);
            will(returnValue(toSet(task1, task2)));
            one(taskExecuter).addTasks(toSet(task1, task2));
          }
        });

    TaskNameResolvingBuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("name"));
    executer.select(gradle);
    assertThat(executer.getDisplayName(), equalTo("primary task 'name'"));
  }
  @Test
  public void selectsTaskWithMatchingPath() {
    final Task task1 = task("b");

    context.checking(
        new Expectations() {
          {
            one(project).findProject("a");
            will(returnValue(subProject));
            one(subProjectTaskContainer).findByName("b");
            will(returnValue(task1));
            one(taskExecuter).addTasks(toSet(task1));
          }
        });

    TaskNameResolvingBuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("a:b"));
    executer.select(gradle);
    assertThat(executer.getDisplayName(), equalTo("primary task 'a:b'"));
  }
  @Test
  public void usesCamelCaseAbbreviationToSelectTasksWhenNoExactMatchAndPathProvided() {
    final Task task1 = task("someTask");
    final Task task2 = task("other");

    context.checking(
        new Expectations() {
          {
            one(project).findProject("a:b:c");
            will(returnValue(subProject));
            one(subProjectTaskContainer).findByName("soTa");
            will(returnValue(null));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet(task1, task2)));
            one(taskExecuter).addTasks(toSet(task1));
          }
        });

    TaskNameResolvingBuildExecuter executer =
        new TaskNameResolvingBuildExecuter(toList("a:b:c:soTa"));
    executer.select(gradle);
    assertThat(executer.getDisplayName(), equalTo("primary task 'a:b:c:someTask'"));
  }
Ejemplo n.º 28
0
 public ExecutionFailure assertThatDescription(Matcher<String> matcher) {
   assertThat(failure.getMessage(), containsLine(matcher));
   return this;
 }
  @Test
  public void testResolveAndGetFilesWithDependencySubset() throws IOException, ParseException {
    prepareResolveReport();
    final ModuleDependency moduleDependencyDummy1 = context.mock(ModuleDependency.class, "dep1");
    final ModuleDependency moduleDependencyDummy2 = context.mock(ModuleDependency.class, "dep2");
    final SelfResolvingDependency selfResolvingDependencyDummy =
        context.mock(SelfResolvingDependency.class);
    final ResolvedDependency root = context.mock(ResolvedDependency.class, "root");
    final ResolvedDependency resolvedDependency1 =
        context.mock(ResolvedDependency.class, "resolved1");
    final ResolvedDependency resolvedDependency2 =
        context.mock(ResolvedDependency.class, "resolved2");
    ResolvedDependency resolvedDependency3 = context.mock(ResolvedDependency.class, "resolved3");
    final DependencySet dependencies = context.mock(DependencySet.class);
    final Map<Dependency, Set<ResolvedDependency>> firstLevelResolvedDependencies =
        new LinkedHashMap<Dependency, Set<ResolvedDependency>>();
    firstLevelResolvedDependencies.put(
        moduleDependencyDummy1, toSet(resolvedDependency1, resolvedDependency2));
    firstLevelResolvedDependencies.put(moduleDependencyDummy2, toSet(resolvedDependency3));

    context.checking(
        new Expectations() {
          {
            allowing(resolvedDependency1).getParentArtifacts(root);
            will(
                returnValue(
                    toSet(
                        createResolvedArtifact(
                            context,
                            "dep1parent",
                            "someType",
                            "someExtension",
                            new File("dep1parent")))));
            allowing(resolvedDependency1).getChildren();
            will(returnValue(emptySet()));
            allowing(resolvedDependency2).getParentArtifacts(root);
            will(
                returnValue(
                    toSet(
                        createResolvedArtifact(
                            context,
                            "dep2parent",
                            "someType",
                            "someExtension",
                            new File("dep2parent")))));
            allowing(resolvedDependency2).getChildren();
            will(returnValue(emptySet()));
            allowing(configurationStub).getAllDependencies();
            will(returnValue(dependencies));
            allowing(dependencies).withType(ModuleDependency.class);
            will(
                returnValue(
                    toDomainObjectSet(
                        ModuleDependency.class, moduleDependencyDummy1, moduleDependencyDummy2)));
            allowing(conversionResultStub).getFirstLevelResolvedDependencies();
            will(returnValue(firstLevelResolvedDependencies));
            allowing(conversionResultStub).getRoot();
            will(returnValue(root));
          }
        });

    ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
    prepareTestsThatRetrieveDependencies(moduleDescriptor);

    ResolvedConfiguration resolvedConfig = ivyDependencyResolver.resolve(configurationStub);
    Set<File> actualFiles =
        resolvedConfig.getFiles(
            new Spec<Dependency>() {
              public boolean isSatisfiedBy(Dependency element) {
                return element == moduleDependencyDummy1 || element == selfResolvingDependencyDummy;
              }
            });
    assertThat(actualFiles, equalTo(toSet(new File("dep1parent"), new File("dep2parent"))));

    Set<ResolvedDependency> actualDeps =
        resolvedConfig.getFirstLevelModuleDependencies(
            new Spec<Dependency>() {
              public boolean isSatisfiedBy(Dependency element) {
                return element == moduleDependencyDummy1;
              }
            });
    assertThat(actualDeps, equalTo(toSet(resolvedDependency1, resolvedDependency2)));
  }
Ejemplo n.º 30
0
 public ExecutionFailure assertHasFileName(String filename) {
   assertThat(failure.getMessage(), startsWith(String.format("%s", filename)));
   return this;
 }