/* ====================================================================
    * License: 
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by 
   *        Robert Half International (http://www.rhi.com/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Parc", "RHI", and "Robert Half International" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact pete.mckinstry@rhi.com.
   *
   * 5. Products derived from this software may not be called "PARC",
   *    nor may "PARC" appear in their name, without prior written
   *    permission of Robert Half International.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   */
  package com.rhi.architecture.parc.adapter;
  
  import com.rhi.architecture.batch.AuditAgent;
  import com.rhi.architecture.batch.TestAuditAgent;
  import com.rhi.architecture.config.ConfigFacility;
  import com.rhi.architecture.parc.ArrayListQueue;
  import com.rhi.architecture.parc.Channel;
  import com.rhi.architecture.parc.ExceptionHandler;
  import com.rhi.architecture.parc.PARCTest;
  import com.rhi.architecture.parc.TestError;
  import com.rhi.architecture.parc.TestRecord;
  import com.rhi.architecture.resource.ResourceContext;
  import com.rhi.architecture.xa.Transaction;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import java.util.Properties;
  
  import junit.framework.Test;
  import junit.framework.TestSuite;
  
  /***
   * OutputAdapterTest.java
   * 
   * @author <a href="mailto:pete.mckinstry@rhi.com">Pete McKinstry</a>
   * @copyright 2002, Robert Half International, All rights reserved.
   * 
   * @version 1.0
   */
  public class OutputAdapterTest extends PARCTest {
  
  	private TestOutputAdapter oa;
  	private Channel valid;
  	private Channel error;
  	private ExceptionHandler handler;
  	private AuditAgent auditAgent;
  
  	/***
  	 * Constructor for OutputAdapterTest.
  	 * @param name
  	 */
  	public OutputAdapterTest(String name) {
  		super(name);
  	}
  
  	/***
  	 * Allow subclasses to add extra params. Default impl provided.
  	 * @param p
  	 * @return
  	 */
  	public Properties doGetProperties(Properties p) {
  		p.setProperty(
 			Transaction.TYPE_KEY,
 			"com.rhi.architecture.xa.TestTransaction");
 		p.setProperty("AbstractOutputAdapter.MaxSleep", "100");
 		super.setLoadDriver(false);
 
 		return p;
 	}
 
 	/***
      * setup
      * @throws Exception
 	 */
 	protected void setUp() throws Exception {
 		super.setUp();
 		oa = new TestOutputAdapter();
 		valid = new ArrayListQueue();
 		error = new ArrayListQueue();
 		handler = new ExceptionHandler();
 		auditAgent = new TestAuditAgent();
 
 		ResourceContext ctx = new ResourceContext();
 		ConfigFacility config = (ConfigFacility) ctx.lookup(ConfigFacility.KEY);
 		Properties p = config.getProperties();
 
 		oa.init(p);
 		oa.setValidChannel(valid);
 		oa.setErrorChannel(error);
 		oa.setExceptionHandler(handler);
 		oa.setAuditAgent(auditAgent);
 	}
 
 	/***
      * tear down
 	 * @throws Exception
 	 */
 	protected void tearDown() throws Exception {
 		super.tearDown();
 		oa.cleanup();
 	}
 
 	/***
      * Test the error handling
      * 
      * Set the valid channel to null, thus causing the output 
      * adapter to fail w/ a fatal runtime exception. The run()
      * method should detect this error & instead of crashing, 
      * signal the error handler.
      * 
      * @throws Exception
      * @since 1,1
      */
     public void testExceptionThrown() throws Exception {
 		this.oa.setValidChannel(null);
 
 		// just immediately after processing records.
 		this.oa.markComplete();
 
 		Thread oaThread = new Thread(this.oa);
 
 		oaThread.start();
 
 		while (oaThread.isAlive()) {
 			try {
 				Thread.sleep(100);
 			}
 			catch (InterruptedException e) {
 				// ignore 
 			}
 		}
 
 		assertTrue(
 			"exception not caught by OutputAdapter.",
 			handler.hasError() == true);
 	}
 
 	/***
 	 * Simple test
      * Push record into inbound channel before starting OA, 
      * then check that record comes out the other end.
      * 
 	 * @throws Exception
      * @since 1,1
 	 */
 	public void testOneRecord() throws Exception {
 		List records = new ArrayList();
 
 		records.add(new TestRecord());
 		this.valid.push(records);
 
 		// just immediately after processing records.
 		this.oa.markComplete();
 
 		Thread oaThread = new Thread(this.oa);
 
 		oaThread.start();
 
 		while (oaThread.isAlive()) {
 			try {
 				Thread.sleep(100);
 			}
 			catch (InterruptedException e) {
 				// ignore 
 			}
 		}
 
 		assertTrue(
 			"exception thrown by OutputAdapter.",
 			handler.hasError() == false);
 		records = oa.getValidRecords();
 		assertTrue("valid record size wrong.", records.size() == 1);
 		records = oa.getErrorRecords();
 		assertTrue("error record size wrong.", records.size() == 0);
 	}
 
     /***
      * Test of non-thread version to ensure backward compatibility.
      * 
      * @throws Exception
      * @since 1,1
      */
     public void testNonThreadOutputAdapter() throws Exception {
         List records = new ArrayList();
 
         records.add(new TestRecord());
         this.valid.push(records);
 
         // just immediately after processing records.
         this.oa.markComplete();
 
         this.oa.run();
         
         assertTrue(
             "exception thrown by OutputAdapter.",
             handler.hasError() == false);
         records = oa.getValidRecords();
         assertTrue("valid record size wrong.", records.size() == 1);
         records = oa.getErrorRecords();
         assertTrue("error record size wrong.", records.size() == 0);
     }
 
     /***
      * Start the output adapter first, then push some records into
      * the channel multiple times to simulate a multi-batch interface
      * After both batches are pushed, mark the OA complete & ensure
      * that it shuts down properly (w/ all the records accounted for.
      * 
      * @throws Exception
      * @since 1,1
      */
 	public void testNormalScenario() throws Exception {
 		Thread oaThread = new Thread(this.oa);
 
 		oaThread.start();
 
 		// wait for a bit.
 		try {
 			Thread.sleep(1000);
 		}
 		catch (InterruptedException e) {
 			// ignore
 		}
 
 		// now, push some records into the channel.
 		List records1 = new ArrayList();
 
 		records1.add(new TestRecord());
 		records1.add(new TestRecord());
 		records1.add(new TestRecord());
 		this.valid.push(records1);
 
 		// and push some more.
 		List records2 = new ArrayList();
 
 		records2.add(new TestRecord());
 		records2.add(new TestRecord());
 		this.valid.push(records2);
 
 		// after it's done w/ these 5, exit.
 		this.oa.markComplete();
 
 		while (oaThread.isAlive()) {
 			try {
 				Thread.sleep(100);
 			}
 			catch (InterruptedException e) {
 				// ignore 
 			}
 		}
 
 		assertTrue(
 			"exception not caught by OutputAdapter.",
 			handler.hasError() == false);
 
 		Collection records = oa.getValidRecords();
 
 		assertTrue("valid record size wrong.", records.size() == 5);
 		records = oa.getErrorRecords();
 		assertTrue("error record size wrong.", records.size() == 0);
 	}
 
     /***
      * Test of wait/notify logic.
      * 
      * Start the output adapter first, then push some records into
      * the channel multiple times to simulate a multi-batch interface
      * After both batches are pushed, mark the OA complete & ensure
      * that it shuts down properly (w/ all the records accounted for.
      * 
      * @throws Exception
      * @since 1,1
      */
     public void testOutputAdapterNotifyWaitCycle() throws Exception {
         Thread oaThread = new Thread(this.oa);
 
         oaThread.start();
 
         // wait for a bit, forcing the OA to sleep (no records yet)
         try {
             Thread.sleep(250);
         }
         catch (InterruptedException e) {
             // ignore
         }
 
         // Batch 1
         List records1 = new ArrayList();
 
         records1.add(new TestRecord());
         records1.add(new TestRecord());
         records1.add(new TestRecord());
         this.valid.push(records1);
 
         // wait for a bit, forcing the OA to sleep. 1 cycle, then empty cycle.
         try {
             Thread.sleep(1000);
         }
         catch (InterruptedException e) {
             // ignore
         }
 
         // Batch 2
         List records2 = new ArrayList();
 
         records2.add(new TestRecord());
         records2.add(new TestRecord());
         this.valid.push(records2);
 
         // after it's done w/ these 5, exit.
         this.oa.markComplete();
 
         while (oaThread.isAlive()) {
             try {
                 Thread.sleep(100);
             }
             catch (InterruptedException e) {
                 // ignore 
             }
         }
 
         int writeCount = ((TestOutputAdapter)this.oa).getWriteCount();
         System.out.println("write called " + writeCount + " times");
         assertTrue( "incorrect number of batches. wait/notify logic broken. " + 
                     "write() called " + writeCount,
                     writeCount<15);
                 
         int handleValidCount = ((TestOutputAdapter)this.oa).getHandleValidCount();
         System.out.println("handleValid called " + handleValidCount + " times");
         assertTrue( "wait/notify logic broken. " + 
                     "handleValid called " + handleValidCount + " times",
                     handleValidCount==2);
                 
         
         assertTrue( "exception not caught by OutputAdapter.",
             handler.hasError() == false);
 
         Collection records = oa.getValidRecords();
 
         assertTrue("valid record size wrong.", records.size() == 5);
         records = oa.getErrorRecords();
         assertTrue("error record size wrong.", records.size() == 0);
     }
     
     /***
 	 * Add errored records to error channel & make sure they 
      * are propertly accounted for. 
      * 
 	 * @throws Exception
      * @since 1,1
 	 */
 	public void testErrorChannel() throws Exception {
 		List records = new ArrayList();
 		TestRecord r = new TestRecord();
 
 		r.addError(new TestError());
 		records.add(r);
 		records.add(r);
 		this.error.push(records);
 
 		// just immediately after processing records.
 		this.oa.markComplete();
 
 		Thread oaThread = new Thread(this.oa);
 
 		oaThread.start();
 
 		while (oaThread.isAlive()) {
 			try {
 				Thread.sleep(100);
 			}
 			catch (InterruptedException e) {
 				// ignore 
 			}
 		}
 
 		assertTrue(
 			"exception thrown by OutputAdapter.",
 			handler.hasError() == false);
 		records = oa.getValidRecords();
 		assertTrue("valid record size wrong.", records.size() == 0);
 		records = oa.getErrorRecords();
 		assertTrue("error record size wrong.", records.size() == 2);
 	}
 
 	/***
      * Add errored records to valid channel & make sure they 
      * are propertly accounted for. 
      * 
      * @throws Exception
      * @since 1,1
 	 */
 	public void testErrorsInValidChannel() throws Exception {
 		List records = new ArrayList();
 		TestRecord r = new TestRecord();
 
 		r.addError(new TestError());
 		records.add(r);
 		records.add(r);
 		this.valid.push(records);
 
 		// just immediately after processing records.
 		this.oa.markComplete();
 
 		Thread oaThread = new Thread(this.oa);
 
 		oaThread.start();
 
 		while (oaThread.isAlive()) {
 			try {
 				Thread.sleep(100);
 			}
 			catch (InterruptedException e) {
 				// ignore 
 			}
 		}
 
 		assertTrue(
 			"exception thrown by OutputAdapter.",
 			handler.hasError() == false);
 		records = oa.getValidRecords();
 		assertTrue("valid record size wrong.", records.size() == 0);
 		records = oa.getErrorRecords();
 		assertTrue("error record size wrong.", records.size() == 2);
 	}
 
     /***
      * suite of all tests
      * @return Test
      */
 	public static Test suite() {
 		return new TestSuite(OutputAdapterTest.class);
 	}
     
 }