teststoragequery.java

lucene2.2.0版本

/** 
 * Copyright 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.lucene.gdata.storage.lucenestorage;

import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;

import org.apache.lucene.gdata.data.GDataAccount;
import org.apache.lucene.gdata.data.ServerBaseEntry;
import org.apache.lucene.gdata.data.ServerBaseFeed;
import org.apache.lucene.gdata.server.registry.ProvidedService;
import org.apache.lucene.gdata.storage.StorageException;
import org.apache.lucene.gdata.storage.lucenestorage.StorageEntryWrapper.StorageOperation;
import org.apache.lucene.gdata.utils.ProvidedServiceStub;
import org.apache.lucene.gdata.utils.ReferenceCounter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;

import com.google.gdata.data.BaseEntry;
import com.google.gdata.data.BaseFeed;
import com.google.gdata.data.DateTime;
import com.google.gdata.data.Entry;
import com.google.gdata.util.ParseException;

public class TestStorageQuery extends TestCase {
    private StorageModifier modifier;
    private int count = 30;
    private ReferenceCounter<StorageQuery> query;
    private ProvidedService configurator;
    private StorageCoreController controller;
    private  Directory dir;
    private static String feedId = "myFeed";
    private static String accountName = "simon";
    private static String service = ProvidedServiceStub.SERVICE_NAME;
    protected void setUp() throws Exception {
        this.configurator = new ProvidedServiceStub();
        this.controller = new StorageCoreController();
        this.dir = new RAMDirectory();
        this.controller.setStorageDir(this.dir);
        this.controller.setKeepRecoveredFiles(false);
        this.controller.setOptimizeInterval(10);
        this.controller.setRecover(false);
        this.controller.setBufferSize(10);
        this.controller.setPersistFactor(10);
        this.controller.initialize();
        this.configurator = new ProvidedServiceStub();
        this.modifier = this.controller.getStorageModifier();
        this.dir = this.controller.getDirectory();        
        ServerBaseFeed feed = new ServerBaseFeed();
        feed.setId(feedId);
        feed.setServiceType(service);
        feed.setServiceConfig(this.configurator);
        
        StorageFeedWrapper wrapper = new StorageFeedWrapper(feed,accountName);
        this.modifier.createFeed(wrapper);
        insertEntries(this.count);
        this.query = this.controller.getStorageQuery();
        
    }
    
    /**
     * @param entrycount
     * @throws IOException
     * @throws InterruptedException
     * @throws StorageException
     */
    public void insertEntries(int entrycount) throws IOException,InterruptedException, StorageException{
        List<StorageEntryWrapper> tempList = new ArrayList<StorageEntryWrapper>();
        for (int i = 0; i <= entrycount ; i++) {
            ServerBaseEntry entry = new ServerBaseEntry(new Entry());
            entry.setId(""+i);
            entry.setServiceConfig(this.configurator);
            entry.setUpdated(new DateTime(System.currentTimeMillis(),0));
            entry.setFeedId(feedId);
            StorageEntryWrapper wrapper = new StorageEntryWrapper(entry,StorageOperation.INSERT);
            tempList.add(i,wrapper);
           
            // force different timestamps --> DateTime 2006-06-05T13:37:55.724Z
            Thread.sleep(10);
          
        }
        for (StorageEntryWrapper entry : tempList) {
            this.modifier.insertEntry(entry);
        }
        
        
        
        
    }

    protected void tearDown() throws Exception {
        this.query.decrementRef();
        this.controller.destroy();
    }
    
    /*
     *  
     */
    public void testAccountNameQuery() throws IOException, StorageException{
        ReferenceCounter<StorageQuery> query = this.controller.getStorageQuery();
        assertEquals(accountName,query.get().getAccountNameForFeedId(feedId));
        assertNull(query.get().getAccountNameForFeedId("someId"));
    }

    /*
     * Test method for 'org.apache.lucene.storage.lucenestorage.StorageQuery.feedQuery(String, int, int)'
     */
    public void testFeedQuery() throws IOException,  ParseException, StorageException {
        feedQueryHelper(this.query);
        this.controller.forceWrite();
        ReferenceCounter<StorageQuery> queryAssureWritten = this.controller.getStorageQuery();
       
        assertNotSame(queryAssureWritten,this.query);
        feedQueryHelper(queryAssureWritten);
        queryAssureWritten.decrementRef();
    }
    private void feedQueryHelper(ReferenceCounter<StorageQuery> currentQuery) throws IOException,  ParseException{
       BaseFeed feed = currentQuery.get().getLatestFeedQuery(feedId,25,1,this.configurator);
       List<BaseEntry> entryList = feed.getEntries(); 
        assertTrue("listSize: "+entryList.size(),entryList.size() == 25);
        
        BaseEntry tempEntry = null;
        for (BaseEntry entry : entryList) {
          
            assertNotNull("entry",entry);
            if(tempEntry != null){
                assertTrue(tempEntry.getUpdated().compareTo(entry.getUpdated())>=0) ;
                tempEntry = entry;
            }else
                tempEntry = entry;
            
        }
        // test sub retrieve sublist
        int offset = 15;
        int resultCount = 5; 
        feed = currentQuery.get().getLatestFeedQuery(feedId,resultCount,offset,this.configurator);
        List<BaseEntry> entrySubList = feed.getEntries();
        
        assertTrue("listSize: "+entrySubList.size(),entrySubList.size() == resultCount);
        offset--;
        for (BaseEntry entry : entrySubList) {
            
            assertEquals(entry.getId(),entryList.get(offset).getId());
            offset++;
            
        }
        
        
        
    }

    /*
     * Test method for 'org.apache.lucene.storage.lucenestorage.StorageQuery.singleEntryQuery(String, String)'
     */
    public void testSingleEntryQuery() throws  ParseException, IOException {
        for (int i = 1; i <= this.count; i++) {
            BaseEntry entry = this.query.get().singleEntryQuery(""+i,feedId,this.configurator);
            assertEquals(""+i,entry.getId());
        }
        
    }

    /*
     * Test method for 'org.apache.lucene.storage.lucenestorage.StorageQuery.entryQuery(List<String>, String)'
     */
    public void testEntryQuery() throws  ParseException, IOException, StorageException {
        entryQueryHelper(this.query);
        this.controller.forceWrite();
        ReferenceCounter<StorageQuery> queryAssureWritten = this.controller.getStorageQuery();
       
        assertNotSame(queryAssureWritten,query);
        entryQueryHelper(queryAssureWritten);
        queryAssureWritten.decrementRef();
    }
    public void testGetUser() throws StorageException, IOException{
        this.modifier.forceWrite();
        GDataAccount user = new GDataAccount();
        user.setName("simon");
        user.setPassword("pass");
        user.setAuthorname("simon willnauer");
        user.setAuthorMail("[e-mail]");
        user.setAuthorLink(new URL("http://www.apache.org"));
        
       
     
        this.modifier.createAccount(new StorageAccountWrapper(user));
        GDataAccount queriedUser = this.query.get().getUser("simon");
        assertNull(queriedUser);
        ReferenceCounter<StorageQuery> tempQuery = this.controller.getStorageQuery();
        queriedUser = tempQuery.get().getUser("simon");
        assertTrue(queriedUser.equals(user));
        assertTrue(queriedUser.getAuthorMail().equals(user.getAuthorMail()));
        assertTrue(queriedUser.getAuthorLink().equals(user.getAuthorLink()));
        assertTrue(queriedUser.getAuthorname().equals(user.getAuthorname()));
        assertTrue(queriedUser.getPassword().equals(user.getPassword()));
    }
    
    public void testIsEntryStored() throws IOException{
        
      assertTrue(this.query.get().isEntryStored(""+(this.count-1),feedId));
      assertFalse(this.query.get().isEntryStored("someOther",feedId));
      this.modifier.forceWrite();
      assertTrue(this.query.get().isEntryStored(""+(this.count-1),feedId));
      this.query = this.controller.getStorageQuery();
      assertTrue(this.query.get().isEntryStored(""+(this.count-1),feedId));
      assertFalse(this.query.get().isEntryStored("someOther",feedId));
    }
    
    public void testGetEntryLastModied() throws IOException, StorageException{
        ServerBaseEntry entry = new ServerBaseEntry(new Entry());
        entry.setId("test");
        entry.setServiceConfig(this.configurator);
        entry.setUpdated(new DateTime(System.currentTimeMillis(),0));
        entry.setFeedId(feedId);
        StorageEntryWrapper wrapper = new StorageEntryWrapper(entry,StorageOperation.INSERT);
        
        this.modifier.insertEntry(wrapper);
        assertEquals(entry.getUpdated().getValue(),this.query.get().getEntryLastModified("test",feedId));
        this.modifier.forceWrite();
        assertEquals(entry.getUpdated().getValue(),this.query.get().getEntryLastModified("test",feedId));
        this.query = this.controller.getStorageQuery();
        assertEquals(entry.getUpdated().getValue(),this.query.get().getEntryLastModified("test",feedId));
        try{
        this.query.get().getEntryLastModified("some",feedId);
        fail("exception expected");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public void testGetFeedLastModified() throws StorageException, IOException{
        ServerBaseEntry entry = new ServerBaseEntry(new Entry());
        entry.setId("test");
        entry.setServiceConfig(this.configurator);
        entry.setUpdated(new DateTime(System.currentTimeMillis(),0));
        entry.setFeedId(feedId);
        StorageEntryWrapper wrapper = new StorageEntryWrapper(entry,StorageOperation.INSERT);
        this.modifier.insertEntry(wrapper);
        assertEquals(entry.getUpdated().getValue(),this.query.get().getFeedLastModified(feedId));
        this.modifier.forceWrite();
        assertEquals(entry.getUpdated().getValue(),this.query.get().getFeedLastModified(feedId));
        this.query = this.controller.getStorageQuery();
        assertEquals(entry.getUpdated().getValue(),this.query.get().getFeedLastModified(feedId));
    }
    
    public void testCheckVersionId() throws IOException, StorageException{
        this.modifier.forceWrite();
        ReferenceCounter<StorageQuery> sQuery = this.controller.getStorageQuery();
        ServerBaseEntry entry = new ServerBaseEntry(new Entry());
        entry.setId("test");
        entry.setServiceConfig(this.configurator);
        entry.setUpdated(new DateTime(System.currentTimeMillis(),0));
        entry.setFeedId(feedId);
        entry.setVersion(5);
        StorageEntryWrapper wrapper = new StorageEntryWrapper(entry,StorageOperation.INSERT);
        this.modifier.insertEntry(wrapper);
        //test in buffer
        assertTrue(sQuery.get().checkEntryVersion(entry.getId(),entry.getFeedId(),entry.getVersion()));
        assertFalse(sQuery.get().checkEntryVersion(entry.getId(),entry.getFeedId(),10000));
        assertFalse(sQuery.get().checkEntryVersion(entry.getId(),"someOtherFeed",entry.getVersion()));
        assertFalse(sQuery.get().checkEntryVersion("foobar",entry.getFeedId(),entry.getVersion()));
        
        
        this.modifier.forceWrite();
        //test in buffer after written
        assertTrue(sQuery.get().checkEntryVersion(entry.getId(),entry.getFeedId(),entry.getVersion()));
        assertFalse(sQuery.get().checkEntryVersion(entry.getId(),entry.getFeedId(),10000));
        assertFalse(sQuery.get().checkEntryVersion(entry.getId(),"someOtherFeed",entry.getVersion()));
        assertFalse(sQuery.get().checkEntryVersion("foobar",entry.getFeedId(),entry.getVersion()));
        sQuery.decrementRef();
        sQuery = this.controller.getStorageQuery();
        //test in index
        assertTrue(sQuery.get().checkEntryVersion(entry.getId(),entry.getFeedId(),entry.getVersion()));
        assertFalse(sQuery.get().checkEntryVersion(entry.getId(),entry.getFeedId(),10000));
        assertFalse(sQuery.get().checkEntryVersion("foobar",entry.getFeedId(),entry.getVersion()));
        sQuery.decrementRef();
        
        
        
        
    }
    private void entryQueryHelper(ReferenceCounter<StorageQuery> currentQuery) throws IOException,  ParseException{
        
        List<String> entryIdList = new ArrayList<String>();
        for (int i = 1; i <= this.count; i++) {
           entryIdList.add(""+i);
        }
        List<BaseEntry> entryList = currentQuery.get().entryQuery(entryIdList,feedId,this.configurator);
        assertEquals(entryIdList.size(),entryList.size());
        List<String> entryIdCompare = new ArrayList<String>();
        for (BaseEntry entry : entryList) {
            assertEquals("1",entry.getVersionId());
            entryIdCompare.add(entry.getId());
            
        }
        assertTrue(entryIdList.containsAll(entryIdCompare));
        
    }
    
    

}