package org.marketchangers.prayer.lucene;
   
   import java.io.IOException;
   import java.lang.reflect.Modifier;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Hashtable;
   
   import junit.framework.TestCase;
  
  import org.apache.lucene.analysis.standard.StandardAnalyzer;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.index.TermDocs;
  import org.apache.lucene.index.TermEnum;
  import org.apache.lucene.index.TermFreqVector;
  import org.apache.lucene.index.TermPositions;
  import org.apache.lucene.search.BooleanQuery;
  import org.apache.lucene.search.Query;
  import org.apache.lucene.search.Searchable;
  import org.apache.lucene.store.RAMDirectory;
  import org.marketchangers.prayer.PrayerRequest;
  import org.marketchangers.prayer.PrayerRequestQuery;
  import org.marketchangers.prayer.PrayerRequestSearcher;
  
  import com.mockobjects.ExpectationCounter;
  import com.mockobjects.ExpectationList;
  import com.mockobjects.dynamic.Mock;
  import com.mockobjects.util.Verifier;
  
  /***
   * @author <a href="mailto:mtodd@wc-group.com">Matthew Todd</a>
   */
  public class LucenePrayerRequestSearcherTest extends TestCase {
  	private PrayerRequestSearcher prayerRequestSearcher;
  
  	private Mock provider;
  	private MockIndexReader reader;
  	private Mock searcher;
  	private MockIndexWriter writer;
  
  	// --------------------------------------------- SetUp and TearDown Methods
  	protected void setUp() throws IOException {
  		provider = new Mock(IndexProvider.class);
  		reader = new MockIndexReader();
  		searcher = new Mock(Searchable.class);
  		writer = new MockIndexWriter();
  
  		prayerRequestSearcher =
  			new LucenePrayerRequestSearcher((IndexProvider) provider.proxy());
  	}
  
  	protected void tearDown() {
  		provider.verify();
  		reader.verify();
  		searcher.verify();
  		writer.verify();
  	}
  
  	// ----------------------------------------------------------- Test Methods
  	public void testWritesDocumentsIntoTheDirectoryOnIndex() {
  		PrayerRequest request = new PrayerRequest();
  		Document document = new Document();
  
  		provider.expectAndReturn("getWriter", writer);
  		provider.expectAndReturn("translateToDocument", request, document);
  		writer.expectAddDocument(document);
  		writer.expectClose();
  
  		prayerRequestSearcher.index(request);
  	}
  
  	public void testIndexMethodIsSynchronized() throws NoSuchMethodException {
  		assertTrue(
  			Modifier.isSynchronized(
  				prayerRequestSearcher
  					.getClass()
  					.getMethod("index", new Class[] { PrayerRequest.class })
  					.getModifiers()));
  	}
  
  	public void testSearchSomehow() {
  		// TODO Figure out how to test the Lucene code with Mocks.
  		// Too many of their classes are final, and they don't use interfaces.
  	}
  
  	public void testSearchReturnsAnEmptyListIfThereAreNoRequestors() {
  		PrayerRequestQuery emptyQuery = new PrayerRequestQuery(new Hashtable());
  		assertEquals(0, prayerRequestSearcher.search(emptyQuery).size());
  	}
  
  	public void testDelete() throws IOException {
  		provider.expectAndReturn("getReader", reader);
  		reader.expectDeleteDocument(0);
  		reader.expectClose();
  		prayerRequestSearcher.delete(0);
  	}
 
 	public void doNotTestUpdateStatus() {
 		PrayerRequest request = new PrayerRequest();
 		Query query = new BooleanQuery();
 		provider.expectAndReturn("translateToQuery", request, query);
 		provider.expectAndReturn("getReader", reader);
 		provider.expectAndReturn("getSearcher", searcher);
 
 		reader.expectDeleteDocument(0);
 		reader.expectClose();
 
 		prayerRequestSearcher.updateStatus(request);
 	}
 
 	// ------------------------------------------------- Private Helper Classes
 	private static class MockIndexReader extends IndexReader {
 		private ExpectationCounter close;
 		private ExpectationList documents;
 		public MockIndexReader() throws IOException {
 			super(new RAMDirectory());
 			this.close = new ExpectationCounter("Close");
 			this.documents = new ExpectationList("Documents");
 		}
 		public void doDelete(int i) {
 		}
 		public TermPositions termPositions() {
 			return null;
 		}
 		public void doSetNorm(int doc, String field, byte value) {
 		}
 
 		public Collection getIndexedFieldNames(boolean b) {
 			return null;
 		}
 		public void doCommit() {
 		}
 		public int maxDoc() {
 			return 1;
 		}
 		public void doUndeleteAll() {
 		}
 		public void doClose() {
 		}
 		public boolean isDeleted(int i) {
 			return false;
 		}
 		public Document document(int i) {
 			return new Document();
 		}
 		public void setNorm(int doc, String field, float value) {
 		}
 		public Collection getFieldNames() {
 			return new ArrayList();
 		}
 		public Collection getFieldNames(boolean bool) {
 			return new ArrayList();
 		}
 		public TermDocs termDocs() {
 			return null;
 		}
 		public TermEnum terms() {
 			return null;
 		}
 		public TermEnum terms(Term term) {
 			return null;
 		}
 		public TermFreqVector getTermFreqVector(int docNumber, String field) {
 			return null;
 		}
 		public TermFreqVector[] getTermFreqVectors(int docNumber) {
 			return null;
 		}
 		public int numDocs() {
 			return 10;
 		}
 		public void norms(String field, byte[] bytes, int offset)
 			throws IOException {
 
 		}
 		public byte[] norms(String field) {
 			return new byte[1];
 		}
 		public boolean hasDeletions() {
 			return false;
 		}
 
 		public void verify() {
 			Verifier.verifyObject(this);
 		}
 		public boolean isDeleted() {
 			return false;
 		}
 		public void doDelete() {
 
 		}
 
 		public int docFreq(Term t) {
 			return 0;
 		}
 
 		public void expectDeleteDocument(int i) {
 			//documents.addExpected(new Integer(i));
 			documents.setExpectNothing();
 		}
 		public void expectClose() {
 
 			close.setExpected(0);
 		}
 
 	}
 
 	private static class MockIndexWriter extends IndexWriter {
 		private ExpectationCounter close;
 		private ExpectationList documents;
 
 		public MockIndexWriter() throws IOException {
 			super(new RAMDirectory(), new StandardAnalyzer(), true);
 
 			this.close = new ExpectationCounter("Close");
 			this.documents = new ExpectationList("Documents");
 		}
 
 		public void addDocument(Document d) {
 			documents.addActual(d);
 		}
 
 		public void close() {
 			close.inc();
 		}
 
 		public void expectAddDocument(Document d) {
 			documents.addExpected(d);
 		}
 
 		public void expectClose() {
 			close.setExpected(1);
 		}
 
 		public void verify() {
 			Verifier.verifyObject(this);
 		}
 
 	}
 }