geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jinmeil...@apache.org
Subject [19/50] [abbrv] incubator-geode git commit: GEODE-1220: Adding unit tests for LuceneIndexForPartitionRegion
Date Thu, 21 Apr 2016 17:16:54 GMT
GEODE-1220: Adding unit tests for LuceneIndexForPartitionRegion

Refactored LuceneIndexForPartitionRegion, breaking down initialize()
into smaller method calls


Project: http://git-wip-us.apache.org/repos/asf/incubator-geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-geode/commit/8cdeb55e
Tree: http://git-wip-us.apache.org/repos/asf/incubator-geode/tree/8cdeb55e
Diff: http://git-wip-us.apache.org/repos/asf/incubator-geode/diff/8cdeb55e

Branch: refs/heads/feature/GEODE-17-2
Commit: 8cdeb55e4c580b9699fac3ca1f24079ace8c33e1
Parents: 760c6e2
Author: Jason Huynh <huynhja@gmail.com>
Authored: Thu Apr 14 17:00:44 2016 -0700
Committer: Jason Huynh <huynhja@gmail.com>
Committed: Tue Apr 19 11:33:36 2016 -0700

----------------------------------------------------------------------
 .../LuceneIndexForPartitionedRegion.java        | 117 +++++--
 .../LuceneIndexForPartitionedRegionTest.java    | 348 +++++++++++++++++++
 2 files changed, 433 insertions(+), 32 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8cdeb55e/geode-lucene/src/main/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegion.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/main/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegion.java
b/geode-lucene/src/main/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegion.java
index 25b63a4..4145459 100644
--- a/geode-lucene/src/main/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegion.java
+++ b/geode-lucene/src/main/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegion.java
@@ -23,9 +23,11 @@ import com.gemstone.gemfire.cache.Cache;
 import com.gemstone.gemfire.cache.DataPolicy;
 import com.gemstone.gemfire.cache.PartitionAttributes;
 import com.gemstone.gemfire.cache.PartitionAttributesFactory;
+import com.gemstone.gemfire.cache.Region;
 import com.gemstone.gemfire.cache.RegionAttributes;
 import com.gemstone.gemfire.cache.RegionShortcut;
 import com.gemstone.gemfire.cache.asyncqueue.AsyncEventQueue;
+import com.gemstone.gemfire.cache.asyncqueue.AsyncEventQueueFactory;
 import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueFactoryImpl;
 import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueImpl;
 import com.gemstone.gemfire.cache.lucene.internal.filesystem.ChunkKey;
@@ -43,13 +45,13 @@ public class LuceneIndexForPartitionedRegion extends LuceneIndexImpl {
     this.regionPath = regionPath;
     this.cache = cache;
   }
