DependencyFilterTest.java

package org.pitest.coverage.execute;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.pitest.dependency.DependencyExtractor;
import org.pitest.functional.predicate.Predicate;
import org.pitest.testapi.Description;
import org.pitest.testapi.ResultCollector;
import org.pitest.testapi.TestUnit;

public class DependencyFilterTest {

  private DependencyFilter    testee;

  @Mock
  private DependencyExtractor extractor;

  private TestUnit            aTestUnit;

  private TestUnit            anotherTestUnit;

  private List<TestUnit>      tus;

  @Before
  public void setUp() {
    MockitoAnnotations.initMocks(this);

    this.aTestUnit = makeTestUnit(new Description("foo", String.class));
    this.anotherTestUnit = makeTestUnit(new Description("bar", Integer.class));

    this.testee = new DependencyFilter(this.extractor, null);
    this.tus = Arrays.asList(this.aTestUnit, this.anotherTestUnit);
  }

  @SuppressWarnings("unchecked")
  @Test
  public void shouldNotPerformAnalysisWhenDependencyDistanceIsLessThan0()
      throws IOException {
    when(this.extractor.getMaxDistance()).thenReturn(-1);
    final List<TestUnit> actual = this.testee
        .filterTestsByDependencyAnalysis(this.tus);
    assertSame(this.tus, actual);
    verify(this.extractor, never()).extractCallDependenciesForPackages(
        anyString(), any(Predicate.class));
  }

  @SuppressWarnings("unchecked")
  @Test
  public void shouldReturnOnlyTestUnitsForClassesWithinReach()
      throws IOException {
    when(
        this.extractor.extractCallDependenciesForPackages(eq(this.aTestUnit
            .getDescription().getFirstTestClass()), any(Predicate.class)))
            .thenReturn(Arrays.asList("foo"));
    when(
        this.extractor.extractCallDependenciesForPackages(
            eq(this.anotherTestUnit.getDescription().getFirstTestClass()),
            any(Predicate.class))).thenReturn(Collections.<String> emptyList());

    assertEquals(Arrays.asList(this.aTestUnit),
        this.testee.filterTestsByDependencyAnalysis(this.tus));

  }

  @SuppressWarnings("unchecked")
  @Test
  public void shouldNotRecalculateDependenciesForAlreadyAnalysedClasses()
      throws IOException {

    when(
        this.extractor.extractCallDependenciesForPackages(eq(this.aTestUnit
            .getDescription().getFirstTestClass()), any(Predicate.class)))
            .thenReturn(Arrays.asList("foo"));

    this.tus = Arrays.asList(this.aTestUnit, this.aTestUnit);

    this.testee.filterTestsByDependencyAnalysis(this.tus);
    verify(this.extractor, times(1)).extractCallDependenciesForPackages(
        eq(this.aTestUnit.getDescription().getFirstTestClass()),
        any(Predicate.class));
  }

  private TestUnit makeTestUnit(final Description d) {
    return new TestUnit() {

      @Override
      public void execute(final ClassLoader loader, final ResultCollector rc) {

      }

      @Override
      public Description getDescription() {
        return d;
      }

    };
  }
}