package org.junit.tests.running.classes;

import static org.junit.Assert.fail;

import java.util.List;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.experimental.categories.Categories.CategoryFilter;
import org.junit.experimental.categories.Category;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runner.JUnitCore;
import org.junit.runner.Request;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import org.junit.runners.model.Statement;

/**
 * Tests verifying that class-level fixtures ({@link BeforeClass} and
 * {@link AfterClass}) and rules ({@link ClassRule}) are not executed when there
 * are no test methods to be run in a test class because they have been ignored.
 * 
 */
public class ClassLevelMethodsWithIgnoredTestsTest {
    private static final String FAILURE_MESSAGE = "This should not have happened!";

    public static class BeforeClassWithIgnoredTest {
        @BeforeClass
        public static void beforeClass() {
            fail(FAILURE_MESSAGE);
        }
        
        @Ignore
        @Test
        public void test() throws Exception {
            fail("test() should not run");
        }
    }

    @Test
    public void beforeClassShouldNotRunWhenAllTestsAreIgnored() {
        runClassAndVerifyNoFailures(BeforeClassWithIgnoredTest.class,
                "BeforeClass should not have been executed because the test method is ignored!");
    }

    @Ignore
    public static class BeforeClassWithIgnoredClass {
        @BeforeClass
        public static void beforeClass() {
            fail(FAILURE_MESSAGE);
        }

        @Test
        public void test() throws Exception {
            fail("test() should not run");
        }
    }

    @Test
    public void beforeClassShouldNotRunWhenWholeClassIsIgnored() {
        runClassAndVerifyNoFailures(
                BeforeClassWithIgnoredClass.class,
                "BeforeClass should not have been executed because the whole test class is ignored!");
    }

    public static class AfterClassWithIgnoredTest {
        @Ignore
        @Test
        public void test() throws Exception {
            fail("test() should not run");
        }

        @AfterClass
        public static void afterClass() {
            fail(FAILURE_MESSAGE);
        }
    }

    @Test
    public void afterClassShouldNotRunWhenAllTestsAreIgnored() {
        runClassAndVerifyNoFailures(AfterClassWithIgnoredTest.class,
                "AfterClass should not have been executed because the test method is ignored!");
    }

    public interface FilteredTests {
    }

    public static class BeforeClassWithFilteredTest {
        @BeforeClass
        public static void setUpClass() {
            fail(FAILURE_MESSAGE);
        }

        @Category(FilteredTests.class)
        @Test
        public void test() throws Exception {
            fail("test() should not run");
        }
    }

    public static class HasUnfilteredTest {
        @Test
        public void unfilteredTest() {
            // to prevent errors when all other tests have been filtered
        }
    }

    @Test
    public void beforeClassShouldNotRunWhenAllTestsAreFiltered() {
        Result result = new JUnitCore().run(Request.classes(
                BeforeClassWithFilteredTest.class, HasUnfilteredTest.class)
                .filterWith(CategoryFilter.exclude(FilteredTests.class)));
        analyseResult(
                result,
                "BeforeClass should not have been executed because the test method is filtered!");
    }

    public static class BrokenRule implements TestRule {
        public Statement apply(Statement base, Description description) {
            throw new RuntimeException("this rule is broken");
        }
    }

    public static class ClassRuleWithIgnoredTest {
        @ClassRule
        public static BrokenRule brokenRule = new BrokenRule();

        @Ignore
        @Test
        public void test() throws Exception {
            fail("test() should not be run");
        }
    }

    @Test
    public void classRuleShouldNotBeAppliedWhenAllTestsAreIgnored() {
        runClassAndVerifyNoFailures(ClassRuleWithIgnoredTest.class,
                "The class rule should have been applied because the test method is ignored!");
    }

    private void runClassAndVerifyNoFailures(Class<?> klass,
            String testFailureDescription) {
        Result result = JUnitCore.runClasses(klass);
        analyseResult(result, testFailureDescription);
    }

    private void analyseResult(Result result, String testFailureDescription) {
        List<Failure> failures = result.getFailures();
        if (failures.isEmpty() == false) {
            analyzeFailure(failures.get(0), testFailureDescription);
        }
    }

    private void analyzeFailure(Failure failure, String testFailureDescription) {
        String actualFailureMsg = failure.getMessage();
        if (FAILURE_MESSAGE.equals(actualFailureMsg)) {
            fail(testFailureDescription);
        }
        fail("Unexpected failure : " + actualFailureMsg);
    }
}