FilterFactoriesTest.java

package org.junit.runner;

import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assume.assumeThat;
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.ExcludeCategories;
import org.junit.rules.ExpectedException;
import org.junit.rules.TestName;
import org.junit.runner.manipulation.Filter;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

public class FilterFactoriesTest {
    @Rule
    public ExpectedException expectedException = ExpectedException.none();

    @Rule
    public TestName testName = new TestName();

    private Request createSuiteRequest() {
        return Request.aClass(DummySuite.class);
    }

    @Test
    public void shouldCreateFilterWithArguments() throws Exception {
        Filter filter = FilterFactories.createFilterFromFilterSpec(
                createSuiteRequest(),
                ExcludeCategories.class.getName() + "=" + DummyCategory.class.getName());

        assertThat(filter.describe(), startsWith("excludes "));
    }

    @Test
    public void shouldCreateFilterWithNoArguments() throws Exception {
        Filter filter = FilterFactories.createFilterFromFilterSpec(
                createSuiteRequest(), FilterFactoryStub.class.getName());

        assertThat(filter, instanceOf(DummyFilter.class));
    }

    @Test
    public void shouldPassOnDescriptionToFilterFactory() throws Exception {
        Request request = createSuiteRequest();
        Description description = request.getRunner().getDescription();
        Filter filter = FilterFactories.createFilterFromFilterSpec(
                request, FilterFactoryStub.class.getName());

        // This assumption tested in shouldCreateFilterWithNoArguments()
        assumeThat(filter, instanceOf(DummyFilter.class));

        DummyFilter dummyFilter = (DummyFilter) filter;
        assertThat(dummyFilter.getTopLevelDescription(), is(description));
    }

    @Test
    public void shouldCreateFilter() throws Exception {
        Filter filter = FilterFactories.createFilter(
                FilterFactoryStub.class,
                new FilterFactoryParams(
                        Description.createSuiteDescription(testName.getMethodName()),
                        ""));

        assertThat(filter, instanceOf(DummyFilter.class));
    }

    @Test
    public void shouldThrowExceptionIfNotFilterFactory() throws Exception {
        expectedException.expect(FilterFactory.FilterNotCreatedException.class);

        FilterFactories.createFilterFactory(NonFilterFactory.class.getName());
    }

    @Test
    public void shouldThrowExceptionIfNotInstantiable() throws Exception {
        expectedException.expect(FilterFactory.FilterNotCreatedException.class);

        FilterFactories.createFilterFactory(NonInstantiableFilterFactory.class);
    }

    public static class NonFilterFactory {
    }

    public static class NonInstantiableFilterFactory implements FilterFactory {
        private NonInstantiableFilterFactory() {
        }

        public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
            throw new FilterNotCreatedException(new Exception("not implemented"));
        }
    }

    public static class FilterFactoryStub implements FilterFactory {
        public Filter createFilter(FilterFactoryParams params) {
            return new DummyFilter(params.getTopLevelDescription());
        }
    }

    private static class DummyFilter extends Filter {
        private final Description fTopLevelDescription;

        public DummyFilter(Description topLevelDescription) {
            fTopLevelDescription = topLevelDescription;
        }

        public Description getTopLevelDescription() {
            return fTopLevelDescription;
        }

        @Override
        public boolean shouldRun(Description description) {
            return false;
        }

        @Override
        public String describe() {
            return null;
        }
    }

    public static class DummyCategory {
    }

    @RunWith(Suite.class)
    @SuiteClasses(DummyTest.class)
    public static class DummySuite {
    }

    public static class DummyTest {
        @Test
        public void passes() {
        }
    }
}