TestPitest.java

/**
 *
 */
package org.pitest.testapi.execute;

import static org.mockito.Matchers.any;
import static org.mockito.Mockito.verify;

import java.io.FileNotFoundException;
import java.util.Arrays;

import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.pitest.simpletest.ConfigurationForTesting;
import org.pitest.simpletest.TestAnnotationForTesting;
import org.pitest.testapi.Description;
import org.pitest.testapi.TestListener;
import org.pitest.testapi.TestResult;
import org.pitest.testapi.execute.containers.UnContainer;

/**
 * @author henry
 *
 */

public class TestPitest {

  private Pitest       testee;
  private Container    container;

  @Mock
  private TestListener listener;
  @Mock
  private TestListener listener2;

  @Before
  public void setUp() {
    MockitoAnnotations.initMocks(this);
    this.container = new UnContainer();
    this.testee = new Pitest(Arrays.asList(this.listener, this.listener2));
  }

  public static class PassingTest {
    @TestAnnotationForTesting
    public void shouldPass() {

    }
  };

  @Test
  public void shouldNotifyAllListenersOfRunStart() {
    run(PassingTest.class);
    verify(this.listener).onRunStart();
    verify(this.listener2).onRunStart();
  }

  @Test
  public void shouldNotifyAllListenersOfTestStart() {
    run(PassingTest.class);
    verify(this.listener).onTestStart(any(Description.class));
    verify(this.listener2).onTestStart(any(Description.class));
  }

  @Test
  public void shouldNotifyAllListenersOfTestSuccess() {
    run(PassingTest.class);
    verify(this.listener).onTestSuccess(any(TestResult.class));
    verify(this.listener2).onTestSuccess(any(TestResult.class));
  }

  @Test
  public void shouldNotifyAllListenersOfRunEnd() {
    ;
  run(PassingTest.class);
  verify(this.listener).onRunEnd();
  verify(this.listener2).onRunEnd();
  }

  @Test
  public void shouldReportsSuccessIfNoExceptionThrown() {
    run(PassingTest.class);
    verify(this.listener).onTestSuccess(any(TestResult.class));
  }

  public static class FailsAssertion {
    @TestAnnotationForTesting
    public void willFail() {
      throw new AssertionError();
    }
  };

  @Test
  public void shouldReportedAsFailureIfAssertionThrown() {
    run(FailsAssertion.class);
    verify(this.listener).onTestFailure(any(TestResult.class));
  }

  public static class ExpectedExceptionThrown {
    @TestAnnotationForTesting(expected = NullPointerException.class)
    public void expectToThrowNullPointer() {
      throw new NullPointerException();
    }

  };

  @Test
  public void shouldReportSuccessIfExpectedExceptionThrown() {
    run(ExpectedExceptionThrown.class);
    verify(this.listener).onTestSuccess(any(TestResult.class));

  }

  public static class ExpectedExceptionNotThrown {
    @TestAnnotationForTesting(expected = NullPointerException.class)
    public void expectToThrowNullPointer() {

    }
  };

  @Test
  public void shouldReportFailureIfExpectedExceptionNotThrown() {
    run(ExpectedExceptionNotThrown.class);
    verify(this.listener).onTestFailure(any(TestResult.class));
  }

  public static class UnexpectedExceptionThrown {
    @TestAnnotationForTesting
    public void willFailWithError() throws Exception {
      throw new FileNotFoundException();
    }
  };

  @Test
  public void shouldReportFailureWhenExceptionThrownAndNoExpectationSet() {
    run(UnexpectedExceptionThrown.class);
    verify(this.listener).onTestFailure(any(TestResult.class));
  }

  public static class WrongExceptionThrown {
    @TestAnnotationForTesting(expected = NullPointerException.class)
    public void willFailWithError() throws Exception {
      throw new FileNotFoundException();
    }
  };

  @Test
  public void shouldReportFailureWhenThrownExceptionDifferentFromExpectedException() {
    run(WrongExceptionThrown.class);
    verify(this.listener).onTestFailure(any(TestResult.class));
  }

  public static class SubclassOfExpectedExceptionThrown {
    @TestAnnotationForTesting(expected = Exception.class)
    public void shouldPass() throws Exception {
      throw new FileNotFoundException();
    }
  };

  @Test
  public void shouldReportSuccessWhenSubclassOfExpectedExceptionThrown() {
    run(SubclassOfExpectedExceptionThrown.class);
    verify(this.listener).onTestSuccess(any(TestResult.class));
  }

  public static class StaticTestCase {
    @TestAnnotationForTesting
    public static void staticTestMethod() {
    }
  };

  @Test
  public void shouldBeAbleToCallStaticTestMethods() {
    run(StaticTestCase.class);
    verify(this.listener).onTestSuccess(any(TestResult.class));
  }

  private void run(final Class<?> clazz) {
    this.testee.run(this.container, new ConfigurationForTesting(), clazz);
  }
}