-  
+
   @Override
   public void initialize() {
     if (!hasInitialized) {
       /* create index region */
-      PartitionedRegion dataRegion = (PartitionedRegion)cache.getRegion(regionPath);
-      assert dataRegion != null;
+      PartitionedRegion dataRegion = (PartitionedRegion) cache.getRegion(regionPath);
+      //assert dataRegion != null;
       RegionAttributes ra = dataRegion.getAttributes();
       DataPolicy dp = ra.getDataPolicy();
       final boolean withPersistence = dp.withPersistence();
@@ -73,52 +75,103 @@ public class LuceneIndexForPartitionedRegion extends LuceneIndexImpl
{
       }
 
       // create PR fileRegion, but not to create its buckets for now
-      final String fileRegionName = LuceneServiceImpl.getUniqueIndexName(indexName, regionPath)+".files";
-      fileRegion = cache.<String, File> getRegion(fileRegionName);
+      final String fileRegionName = createFileRegionName();
       PartitionAttributes partitionAttributes = dataRegion.getPartitionAttributes();
-      if (null == fileRegion) {
-        fileRegion = cache.<String, File> createRegionFactory(regionShortCut)
-            .setPartitionAttributes(new PartitionAttributesFactory<String, File>().setColocatedWith(regionPath)
-                .setTotalNumBuckets(partitionAttributes.getTotalNumBuckets())
-                .create())
-                .create(fileRegionName);
+      if (!fileRegionExists(fileRegionName)) {
+        fileRegion = createFileRegion(regionShortCut, fileRegionName, partitionAttributes);
       }
 
       // create PR chunkRegion, but not to create its buckets for now
-      final String chunkRegionName = LuceneServiceImpl.getUniqueIndexName(indexName, regionPath)
+ ".chunks";
-      chunkRegion = cache.<ChunkKey, byte[]> getRegion(chunkRegionName);
-      if (null == chunkRegion) {
-        chunkRegion = cache.<ChunkKey, byte[]> createRegionFactory(regionShortCut)
-            .setPartitionAttributes(new PartitionAttributesFactory<ChunkKey, byte[]>().setColocatedWith(fileRegionName)
-                .setTotalNumBuckets(partitionAttributes.getTotalNumBuckets())
-                .create())
-                .create(chunkRegionName);
+      final String chunkRegionName = createChunkRegionName();
+      if (!chunkRegionExists(chunkRegionName)) {
+        chunkRegion = createChunkRegion(regionShortCut, fileRegionName, partitionAttributes,
chunkRegionName);
       }
 
-      // we will create RegionDirectorys on the fly when data coming
+      // we will create RegionDirectories on the fly when data comes in
       HeterogenousLuceneSerializer mapper = new HeterogenousLuceneSerializer(getFieldNames());
       repositoryManager = new PartitionedRepositoryManager(dataRegion, (PartitionedRegion)fileRegion,
(PartitionedRegion)chunkRegion, mapper, analyzer);
       
-      // create AEQ, AEQ listner and specify the listener to repositoryManager
-      AsyncEventQueueFactoryImpl factory = (AsyncEventQueueFactoryImpl) cache.createAsyncEventQueueFactory();
+      // create AEQ, AEQ listener and specify the listener to repositoryManager
       if (withPersistence) {
-        factory.setPersistent(true);
+        createAEQWithPersistence();
+      }
+      else {
+        createAEQ();
       }
-      factory.setParallel(true); // parallel AEQ for PR
-      factory.setMaximumQueueMemory(1000);
-      factory.setDispatcherThreads(1);
-      factory.setIsMetaQueue(true);
-      
-      LuceneEventListener listener = new LuceneEventListener(repositoryManager);
-      String aeqId = LuceneServiceImpl.getUniqueIndexName(getName(), regionPath);
-      AsyncEventQueueImpl aeq = (AsyncEventQueueImpl)cache.getAsyncEventQueue(aeqId);
-      AsyncEventQueue indexQueue = factory.create(aeqId, listener);
 
       addExtension(dataRegion);
       hasInitialized = true;
     }
   }
 
+  private AsyncEventQueueFactoryImpl createAEQFactory() {
+    AsyncEventQueueFactoryImpl factory = (AsyncEventQueueFactoryImpl) cache.createAsyncEventQueueFactory();
+    factory.setParallel(true); // parallel AEQ for PR
+    factory.setMaximumQueueMemory(1000);
+    factory.setDispatcherThreads(1);
+    factory.setIsMetaQueue(true);
+    return factory;
+  }
+
+  AsyncEventQueue createAEQWithPersistence() {
+    AsyncEventQueueFactoryImpl factory = createAEQFactory();
+    factory.setPersistent(true);
+    return createAEQ(factory);
+  }
+
+  AsyncEventQueue createAEQ() {
+    return createAEQ(createAEQFactory());
+  }
+
+  private AsyncEventQueue createAEQ(AsyncEventQueueFactoryImpl factory) {
+    LuceneEventListener listener = new LuceneEventListener(repositoryManager);
+    String aeqId = LuceneServiceImpl.getUniqueIndexName(getName(), regionPath);
+    AsyncEventQueueImpl aeq = (AsyncEventQueueImpl)cache.getAsyncEventQueue(aeqId);
+    AsyncEventQueue indexQueue = factory.create(aeqId, listener);
+    return indexQueue;
+  }
+
+
+  boolean fileRegionExists(String fileRegionName) {
+    return cache.<String, File> getRegion(fileRegionName) != null;
+  }
+
+  Region createFileRegion(final RegionShortcut regionShortCut,
+                                final String fileRegionName,
+                                final PartitionAttributes partitionAttributes)
+  {
+    return cache.<String, File> createRegionFactory(regionShortCut)
+        .setPartitionAttributes(new PartitionAttributesFactory<String, File>().setColocatedWith(regionPath)
+            .setTotalNumBuckets(partitionAttributes.getTotalNumBuckets())
+            .create())
+            .create(fileRegionName);
+  }
+
+  String createFileRegionName() {
+    return LuceneServiceImpl.getUniqueIndexName(indexName, regionPath)+".files";
+  }
+
+  boolean chunkRegionExists(String chunkRegionName) {
+    return cache.<ChunkKey, byte[]> getRegion(chunkRegionName) != null;
+  }
+
+  Region<ChunkKey, byte[]> createChunkRegion(final RegionShortcut regionShortCut,
+                           final String fileRegionName,
+                           final PartitionAttributes partitionAttributes, final String chunkRegionName)
+  {
+    return cache.<ChunkKey, byte[]> createRegionFactory(regionShortCut)
+      .setPartitionAttributes(new PartitionAttributesFactory<ChunkKey, byte[]>().setColocatedWith(fileRegionName)
+        .setTotalNumBuckets(partitionAttributes.getTotalNumBuckets())
+        .create())
+      .create(chunkRegionName);
+  }
+
+  String createChunkRegionName() {
+    return LuceneServiceImpl.getUniqueIndexName(indexName, regionPath) + ".chunks";
+  }
+
+
+
   public void close() {
     // TODO Auto-generated method stub
     

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8cdeb55e/geode-lucene/src/test/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegionTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegionTest.java
b/geode-lucene/src/test/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegionTest.java
new file mode 100644
index 0000000..74d4e34
--- /dev/null
+++ b/geode-lucene/src/test/java/com/gemstone/gemfire/cache/lucene/internal/LuceneIndexForPartitionedRegionTest.java
@@ -0,0 +1,348 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 com.gemstone.gemfire.cache.lucene.internal;
+
+import static org.mockito.Mockito.*;
+
+import com.gemstone.gemfire.cache.Cache;
+import com.gemstone.gemfire.cache.DataPolicy;
+import com.gemstone.gemfire.cache.PartitionAttributes;
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.cache.RegionAttributes;
+import com.gemstone.gemfire.cache.RegionFactory;
+import com.gemstone.gemfire.cache.RegionShortcut;
+import com.gemstone.gemfire.cache.asyncqueue.AsyncEventQueueFactory;
+import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueFactoryImpl;
+import com.gemstone.gemfire.internal.cache.PartitionedRegion;
+import com.gemstone.gemfire.internal.cache.extension.ExtensionPoint;
+import com.gemstone.gemfire.test.fake.Fakes;
+import com.gemstone.gemfire.test.junit.categories.UnitTest;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
+
+@Category(UnitTest.class)
+public class LuceneIndexForPartitionedRegionTest {
+
+  @Rule
+  public ExpectedException expectedExceptions = ExpectedException.none();
+
+  @Test
+  public void getIndexNameReturnsCorrectName() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = null;
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    Assert.assertEquals(name, index.getName());
+  }
+
+  @Test
+  public void getRegionPathReturnsPath() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = null;
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    Assert.assertEquals(regionPath, index.getRegionPath());
+  }
+
+  @Test
+  public void fileRegionExistsWhenFileRegionExistsShouldReturnTrue() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    PartitionedRegion region = mock(PartitionedRegion.class);
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    String fileRegionName = index.createFileRegionName();
+    when(cache.getRegion(fileRegionName)).thenReturn(region);
+
+    Assert.assertTrue(index.fileRegionExists(fileRegionName));
+  }
+
+  @Test
+  public void fileRegionExistsWhenFileRegionDoesNotExistShouldReturnFalse() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    String fileRegionName = index.createFileRegionName();
+    when(cache.getRegion(fileRegionName)).thenReturn(null);
+
+    Assert.assertFalse(index.fileRegionExists(fileRegionName));
+  }
+
+  @Test
+  public void chunkRegionExistsWhenChunkRegionExistsShouldReturnTrue() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    PartitionedRegion region = mock(PartitionedRegion.class);
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    String chunkRegionName = index.createChunkRegionName();
+    when(cache.getRegion(chunkRegionName)).thenReturn(region);
+
+    Assert.assertTrue(index.chunkRegionExists(chunkRegionName));
+  }
+
+  @Test
+  public void chunkRegionExistsWhenChunkRegionDoesNotExistShouldReturnFalse() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    String chunkRegionName = index.createChunkRegionName();
+    when(cache.getRegion(chunkRegionName)).thenReturn(null);
+
+    Assert.assertFalse(index.chunkRegionExists(chunkRegionName));
+  }
+
+  @Test
+  public void createChunkRegionWithPartitionShortcutCreatesRegionThroughFactory() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    RegionFactory regionFactory = mock(RegionFactory.class);
+    PartitionAttributes partitionAttributes = mock(PartitionAttributes.class);
+    when(cache.createRegionFactory(RegionShortcut.PARTITION)).thenReturn(regionFactory);
+    when(regionFactory.setPartitionAttributes(any())).thenReturn(regionFactory);
+    when(partitionAttributes.getTotalNumBuckets()).thenReturn(113);
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+
+    index.createChunkRegion(RegionShortcut.PARTITION, index.createFileRegionName(), partitionAttributes,
index.createChunkRegionName());
+    verify(regionFactory).create(index.createChunkRegionName());
+  }
+
+  @Test
+  public void createFileRegionWithPartitionShortcutCreatesRegionThroughFactory() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    RegionFactory regionFactory = mock(RegionFactory.class);
+    PartitionAttributes partitionAttributes = mock(PartitionAttributes.class);
+    when(cache.createRegionFactory(RegionShortcut.PARTITION)).thenReturn(regionFactory);
+    when(regionFactory.setPartitionAttributes(any())).thenReturn(regionFactory);
+    when(partitionAttributes.getTotalNumBuckets()).thenReturn(113);
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+
+    index.createFileRegion(RegionShortcut.PARTITION, index.createFileRegionName(), partitionAttributes);
+    verify(regionFactory).create(index.createFileRegionName());
+  }
+
+  @Test
+  public void createAEQWithPersistenceCallsCreateOnAEQFactory() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    AsyncEventQueueFactoryImpl aeqFactory = mock(AsyncEventQueueFactoryImpl.class);
+    when(cache.createAsyncEventQueueFactory()).thenReturn(aeqFactory);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.createAEQWithPersistence();
+
+    verify(aeqFactory).create(any(), any());
+  }
+
+  @Test
+  public void createAEQCallsCreateOnAEQFactory() {
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    AsyncEventQueueFactoryImpl aeqFactory = mock(AsyncEventQueueFactoryImpl.class);
+    when(cache.createAsyncEventQueueFactory()).thenReturn(aeqFactory);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.createAEQ();
+
+    verify(aeqFactory).create(any(), any());
+  }
+
+  private void initializeScenario(final boolean withPersistence, final String regionPath,
final Cache cache) {
+    int defaultLocalMemory = 100;
+    initializeScenario(withPersistence, regionPath, cache, defaultLocalMemory);
+  }
+
+  private void initializeScenario(final boolean withPersistence, final String regionPath,
final Cache cache, int localMaxMemory) {
+    PartitionedRegion region = mock(PartitionedRegion.class);
+    RegionAttributes regionAttributes = mock(RegionAttributes.class);
+    PartitionAttributes partitionAttributes = mock(PartitionAttributes.class);
+    RegionFactory regionFactory = mock(RegionFactory.class);
+    DataPolicy dataPolicy = mock(DataPolicy.class);
+    ExtensionPoint extensionPoint = mock(ExtensionPoint.class);
+    when(cache.getRegion(regionPath)).thenReturn(region);
+    when(cache.createRegionFactory(isA(RegionShortcut.class))).thenReturn(regionFactory);
+    when(region.getAttributes()).thenReturn(regionAttributes);
+    when(regionAttributes.getPartitionAttributes()).thenReturn(partitionAttributes);
+    when(regionAttributes.getDataPolicy()).thenReturn(dataPolicy);
+    when(partitionAttributes.getLocalMaxMemory()).thenReturn(localMaxMemory);
+    when(partitionAttributes.getTotalNumBuckets()).thenReturn(113);
+    when(dataPolicy.withPersistence()).thenReturn(withPersistence);
+    when(region.getExtensionPoint()).thenReturn(extensionPoint);
+  }
+
+  @Test
+  public void initializeWithNoLocalMemoryThrowsException() {
+    expectedExceptions.expect(IllegalStateException.class);
+    expectedExceptions.expectMessage("The data region to create lucene index should be with
storage");
+    boolean withPersistence = false;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache, 0);
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.initialize();
+  }
+
+  @Test
+  public void initializeWithPersistenceShouldCreateAEQWithPersistence() {
+    boolean withPersistence = true;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQWithPersistence();
+    spy.initialize();
+
+    verify(spy).createAEQWithPersistence();
+  }
+
+  @Test
+  public void initializeWithoutPersistenceShouldCreateAEQ() {
+    boolean withPersistence = false;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQ();
+    spy.initialize();
+
+    verify(spy).createAEQ();
+  }
+
+  @Test
+  public void initializeShouldCreatePartitionChunkRegion() {
+    boolean withPersistence = false;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQ();
+    spy.initialize();
+
+    verify(spy).createChunkRegion(eq(RegionShortcut.PARTITION), eq(index.createFileRegionName()),
any(), eq(index.createChunkRegionName()));
+  }
+
+  @Test
+  public void initializeShouldCreatePartitionFileRegion() {
+    boolean withPersistence = false;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQ();
+    spy.initialize();
+
+    verify(spy).createFileRegion(eq(RegionShortcut.PARTITION), eq(index.createFileRegionName()),
any());
+  }
+
+  @Test
+  public void initializeShouldCreatePartitionPersistentChunkRegion() {
+    boolean withPersistence = true;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQWithPersistence();
+    spy.initialize();
+
+    verify(spy).createChunkRegion(eq(RegionShortcut.PARTITION_PERSISTENT), eq(index.createFileRegionName()),
any(), eq(index.createChunkRegionName()));
+  }
+
+  @Test
+  public void initializeShouldCreatePartitionPersistentFileRegion() {
+    boolean withPersistence = true;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQWithPersistence();
+    spy.initialize();
+
+    verify(spy).createFileRegion(eq(RegionShortcut.PARTITION_PERSISTENT), eq(index.createFileRegionName()),
any());
+  }
+
+  @Test
+  public void initializeWhenCalledMultipleTimesShouldNotCreateMultipleFileRegions() {
+    boolean withPersistence = true;
+    String name = "indexName";
+    String regionPath = "regionName";
+    Cache cache = Fakes.cache();
+    initializeScenario(withPersistence, regionPath, cache);
+
+    LuceneIndexForPartitionedRegion index = new LuceneIndexForPartitionedRegion(name, regionPath,
cache);
+    index.setSearchableFields(new String[]{"field"});
+    LuceneIndexForPartitionedRegion spy = spy(index);
+    doReturn(null).when(spy).createFileRegion(any(), any(), any());
+    doReturn(null).when(spy).createChunkRegion(any(), any(), any(), any());
+    doReturn(null).when(spy).createAEQWithPersistence();
+    spy.initialize();
+    spy.initialize();
+
+    verify(spy).createFileRegion(eq(RegionShortcut.PARTITION_PERSISTENT), eq(index.createFileRegionName()),
any());
+  }
+
+}


Mime
View raw message