package biz.xsoftware.mock;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.List;

 import java.util.logging.Handler;

 import java.util.logging.Level;

 import java.util.logging.LogRecord;

 import java.util.logging.Logger;

 /**

  * Used to aid in the testing of generated log messages. This class extends a

  * logging {@link Handler} in order to capture log messages. These log messages

  * can then be checked against to verify required log messages are indeed

  * logged.

  * 

  * For example:

  * 

  * <pre>

  * public class MyLogObject {

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

  * 

  *     public void runWarningLog(String msg) {

  *         log.warning(msg);

  *     }

  * }

  * 

  * public class TestMyLogObject {

  *     MyLogObject logObj = new MyLogObject();

  * 

  *     MockLogHandler mockLogHandler = new MockLogHandler(MyLogObject.class.getName());

  * 

  *     @Test

  *     public void testLogging() {

  *         // verify the log handler starts out with zero log records

  *         assertEquals(0, mockLogHandler.getLogRecords().size());

  *         // send a log message

  *         logObj.runWarningLog("test one");

  *         // verify the log handler now has one log message

  *         assertEquals(1, mockLogHandler.getLogRecords().size());

  *     }

  * }

  * </pre>

  * 

  * 

  * @author Brian Freeman

  * @since Mar 23, 2007

  */

 public class MockLogHandler extends Handler {

     public static final Level DEFAULT_LOG_LEVEL = Level.FINE;

     private Level oldLevel;

     private Logger logger;

     private final List<LogRecord> recordList = Collections.synchronizedList(new ArrayList<LogRecord>());

     /**

      * Creates an instance of this object. Retrieves the logger for the given

      * class name and adds the instance to the logger's list of

      * <code>Handler</code>s. It will also set the log level if you're trying

      * to verify a specific Level

      * 

      * @param classToMonitor This is the full (package name included) class

      *            name. It can probably be just a package name too

      * 

      * @param logLevel The log level to be monitored

      */

     public MockLogHandler(String classToMonitor, Level logLevel) {

         logger = Logger.getLogger(classToMonitor);

         oldLevel = logger.getLevel();

         logger.setLevel(logLevel);

         logger.addHandler(this);

         setLevel(logLevel);

     }

     /**

      * Helper constructor that just sets the Level to FINE

      * 

      * @param classToMonitor

      */

     public MockLogHandler(String classToMonitor) {

         this(classToMonitor, DEFAULT_LOG_LEVEL);

     }

     /*

      * (non-Javadoc)

      * 

      * @see java.util.logging.Handler#close()

      */

     @Override

     public void close() {

         if (oldLevel != null) {

             logger.setLevel(oldLevel);

             setLevel(oldLevel);

         }

         logger.removeHandler(this);

     }

     /**

      * Clears the list of log records

      * 

      * @see java.util.logging.Handler#flush()

      */

     @Override

     public void flush() {

         recordList.clear();

     }

     /*

      * (non-Javadoc)

      * 

      * @see java.util.logging.Handler#publish(java.util.logging.LogRecord)

      */

     @Override

     public void publish(LogRecord record) {

         recordList.add(record);

     }

     /**

      * Looks at all the messages received so far to see if one equals the given

      * String. Looks for a match not worrying about the log level

      * 

      * @param message The exact String to match against

      * 

      * @return true if a match is found

      */

     public boolean logMessageReceivedThatEquals(String message) {

         for (LogRecord rec : recordList) {

             if (message.equals(rec.getMessage()))

                 return true;

         }

         // no match found

         return false;

     }

     /**

      * Similar to the {@link #logMessageReceivedThatContains(String)}, this

      * method will search for an exact string match. However, this one will also

      * verify that the log level matches the given level

      * 

      * @param message The exact String to match

      * 

      * @param level The log level to compare against

      * 

      * @return True if the given message matches one of the log messages and the

      *         log Level is the same

      */

     public boolean logMessageReceivedThatEquals(String message, Level level) {

         for (LogRecord rec : recordList) {

             if (message.equals(rec.getMessage()) && level.equals(rec.getLevel())) {

                 return true;

             }

         }

         // no match found

         return false;

     }

     /**

      * Looks at all the messages received so far to see if one equals the given

      * String. Looks for a match not worrying about the log level

      * 

      * @param message The exact String to match against

      * 

      * @return true if a match is found

      */

     public boolean logMessageReceivedThatContains(String message) {

         for (LogRecord rec : recordList) {

             if (rec.getMessage().contains(message))

                 return true;

         }

         // no match found

         return false;

     }

     /**

      * Similar to the {@link #logMessageReceivedThatContains(String)}, this

      * method will search for an exact string match. However, this one will also

      * verify that the log level matches the given level

      * 

      * @param message The exact String to match

      * 

      * @param level The log level to compare against

      * 

      * @return True if the given message matches one of the log messages and the

      *         log Level is the same

      */

     public boolean logMessageReceivedThatContains(String message, Level level) {

         for (LogRecord rec : recordList) {

             if (rec.getMessage().contains(message) && level.equals(rec.getLevel())) {

                 return true;

             }

         }

         // no match found

         return false;

     }

     /**

      * Searches the <code>List</code> of <code>LogRecords</code> for an

      * exact match using the <code>LogRecord.getMessage()</code> method. If a

      * match is found it is added to the <code>List</code> that is returned

      * 

      * @param message The message String to match with

      * 

      * @return The list of matching <code>LogRecord</code>s or an empty list

      * 

      */

     public List<LogRecord> getLogRecordsThatEqual(String message) {

         ArrayList<LogRecord> result = new ArrayList<LogRecord>();

         for (LogRecord rec : recordList) {

             if (message.equals(rec.getMessage())) {

                 result.add(rec);

             }

         }

         return result;

     }

     /**

      * Returns a <code>List</code> of <code>LogRecords</code> that have a

      * message that contains the given message. The

      * <code>String.contains()</code> method will be used.

      * 

      * @param message the String to search for in the list of

      *            <code>LogRecords</code>

      */

     public List<LogRecord> getLogRecordsThatContain(String message) {

         ArrayList<LogRecord> result = new ArrayList<LogRecord>();

         for (LogRecord rec : recordList) {

             if (rec.getMessage().contains(message)) {

                 result.add(rec);

             }

         }

         return result;

     }

     /**

      * Returns a <code>List</code> of <code>LogRecords</code> that have a

      * message that contains the given message. The

      * <code>String.contains()</code> method will be used.

      * 

      * @param message the String to search for in the list of

      *            <code>LogRecords</code>

      */

     public List<LogRecord> getLogRecordsThatContain(String message, Level level) {

         ArrayList<LogRecord> result = new ArrayList<LogRecord>();

         for (LogRecord rec : recordList) {

             if (level.equals(rec.getLevel()) && rec.getMessage().contains(message))

                 result.add(rec);

         }

         return result;

     }

     /**

      * Returns all of the saved <code>LogRecords</code>

      */

     public List<LogRecord> getLogRecords() {

         return recordList;

     }

 }