/*

  * Copyright 1999-2001,2004 The Apache Software Foundation.

  * 

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.latka.junit;

 import org.apache.commons.latka.AbstractReporter;

 import org.apache.commons.latka.ValidationException;

 import org.apache.commons.latka.event.ReportMessageEvent;

 import org.apache.commons.latka.event.RequestErrorEvent;

 import org.apache.commons.latka.event.RequestEvent;

 import org.apache.commons.latka.event.RequestFailedEvent;

 import org.apache.commons.latka.event.SuiteEvent;

 import org.apache.log4j.Category;

 import junit.framework.AssertionFailedError;

 import junit.framework.Test;

 import junit.framework.TestResult;

 /**

  * A Latka reporter that takes the various latka events and adapts them into

  * JUnit Tests.

  *

  * In particular this class handles the request error, failed, skipped and

  * succeeded events

  *

  * @author Chuck Burdick

  * @author dIon Gillard

  * @version $Id: JUnitEventReporter.java 155424 2005-02-26 13:09:29Z dirkv $

  */

 public class JUnitEventReporter extends AbstractReporter {

     /** log4j category for log output */

     private static final Category _log = Category.getInstance(

         JUnitEventReporter.class);

     /** the result from running the tests */

     private TestResult _testResult = null;

     /** 

      * Create a JUnitEventReporter, storing the

      * JUnit Test results in the provided object

      * @param result the JUnit TestResult to add failures and errors to

      */   

     protected JUnitEventReporter(TestResult result) {

         _testResult = result;

     }

     /**

      * A {@link Test JUnit Test} that knows how to be a Latka reporter

      */

     private class EventTestAdapter implements Test {

         /** the JUnit assertion error */

         private AssertionFailedError _failed = null;

         /** the error that occurred */

         private Throwable _error = null;

         /** 

          * A JUnit Test class accumulates test results when run

          * based on the constructor that was called

          */      

         public EventTestAdapter() {

         }

         /** 

          * Create an instance with a JUnit

          * {@link junit.framework.AssertionFailedError AssertionFailedError} 

          * that can be added to the results in the

          * {@link #run(junit.framework.TestResult) run} method

          *

          * @param t The AssertionFailedError that will be stored for

          * later addition to results

          */      

         public EventTestAdapter(AssertionFailedError t) {

             _failed = t;

         }

         /**

          * Create an instance with a JUnit {@link java.lang.Throwable Throwable}

          * that can be added to the results in the 

          * {@link #run(junit.framework.TestResult) run} method

          * 

          * @param t The Throwable that will be stored for later addition to

          *      results

          */      

         public EventTestAdapter(Throwable t) {

             _error = t;

         }

         /**

          * The number of test cases this test contains

          * 

          * @return Currently hard coded to one test cases

          */      

         public int countTestCases() {

             return 1;

         }

         /**

          * Run this test.

          * Since Latka has already executed the request we simply check if there

          * has been a failure or error stored and add it to the test results

          *

          * @param result The {@link junit.framework.TestResult TestResult} to 

          * store failures or errors in

          */      

         public void run(TestResult result) {

             result.startTest(this);

             if (_error != null) {

                 result.addError(this, _error);

             } else if (_failed != null) {

                 result.addFailure(this, _failed);

             }

             result.endTest(this);

         }

     }

     /**

      * Process a Latka request error

      * @param event the latka request event that is in error

      */

     public void requestError(RequestEvent event) {

         _log.debug("Received latka RequestErrorEvent");

         Throwable error = ((RequestErrorEvent) event).getError();

         Test test = new EventTestAdapter(error);

         test.run(_testResult);

     }

     /**

      * Process a Latka request failure

      * @param event The event describing the request that has failed

      */   

     public  void requestFailed(RequestEvent event) {

         _log.debug("Received latka RequestFailedEvent");

         RequestFailedEvent fe = (RequestFailedEvent) event;

         ValidationException ve = (ValidationException) 

             fe.getValidationException();

         String requestUrl = event.getRequest().getURL().toString();

         String requestLabel = event.getRequest().getLabel();

         String message = requestUrl + " -- " + requestLabel + ": "

             + ve.getReason();

         AssertionFailedError failure = new AssertionFailedError(message);

         Test test = new EventTestAdapter(failure);

         test.run(_testResult);

     }

     /**

      * Process a Latka event being skipped

      * @param event The event describing the request that has been skipped

      */   

     public void requestSkipped(RequestEvent event) {

         _log.debug("Received latka RequestSkippedEvent");

         AssertionFailedError failure = new AssertionFailedError(

                                         "Skipped due to earlier error");

         Test test = new EventTestAdapter(failure);

         test.run(_testResult);

     }

     /**

      * Process a Latka request success event

      * @param event The event describing the request that has succeeded

      */   

     public void requestSucceeded(RequestEvent event) {

         _log.debug("Received latka RequestSucceededEvent");

         Test test = new EventTestAdapter();

         test.run(_testResult);

     }

     /**

      * This method is currently ignored by the JUnitEventReporter.

      * It may be implemented later.

      * 

      * @param event  reportMessage (ignored)

      */

     public void reportMessage(ReportMessageEvent event) {

     }

     /**

      * Process a Latka suite completion event

      * @param event The event describing the suite that has completed

      */      

     public void suiteCompleted(SuiteEvent event) {

     }

 }