package biz.xsoftware.mock.testcase;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import java.util.logging.SimpleFormatter;

 import junit.framework.TestCase;

 import biz.xsoftware.mock.MockObject;

 import biz.xsoftware.mock.MockObjectFactory;

 /**

  * This is a special test case that does two things

  * <ol>

  * <li>Verifies logs with either of the following</li>

  * <ol>

  * <li>Verifies there are no warning logs</li>

  * <li>Verifies warning logs exist as they should exist</li>

  * </ol>

  * <li>For mocks created using MockTestCase.createMock, this test case will

  * verify in teardown that no more methods were called on the mock</li>

  * </ol>

  */

 public abstract class MockTestCase extends TestCase {

     private static final Logger log = Logger.getLogger(MockTestCase.class.getName());

     private String testName;

     private List<MockObject> mocks;

     private HandlerForTests currentHandler;

     private int numberOfExpectedWarnings = 0;

     public MockTestCase() {

         super();

     }

     public MockTestCase(String name) {

         super(name);

         testName = name;

     }

     @Override

     protected final void setUp() throws Exception {

         super.setUp();

         currentHandler = new HandlerForTests();

         Logger.getLogger("").addHandler(currentHandler);

         mocks = new ArrayList<MockObject>();

         numberOfExpectedWarnings = 0;

         setUpImpl();

     }

     @Override

     protected final void tearDown() throws Exception {

         super.tearDown();

         tearDownImpl();

         List<LogAndStack> failures = currentHandler.getFailures();

         if (numberOfExpectedWarnings == 0 && failures.size() != 0) {

             SimpleFormatter form = new SimpleFormatter();

             LogAndStack logAndStack = failures.get(0);

             String logRec = form.format(logAndStack.getRecord());

             Throwable howItWasCalled = logAndStack.getHowItWasCalled();

             log.log(Level.INFO, howItWasCalled.getMessage());

             throw new LogHasWarningException("Log contains " + failures.size() + " warnings, or errors.  "

                     + "If these are expected, call super.setNumberOfExpectedWarnings(" + failures.size() + ") "

                     + "anywhere in the test case.  first failure record=\n" + logRec

                     + "\nHere is how Logger.log method was called on the first log....\n",

                     logAndStack.getRecord().getMessage());

         } else if (numberOfExpectedWarnings != failures.size()) {

             throw new LogHasNoWarningsException("The number of warnings was=" + failures.size() + " but"

                     + "you expected " + numberOfExpectedWarnings + " warnings or errors");

         }

         for (MockObject mock : mocks) {

             mock.expect(MockObject.NONE);

         }

         // make sure the currentHandler gets removed and doesn't stay in memory

         // forever while tests run

         Logger.getLogger("").removeHandler(currentHandler);

     }

     /**

      * A method the subclass of MockTestCase needs to implement

      * 

      * @throws Exception

      */

     protected abstract void tearDownImpl() throws Exception;

     /**

      * A method the subclass of MockTestCase needs to implement

      * 

      * @throws Exception

      */

     protected abstract void setUpImpl() throws Exception;

     /**

      * @see junit.framework.TestCase#runBare()

      */

     @Override

     public void runBare() throws Throwable {

         // String method = getClass().getName()+"."+testName;

         String method = testName;

         log.info("TEST STARTING=" + method);

         try {

             super.runBare();

         } catch (Throwable e) {

             log.warning("TEST FAILED=" + method);

             throw e;

         }

         log.info("TEST PASSED=" + method);

     }

     /**

      * If this test will result in warnings recorded in the log, the test needs

      * to call this method so it won't fail. MockTestCase in tearDown checks the

      * number of warnings in the log and if they don't match, it will fail the

      * test.

      * 

      * @param num

      */

     protected void setNumberOfExpectedWarnings(int num) {

         this.numberOfExpectedWarnings = num;

     }

     /**

      * @deprecated Use {@link #setNumberOfExpectedWarnings(int)} instead

      * @param b

      */

     @Deprecated

     protected void setExpectWarning(boolean b) {

         if (b) {

             numberOfExpectedWarnings = 1;

         } else {

             numberOfExpectedWarnings = 0;

         }

     }

     protected List<LogAndStack> getWarningsLogged() {

         return currentHandler.getFailures();

     }

     /**

      * All mockobjects created through this will be checked at teardown to make

      * sure there are no methods called that your test forgot to check.

      * 

      * @param interfaze

      * @return

      */

     protected MockObject createMock(Class<?> interfaze) {

         if (mocks == null)

             throw new IllegalStateException(

                     "You must call createMock in the setUpImpl method or in the test not before");

         MockObject object = MockObjectFactory.createMock(interfaze);

         mocks.add(object);

         return object;

     }

 }