You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by kl...@apache.org on 2021/04/09 18:26:05 UTC
[geode] branch feature/GEODE-7665 updated: GEODE-9132: Minor
cleanup of PartitionedRegionClearTest
This is an automated email from the ASF dual-hosted git repository.
klund pushed a commit to branch feature/GEODE-7665
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/feature/GEODE-7665 by this push:
new a43d103 GEODE-9132: Minor cleanup of PartitionedRegionClearTest
a43d103 is described below
commit a43d103b8a9973cdf03166a2fdbc16de29a120fd
Author: Kirk Lund <kl...@apache.org>
AuthorDate: Fri Apr 9 11:16:12 2021 -0700
GEODE-9132: Minor cleanup of PartitionedRegionClearTest
---
.../internal/cache/PartitionedRegionClearTest.java | 720 +++++++++++++--------
1 file changed, 467 insertions(+), 253 deletions(-)
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/PartitionedRegionClearTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/PartitionedRegionClearTest.java
index 4d8a14e..3b66e67 100644
--- a/geode-core/src/test/java/org/apache/geode/internal/cache/PartitionedRegionClearTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/PartitionedRegionClearTest.java
@@ -14,19 +14,24 @@
*/
package org.apache.geode.internal.cache;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singleton;
+import static org.apache.geode.internal.cache.FilterProfile.NO_PROFILES;
+import static org.apache.geode.util.internal.UncheckedUtils.uncheckedCast;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.mockito.ArgumentCaptor.forClass;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
@@ -43,514 +48,667 @@ import org.apache.geode.distributed.internal.DistributionManager;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.distributed.internal.MembershipListener;
import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.PartitionedRegion.RetryTimeKeeper;
+import org.apache.geode.internal.cache.PartitionedRegionClear.PartitionedRegionClearListener;
+import org.apache.geode.internal.cache.PartitionedRegionClearMessage.OperationType;
import org.apache.geode.internal.cache.partitioned.RegionAdvisor;
import org.apache.geode.internal.serialization.KnownVersion;
public class PartitionedRegionClearTest {
-
- private PartitionedRegionClear partitionedRegionClear;
private DistributionManager distributionManager;
private PartitionedRegion partitionedRegion;
private RegionAdvisor regionAdvisor;
private InternalDistributedMember internalDistributedMember;
+ private PartitionedRegionClear partitionedRegionClear;
+
@Before
public void setUp() {
-
- partitionedRegion = mock(PartitionedRegion.class);
distributionManager = mock(DistributionManager.class);
+ internalDistributedMember = mock(InternalDistributedMember.class);
+ partitionedRegion = mock(PartitionedRegion.class);
+ regionAdvisor = mock(RegionAdvisor.class);
+ when(distributionManager.getDistributionManagerId()).thenReturn(internalDistributedMember);
+ when(distributionManager.getId()).thenReturn(internalDistributedMember);
+ when(internalDistributedMember.getVersion()).thenReturn(KnownVersion.CURRENT);
when(partitionedRegion.getDistributionManager()).thenReturn(distributionManager);
when(partitionedRegion.getName()).thenReturn("prRegion");
-
- partitionedRegionClear = new PartitionedRegionClear(partitionedRegion);
- internalDistributedMember = mock(InternalDistributedMember.class);
- when(internalDistributedMember.getVersion()).thenReturn(KnownVersion.CURRENT);
- regionAdvisor = mock(RegionAdvisor.class);
when(partitionedRegion.getRegionAdvisor()).thenReturn(regionAdvisor);
when(regionAdvisor.getDistributionManager()).thenReturn(distributionManager);
- when(distributionManager.getDistributionManagerId()).thenReturn(internalDistributedMember);
- when(distributionManager.getId()).thenReturn(internalDistributedMember);
-
- }
-
- private Set<BucketRegion> setupBucketRegions(
- PartitionedRegionDataStore partitionedRegionDataStore,
- BucketAdvisor bucketAdvisor) {
- final int numBuckets = 2;
- Set<BucketRegion> bucketRegions = new HashSet<>();
- for (int i = 0; i < numBuckets; i++) {
- BucketRegion bucketRegion = mock(BucketRegion.class);
- when(bucketRegion.getBucketAdvisor()).thenReturn(bucketAdvisor);
- when(bucketRegion.size()).thenReturn(1).thenReturn(0);
- when(bucketRegion.getId()).thenReturn(i);
- bucketRegions.add(bucketRegion);
- }
-
- when(partitionedRegionDataStore.getAllLocalBucketRegions()).thenReturn(bucketRegions);
- when(partitionedRegionDataStore.getAllLocalPrimaryBucketRegions()).thenReturn(bucketRegions);
- return bucketRegions;
+ partitionedRegionClear = new PartitionedRegionClear(partitionedRegion);
}
@Test
public void isLockedForListenerAndClientNotificationReturnsTrueWhenLocked() {
+ // arrange
when(distributionManager.isCurrentMember(internalDistributedMember)).thenReturn(true);
partitionedRegionClear.obtainClearLockLocal(internalDistributedMember);
- assertThat(partitionedRegionClear.isLockedForListenerAndClientNotification()).isTrue();
+ // act
+ boolean result = partitionedRegionClear.isLockedForListenerAndClientNotification();
+
+ // assert
+ assertThat(result).isTrue();
}
@Test
public void isLockedForListenerAndClientNotificationReturnsFalseWhenMemberNotInTheSystemRequestsLock() {
+ // arrange
when(distributionManager.isCurrentMember(internalDistributedMember)).thenReturn(false);
- assertThat(partitionedRegionClear.isLockedForListenerAndClientNotification()).isFalse();
+ // act
+ boolean result = partitionedRegionClear.isLockedForListenerAndClientNotification();
+
+ // assert
+ assertThat(result).isFalse();
}
@Test
public void acquireDistributedClearLockGetsDistributedLock() {
+ // arrange
DistributedLockService distributedLockService = mock(DistributedLockService.class);
String lockName = PartitionedRegionClear.CLEAR_OPERATION + partitionedRegion.getName();
when(partitionedRegion.getPartitionedRegionLockService()).thenReturn(distributedLockService);
+ // act
partitionedRegionClear.acquireDistributedClearLock(lockName);
- verify(distributedLockService, times(1)).lock(lockName, -1, -1);
+ // assert
+ verify(distributedLockService).lock(lockName, -1, -1);
}
@Test
public void releaseDistributedClearLockReleasesDistributedLock() {
+ // arrange
DistributedLockService distributedLockService = mock(DistributedLockService.class);
String lockName = PartitionedRegionClear.CLEAR_OPERATION + partitionedRegion.getName();
when(partitionedRegion.getPartitionedRegionLockService()).thenReturn(distributedLockService);
+ // act
partitionedRegionClear.releaseDistributedClearLock(lockName);
- verify(distributedLockService, times(1)).unlock(lockName);
+ // assert
+ verify(distributedLockService).unlock(lockName);
}
@Test
public void obtainLockForClearGetsLocalLockAndSendsMessageForRemote() throws Exception {
+ // arrange
+ Region<String, PartitionRegionConfig> region = uncheckedCast(mock(Region.class));
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(regionEvent.clone()).thenReturn(mock(RegionEventImpl.class));
- Region<String, PartitionRegionConfig> region = mock(Region.class);
- when(partitionedRegion.getPRRoot()).thenReturn(region);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear)
+ when(partitionedRegion.getPRRoot())
+ .thenReturn(region);
+ when(regionEvent.clone())
+ .thenReturn(mock(RegionEventImpl.class));
+ doReturn(emptySet())
+ .when(spyPartitionedRegionClear)
.attemptToSendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_LOCK_FOR_PR_CLEAR);
+ OperationType.OP_LOCK_FOR_PR_CLEAR);
+ // act
spyPartitionedRegionClear.obtainLockForClear(regionEvent);
- verify(spyPartitionedRegionClear, times(1)).obtainClearLockLocal(internalDistributedMember);
- verify(spyPartitionedRegionClear, times(1)).sendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_LOCK_FOR_PR_CLEAR);
+ // assert
+ verify(spyPartitionedRegionClear)
+ .obtainClearLockLocal(internalDistributedMember);
+ verify(spyPartitionedRegionClear)
+ .sendPartitionedRegionClearMessage(regionEvent, OperationType.OP_LOCK_FOR_PR_CLEAR);
}
@Test
public void releaseLockForClearReleasesLocalLockAndSendsMessageForRemote() throws Exception {
+ // arrange
+ Region<String, PartitionRegionConfig> region = uncheckedCast(mock(Region.class));
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(regionEvent.clone()).thenReturn(mock(RegionEventImpl.class));
- Region<String, PartitionRegionConfig> region = mock(Region.class);
- when(partitionedRegion.getPRRoot()).thenReturn(region);
+
+ when(partitionedRegion.getPRRoot())
+ .thenReturn(region);
+ when(regionEvent.clone())
+ .thenReturn(mock(RegionEventImpl.class));
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear)
+ doReturn(emptySet())
+ .when(spyPartitionedRegionClear)
.attemptToSendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_UNLOCK_FOR_PR_CLEAR);
+ OperationType.OP_UNLOCK_FOR_PR_CLEAR);
+ // act
spyPartitionedRegionClear.releaseLockForClear(regionEvent);
- verify(spyPartitionedRegionClear, times(1)).releaseClearLockLocal();
- verify(spyPartitionedRegionClear, times(1)).sendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_UNLOCK_FOR_PR_CLEAR);
+ // assert
+ verify(spyPartitionedRegionClear)
+ .releaseClearLockLocal();
+ verify(spyPartitionedRegionClear)
+ .sendPartitionedRegionClearMessage(regionEvent, OperationType.OP_UNLOCK_FOR_PR_CLEAR);
}
@Test
public void clearRegionClearsLocalAndSendsMessageForRemote() throws Exception {
+ // arrange
+ Region<String, PartitionRegionConfig> region = uncheckedCast(mock(Region.class));
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(regionEvent.clone()).thenReturn(mock(RegionEventImpl.class));
- Region<String, PartitionRegionConfig> region = mock(Region.class);
- when(partitionedRegion.getPRRoot()).thenReturn(region);
+
+ when(partitionedRegion.getPRRoot())
+ .thenReturn(region);
+ when(regionEvent.clone())
+ .thenReturn(mock(RegionEventImpl.class));
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear)
- .attemptToSendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_PR_CLEAR);
+ doReturn(emptySet())
+ .when(spyPartitionedRegionClear)
+ .attemptToSendPartitionedRegionClearMessage(regionEvent, OperationType.OP_PR_CLEAR);
+ // act
spyPartitionedRegionClear.clearRegion(regionEvent);
- verify(spyPartitionedRegionClear, times(1)).clearRegionLocal(regionEvent);
- verify(spyPartitionedRegionClear, times(1)).sendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_PR_CLEAR);
+ // assert
+ verify(spyPartitionedRegionClear)
+ .clearRegionLocal(regionEvent);
+ verify(spyPartitionedRegionClear)
+ .sendPartitionedRegionClearMessage(regionEvent, OperationType.OP_PR_CLEAR);
}
@Test
public void waitForPrimaryReturnsAfterFindingAllPrimary() {
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+ RetryTimeKeeper retryTimer = mock(RetryTimeKeeper.class);
when(bucketAdvisor.hasPrimary()).thenReturn(true);
- setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
- PartitionedRegion.RetryTimeKeeper retryTimer = mock(PartitionedRegion.RetryTimeKeeper.class);
+ when(partitionedRegion.getDataStore()).thenReturn(dataStore);
+ setupBucketRegions(dataStore, bucketAdvisor);
+ // act
partitionedRegionClear.waitForPrimary(retryTimer);
- verify(retryTimer, times(0)).waitForBucketsRecovery();
+ // assert
+ verify(retryTimer, never()).waitForBucketsRecovery();
}
@Test
public void waitForPrimaryReturnsAfterRetryForPrimary() {
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+ RetryTimeKeeper retryTimer = mock(RetryTimeKeeper.class);
when(bucketAdvisor.hasPrimary()).thenReturn(false).thenReturn(true);
- setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
- PartitionedRegion.RetryTimeKeeper retryTimer = mock(PartitionedRegion.RetryTimeKeeper.class);
+ when(partitionedRegion.getDataStore()).thenReturn(dataStore);
+ setupBucketRegions(dataStore, bucketAdvisor);
+ // act
partitionedRegionClear.waitForPrimary(retryTimer);
- verify(retryTimer, times(1)).waitForBucketsRecovery();
+ // assert
+ verify(retryTimer).waitForBucketsRecovery();
}
@Test
public void waitForPrimaryThrowsPartitionedRegionPartialClearException() {
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
- setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
- PartitionedRegion.RetryTimeKeeper retryTimer = mock(PartitionedRegion.RetryTimeKeeper.class);
- when(retryTimer.overMaximum()).thenReturn(true);
-
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+ RetryTimeKeeper retryTimer = mock(RetryTimeKeeper.class);
+ when(partitionedRegion.getDataStore())
+ .thenReturn(dataStore);
+ when(retryTimer.overMaximum())
+ .thenReturn(true);
+ setupBucketRegions(dataStore, bucketAdvisor);
+
+ // act
Throwable thrown = catchThrowable(() -> partitionedRegionClear.waitForPrimary(retryTimer));
+ // assert
assertThat(thrown)
.isInstanceOf(PartitionedRegionPartialClearException.class)
.hasMessage(
"Unable to find primary bucket region during clear operation on prRegion region.");
- verify(retryTimer, times(0)).waitForBucketsRecovery();
+ verify(retryTimer, never())
+ .waitForBucketsRecovery();
}
@Test
public void clearRegionLocalCallsClearOnLocalPrimaryBucketRegions() {
- RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+ RegionEventImpl regionEvent = mock(RegionEventImpl.class);
when(bucketAdvisor.hasPrimary()).thenReturn(true);
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
- doNothing().when(partitionedRegionDataStore).lockBucketCreationForRegionClear();
- Set<BucketRegion> buckets = setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
+ when(partitionedRegion.getDataStore()).thenReturn(dataStore);
+ doNothing().when(dataStore).lockBucketCreationForRegionClear();
+ Set<BucketRegion> buckets = setupBucketRegions(dataStore, bucketAdvisor);
+ // act
Set<Integer> bucketsCleared = partitionedRegionClear.clearRegionLocal(regionEvent);
- assertThat(bucketsCleared).hasSize(buckets.size());
-
- ArgumentCaptor<RegionEventImpl> argument = ArgumentCaptor.forClass(RegionEventImpl.class);
+ // assert
+ assertThat(bucketsCleared).hasSameSizeAs(buckets);
+ ArgumentCaptor<RegionEventImpl> captor = forClass(RegionEventImpl.class);
for (BucketRegion bucketRegion : buckets) {
- verify(bucketRegion, times(1)).cmnClearRegion(argument.capture(), eq(false), eq(true));
- RegionEventImpl bucketRegionEvent = argument.getValue();
- assertThat(bucketRegionEvent.getRegion()).isEqualTo(bucketRegion);
+ verify(bucketRegion).cmnClearRegion(captor.capture(), eq(false), eq(true));
+ Region<?, ?> region = captor.getValue().getRegion();
+ assertThat(region).isEqualTo(bucketRegion);
}
}
@Test
public void clearRegionLocalRetriesClearOnNonClearedLocalPrimaryBucketRegionsWhenMembershipChanges() {
- RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
- when(bucketAdvisor.hasPrimary()).thenReturn(true);
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
- doNothing().when(partitionedRegionDataStore).lockBucketCreationForRegionClear();
- Set<BucketRegion> buckets = setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+ RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+
+ when(bucketAdvisor.hasPrimary())
+ .thenReturn(true);
+ doNothing()
+ .when(dataStore)
+ .lockBucketCreationForRegionClear();
- final int numExtraBuckets = 3;
- Set<BucketRegion> extraBuckets = new HashSet<>();
- for (int i = 0; i < numExtraBuckets; i++) {
+ Set<BucketRegion> buckets = setupBucketRegions(dataStore, bucketAdvisor);
+
+ Set<BucketRegion> allBuckets = new HashSet<>(buckets);
+ for (int i = 0; i < 3; i++) {
BucketRegion bucketRegion = mock(BucketRegion.class);
- when(bucketRegion.getBucketAdvisor()).thenReturn(bucketAdvisor);
- when(bucketRegion.size()).thenReturn(1);
- when(bucketRegion.getId()).thenReturn(i + buckets.size());
- extraBuckets.add(bucketRegion);
+ when(bucketRegion.getBucketAdvisor())
+ .thenReturn(bucketAdvisor);
+ when(bucketRegion.getId())
+ .thenReturn(i + buckets.size());
+ when(bucketRegion.size())
+ .thenReturn(1);
+ allBuckets.add(bucketRegion);
}
- Set<BucketRegion> allBuckets = new HashSet<>(buckets);
- allBuckets.addAll(extraBuckets);
// After the first try, add 3 extra buckets to the local bucket regions
- when(partitionedRegionDataStore.getAllLocalBucketRegions()).thenReturn(buckets)
+ when(dataStore.getAllLocalBucketRegions())
+ .thenReturn(buckets)
.thenReturn(allBuckets);
- when(partitionedRegionDataStore.getAllLocalPrimaryBucketRegions()).thenReturn(buckets)
+ when(dataStore.getAllLocalPrimaryBucketRegions())
+ .thenReturn(buckets)
.thenReturn(allBuckets);
+ when(partitionedRegion.getDataStore())
+ .thenReturn(dataStore);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
+ // partial mocking to stub some methods
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
- when(spyPartitionedRegionClear.getMembershipChange()).thenReturn(true).thenReturn(false);
+ when(spyPartitionedRegionClear.getMembershipChange())
+ .thenReturn(true)
+ .thenReturn(false);
+ // act
Set<Integer> bucketsCleared = spyPartitionedRegionClear.clearRegionLocal(regionEvent);
- int expectedClears = allBuckets.size();
- assertThat(bucketsCleared).hasSize(expectedClears);
-
- ArgumentCaptor<RegionEventImpl> argument = ArgumentCaptor.forClass(RegionEventImpl.class);
+ // assert
+ assertThat(bucketsCleared).hasSameSizeAs(allBuckets);
+ ArgumentCaptor<RegionEventImpl> captor = forClass(RegionEventImpl.class);
for (BucketRegion bucketRegion : allBuckets) {
- verify(bucketRegion, times(1)).cmnClearRegion(argument.capture(), eq(false), eq(true));
- RegionEventImpl bucketRegionEvent = argument.getValue();
- assertThat(bucketRegionEvent.getRegion()).isEqualTo(bucketRegion);
+ verify(bucketRegion)
+ .cmnClearRegion(captor.capture(), eq(false), eq(true));
+ Region<?, ?> region = captor.getValue().getRegion();
+ assertThat(region).isEqualTo(bucketRegion);
}
}
@Test
public void doAfterClearCallsNotifyClientsWhenClientHaveInterests() {
- RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(partitionedRegion.hasAnyClientsInterested()).thenReturn(true);
+ // arrange
FilterProfile filterProfile = mock(FilterProfile.class);
FilterRoutingInfo filterRoutingInfo = mock(FilterRoutingInfo.class);
- when(filterProfile.getFilterRoutingInfoPart1(regionEvent, FilterProfile.NO_PROFILES,
- Collections.emptySet())).thenReturn(filterRoutingInfo);
- when(filterProfile.getFilterRoutingInfoPart2(filterRoutingInfo, regionEvent)).thenReturn(
- filterRoutingInfo);
+ RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+
+ when(filterProfile.getFilterRoutingInfoPart1(regionEvent, NO_PROFILES, emptySet()))
+ .thenReturn(filterRoutingInfo);
+ when(filterProfile.getFilterRoutingInfoPart2(filterRoutingInfo, regionEvent))
+ .thenReturn(filterRoutingInfo);
when(partitionedRegion.getFilterProfile()).thenReturn(filterProfile);
+ when(partitionedRegion.hasAnyClientsInterested())
+ .thenReturn(true);
+ // act
partitionedRegionClear.doAfterClear(regionEvent);
- verify(regionEvent, times(1)).setLocalFilterInfo(any());
- verify(partitionedRegion, times(1)).notifyBridgeClients(regionEvent);
+ // assert
+ verify(regionEvent)
+ .setLocalFilterInfo(any());
+ verify(partitionedRegion)
+ .notifyBridgeClients(regionEvent);
}
@Test
public void doAfterClearDispatchesListenerEvents() {
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(partitionedRegion.hasListener()).thenReturn(true);
+ when(partitionedRegion.hasListener())
+ .thenReturn(true);
+ // act
partitionedRegionClear.doAfterClear(regionEvent);
- verify(partitionedRegion, times(1)).dispatchListenerEvent(
- EnumListenerEvent.AFTER_REGION_CLEAR, regionEvent);
+ verify(partitionedRegion)
+ .dispatchListenerEvent(EnumListenerEvent.AFTER_REGION_CLEAR, regionEvent);
}
@Test
public void obtainClearLockLocalGetsLockOnPrimaryBuckets() {
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
- when(bucketAdvisor.hasPrimary()).thenReturn(true);
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
- Set<BucketRegion> buckets = setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
- when(distributionManager.isCurrentMember(internalDistributedMember)).thenReturn(true);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+
+ when(bucketAdvisor.hasPrimary())
+ .thenReturn(true);
+ when(distributionManager.isCurrentMember(internalDistributedMember))
+ .thenReturn(true);
+ when(partitionedRegion.getDataStore())
+ .thenReturn(dataStore);
+
+ Set<BucketRegion> buckets = setupBucketRegions(dataStore, bucketAdvisor);
+ // act
partitionedRegionClear.obtainClearLockLocal(internalDistributedMember);
+ // assert
+ // TODO: encapsulate lockForListenerAndClientNotification
assertThat(partitionedRegionClear.lockForListenerAndClientNotification.getLockRequester())
.isSameAs(internalDistributedMember);
for (BucketRegion bucketRegion : buckets) {
- verify(bucketRegion, times(1)).lockLocallyForClear(partitionedRegion.getDistributionManager(),
- partitionedRegion.getMyId(), null);
+ verify(bucketRegion)
+ .lockLocallyForClear(partitionedRegion.getDistributionManager(),
+ partitionedRegion.getMyId(), null);
}
}
@Test
public void obtainClearLockLocalDoesNotGetLocksOnPrimaryBucketsWhenMemberIsNotCurrent() {
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
- when(bucketAdvisor.hasPrimary()).thenReturn(true);
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
- Set<BucketRegion> buckets = setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
- when(distributionManager.isCurrentMember(internalDistributedMember)).thenReturn(false);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+
+ when(bucketAdvisor.hasPrimary())
+ .thenReturn(true);
+ when(distributionManager.isCurrentMember(internalDistributedMember))
+ .thenReturn(false);
+ when(partitionedRegion.getDataStore())
+ .thenReturn(dataStore);
+ Set<BucketRegion> buckets = setupBucketRegions(dataStore, bucketAdvisor);
+
+ // act
partitionedRegionClear.obtainClearLockLocal(internalDistributedMember);
+ // assert
assertThat(partitionedRegionClear.lockForListenerAndClientNotification.getLockRequester())
.isNull();
for (BucketRegion bucketRegion : buckets) {
- verify(bucketRegion, times(0)).lockLocallyForClear(partitionedRegion.getDistributionManager(),
- partitionedRegion.getMyId(), null);
+ verify(bucketRegion, never())
+ .lockLocallyForClear(partitionedRegion.getDistributionManager(),
+ partitionedRegion.getMyId(), null);
}
}
@Test
public void releaseClearLockLocalReleasesLockOnPrimaryBuckets() {
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
- when(bucketAdvisor.hasPrimary()).thenReturn(true);
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
- Set<BucketRegion> buckets = setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
- when(distributionManager.isCurrentMember(internalDistributedMember)).thenReturn(true);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+
+ when(bucketAdvisor.hasPrimary())
+ .thenReturn(true);
+ when(distributionManager.isCurrentMember(internalDistributedMember))
+ .thenReturn(true);
+ when(partitionedRegion.getDataStore())
+ .thenReturn(dataStore);
+
+ Set<BucketRegion> buckets = setupBucketRegions(dataStore, bucketAdvisor);
+
partitionedRegionClear.lockForListenerAndClientNotification
.setLocked(internalDistributedMember);
+ // act
partitionedRegionClear.releaseClearLockLocal();
+ // assert
for (BucketRegion bucketRegion : buckets) {
- verify(bucketRegion, times(1)).releaseLockLocallyForClear(null);
+ verify(bucketRegion)
+ .releaseLockLocallyForClear(null);
}
}
@Test
public void releaseClearLockLocalDoesNotReleaseLocksOnPrimaryBucketsWhenMemberIsNotCurrent() {
+ // arrange
BucketAdvisor bucketAdvisor = mock(BucketAdvisor.class);
- when(bucketAdvisor.hasPrimary()).thenReturn(true);
- PartitionedRegionDataStore partitionedRegionDataStore = mock(PartitionedRegionDataStore.class);
- Set<BucketRegion> buckets = setupBucketRegions(partitionedRegionDataStore, bucketAdvisor);
- when(partitionedRegion.getDataStore()).thenReturn(partitionedRegionDataStore);
+ PartitionedRegionDataStore dataStore = mock(PartitionedRegionDataStore.class);
+
+ when(bucketAdvisor.hasPrimary())
+ .thenReturn(true);
+ when(partitionedRegion.getDataStore())
+ .thenReturn(dataStore);
+
+ Set<BucketRegion> buckets = setupBucketRegions(dataStore, bucketAdvisor);
+ // act
partitionedRegionClear.releaseClearLockLocal();
+ // assert
assertThat(partitionedRegionClear.lockForListenerAndClientNotification.getLockRequester())
.isNull();
for (BucketRegion bucketRegion : buckets) {
- verify(bucketRegion, times(0)).releaseLockLocallyForClear(null);
+ verify(bucketRegion, never())
+ .releaseLockLocallyForClear(null);
}
}
@Test
public void sendPartitionedRegionClearMessageSendsClearMessageToPRNodes() {
- RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(regionEvent.clone()).thenReturn(mock(RegionEventImpl.class));
- Region<String, PartitionRegionConfig> prRoot = mock(Region.class);
- when(partitionedRegion.getPRRoot()).thenReturn(prRoot);
+ // arrange
+ InternalCache internalCache = mock(InternalCache.class);
InternalDistributedMember member = mock(InternalDistributedMember.class);
- Set<InternalDistributedMember> prNodes = Collections.singleton(member);
Node node = mock(Node.class);
- when(node.getMemberId()).thenReturn(member);
- Set<Node> configNodes = Collections.singleton(node);
- when(regionAdvisor.adviseAllPRNodes()).thenReturn(prNodes);
PartitionRegionConfig partitionRegionConfig = mock(PartitionRegionConfig.class);
- when(partitionRegionConfig.getNodes()).thenReturn(configNodes);
- when(prRoot.get(any())).thenReturn(partitionRegionConfig);
- InternalDistributedSystem internalDistributedSystem = mock(InternalDistributedSystem.class);
- when(internalDistributedSystem.getDistributionManager()).thenReturn(distributionManager);
- when(partitionedRegion.getSystem()).thenReturn(internalDistributedSystem);
- InternalCache internalCache = mock(InternalCache.class);
+ Region<String, PartitionRegionConfig> prRoot = uncheckedCast(mock(Region.class));
+ RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+ InternalDistributedSystem system = mock(InternalDistributedSystem.class);
TXManagerImpl txManager = mock(TXManagerImpl.class);
- when(txManager.isDistributed()).thenReturn(false);
- when(internalCache.getTxManager()).thenReturn(txManager);
- when(partitionedRegion.getCache()).thenReturn(internalCache);
- when(member.getVersion()).thenReturn(KnownVersion.getCurrentVersion());
- when(distributionManager.getCancelCriterion()).thenReturn(mock(CancelCriterion.class));
- when(distributionManager.getStats()).thenReturn(mock(DMStats.class));
-
- partitionedRegionClear.sendPartitionedRegionClearMessage(regionEvent,
- PartitionedRegionClearMessage.OperationType.OP_PR_CLEAR);
- verify(distributionManager, times(1)).putOutgoing(any());
+ Set<InternalDistributedMember> prNodes = singleton(member);
+ Set<Node> configNodes = singleton(node);
+
+ when(distributionManager.getCancelCriterion())
+ .thenReturn(mock(CancelCriterion.class));
+ when(distributionManager.getStats())
+ .thenReturn(mock(DMStats.class));
+ when(internalCache.getTxManager())
+ .thenReturn(txManager);
+ when(member.getVersion())
+ .thenReturn(KnownVersion.getCurrentVersion());
+ when(node.getMemberId())
+ .thenReturn(member);
+ when(partitionRegionConfig.getNodes())
+ .thenReturn(configNodes);
+ when(partitionedRegion.getPRRoot())
+ .thenReturn(prRoot);
+ when(regionAdvisor.adviseAllPRNodes())
+ .thenReturn(prNodes);
+ when(regionEvent.clone())
+ .thenReturn(mock(RegionEventImpl.class));
+ when(partitionedRegion.getSystem())
+ .thenReturn(system);
+ when(prRoot.get(anyString()))
+ .thenReturn(partitionRegionConfig);
+ when(system.getDistributionManager())
+ .thenReturn(distributionManager);
+ when(txManager.isDistributed())
+ .thenReturn(false);
+ when(partitionedRegion.getCache())
+ .thenReturn(internalCache);
+
+ // act
+ partitionedRegionClear
+ .sendPartitionedRegionClearMessage(regionEvent, OperationType.OP_PR_CLEAR);
+
+ // assert
+ verify(distributionManager)
+ .putOutgoing(any());
}
-
-
@Test
public void doClearAcquiresAndReleasesDistributedClearLockAndCreatesAllPrimaryBuckets() {
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ // act
spyPartitionedRegionClear.doClear(regionEvent, false);
- verify(spyPartitionedRegionClear, times(1)).acquireDistributedClearLock(any());
- verify(spyPartitionedRegionClear, times(1)).releaseDistributedClearLock(any());
- verify(spyPartitionedRegionClear, times(1)).assignAllPrimaryBuckets();
+ // assert
+ verify(spyPartitionedRegionClear).acquireDistributedClearLock(any());
+ verify(spyPartitionedRegionClear).releaseDistributedClearLock(any());
+ verify(spyPartitionedRegionClear).assignAllPrimaryBuckets();
}
@Test
public void doClearInvokesCacheWriterWhenCacheWriteIsSet() {
- boolean cacheWrite = true;
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
- spyPartitionedRegionClear.doClear(regionEvent, cacheWrite);
- verify(spyPartitionedRegionClear, times(1)).invokeCacheWriter(regionEvent);
+ // act
+ spyPartitionedRegionClear.doClear(regionEvent, true);
+
+ // assert
+ verify(spyPartitionedRegionClear).invokeCacheWriter(regionEvent);
}
@Test
public void doClearDoesNotInvokesCacheWriterWhenCacheWriteIsNotSet() {
- boolean cacheWrite = false;
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
- spyPartitionedRegionClear.doClear(regionEvent, cacheWrite);
+ // act
+ spyPartitionedRegionClear.doClear(regionEvent, false);
- verify(spyPartitionedRegionClear, times(0)).invokeCacheWriter(regionEvent);
+ // assert
+ verify(spyPartitionedRegionClear, never()).invokeCacheWriter(regionEvent);
}
@Test
public void doClearObtainsAndReleasesLockForClearWhenRegionHasListener() {
- boolean cacheWrite = false;
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(partitionedRegion.hasListener()).thenReturn(true);
+
when(partitionedRegion.hasAnyClientsInterested()).thenReturn(false);
+ when(partitionedRegion.hasListener()).thenReturn(true);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
doNothing().when(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
doNothing().when(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
- spyPartitionedRegionClear.doClear(regionEvent, cacheWrite);
+ // act
+ spyPartitionedRegionClear.doClear(regionEvent, false);
- verify(spyPartitionedRegionClear, times(1)).obtainLockForClear(regionEvent);
- verify(spyPartitionedRegionClear, times(1)).releaseLockForClear(regionEvent);
+ // assert
+ verify(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
+ verify(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
}
@Test
public void doClearObtainsAndReleasesLockForClearWhenRegionHasClientInterest() {
+ // arrange
boolean cacheWrite = false;
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(partitionedRegion.hasListener()).thenReturn(false);
+
when(partitionedRegion.hasAnyClientsInterested()).thenReturn(true);
+ when(partitionedRegion.hasListener()).thenReturn(false);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
doNothing().when(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
doNothing().when(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ // act
spyPartitionedRegionClear.doClear(regionEvent, cacheWrite);
- verify(spyPartitionedRegionClear, times(1)).obtainLockForClear(regionEvent);
- verify(spyPartitionedRegionClear, times(1)).releaseLockForClear(regionEvent);
+ // assert
+ verify(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
+ verify(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
}
@Test
public void doClearDoesNotObtainLockForClearWhenRegionHasNoListenerAndNoClientInterest() {
- boolean cacheWrite = false;
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(partitionedRegion.hasListener()).thenReturn(false);
+
when(partitionedRegion.hasAnyClientsInterested()).thenReturn(false);
+ when(partitionedRegion.hasListener()).thenReturn(false);
+
+ // partial mocking to stub some methods and verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
doNothing().when(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
doNothing().when(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
- spyPartitionedRegionClear.doClear(regionEvent, cacheWrite);
+ // act
+ spyPartitionedRegionClear.doClear(regionEvent, false);
- verify(spyPartitionedRegionClear, times(0)).obtainLockForClear(regionEvent);
- verify(spyPartitionedRegionClear, times(0)).releaseLockForClear(regionEvent);
+ // assert
+ verify(spyPartitionedRegionClear, never()).obtainLockForClear(regionEvent);
+ verify(spyPartitionedRegionClear, never()).releaseLockForClear(regionEvent);
}
@Test
public void doClearThrowsPartitionedRegionPartialClearException() {
- boolean cacheWrite = false;
+ // arrange
RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+
when(partitionedRegion.hasListener()).thenReturn(false);
when(partitionedRegion.hasAnyClientsInterested()).thenReturn(false);
when(partitionedRegion.getTotalNumberOfBuckets()).thenReturn(1);
when(partitionedRegion.getName()).thenReturn("prRegion");
+
+ // partial mocking to stub some methods
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
doNothing().when(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
doNothing().when(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
- doReturn(Collections.EMPTY_SET).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ doReturn(emptySet()).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ // act
Throwable thrown =
- catchThrowable(() -> spyPartitionedRegionClear.doClear(regionEvent, cacheWrite));
+ catchThrowable(() -> spyPartitionedRegionClear.doClear(regionEvent, false));
+ // assert
assertThat(thrown)
.isInstanceOf(PartitionedRegionPartialClearException.class)
.hasMessage(
@@ -559,125 +717,181 @@ public class PartitionedRegionClearTest {
@Test
public void doClearThrowsUnsupportedOperationException() {
- boolean cacheWrite = false;
- RegionEventImpl regionEvent = mock(RegionEventImpl.class);
- when(partitionedRegion.hasListener()).thenReturn(false);
- when(partitionedRegion.hasAnyClientsInterested()).thenReturn(false);
- when(partitionedRegion.getTotalNumberOfBuckets()).thenReturn(2);
- when(partitionedRegion.getName()).thenReturn("prRegion");
- PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
- doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
- doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
- doNothing().when(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
- doNothing().when(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
- doReturn(Collections.singleton("2")).when(spyPartitionedRegionClear).clearRegion(regionEvent);
-
- when(regionEvent.clone()).thenReturn(mock(RegionEventImpl.class));
- Region<String, PartitionRegionConfig> prRoot = mock(Region.class);
- when(partitionedRegion.getPRRoot()).thenReturn(prRoot);
+ // arrange
InternalDistributedMember member = mock(InternalDistributedMember.class);
InternalDistributedMember oldMember = mock(InternalDistributedMember.class);
+ Node node = mock(Node.class);
+ Node oldNode = mock(Node.class);
+
Set<InternalDistributedMember> prNodes = new HashSet<>();
prNodes.add(member);
prNodes.add(oldMember);
- Node node = mock(Node.class);
- Node oldNode = mock(Node.class);
- when(member.getName()).thenReturn("member");
- when(oldMember.getName()).thenReturn("oldMember");
- when(node.getMemberId()).thenReturn(member);
- when(oldNode.getMemberId()).thenReturn(oldMember);
+
Set<Node> configNodes = new HashSet<>();
configNodes.add(node);
configNodes.add(oldNode);
- when(partitionedRegion.getBucketPrimary(0)).thenReturn(member);
- when(partitionedRegion.getBucketPrimary(1)).thenReturn(oldMember);
- when(regionAdvisor.adviseAllPRNodes()).thenReturn(prNodes);
+ InternalCache cache = mock(InternalCache.class);
PartitionRegionConfig partitionRegionConfig = mock(PartitionRegionConfig.class);
- when(partitionRegionConfig.getNodes()).thenReturn(configNodes);
- when(prRoot.get(any())).thenReturn(partitionRegionConfig);
- InternalDistributedSystem internalDistributedSystem = mock(InternalDistributedSystem.class);
- when(internalDistributedSystem.getDistributionManager()).thenReturn(distributionManager);
- when(partitionedRegion.getSystem()).thenReturn(internalDistributedSystem);
- InternalCache internalCache = mock(InternalCache.class);
+ Region<String, PartitionRegionConfig> prRoot = uncheckedCast(mock(Region.class));
+ RegionEventImpl regionEvent = mock(RegionEventImpl.class);
+ InternalDistributedSystem system = mock(InternalDistributedSystem.class);
TXManagerImpl txManager = mock(TXManagerImpl.class);
- when(txManager.isDistributed()).thenReturn(false);
- when(internalCache.getTxManager()).thenReturn(txManager);
- when(partitionedRegion.getCache()).thenReturn(internalCache);
- when(oldMember.getVersion()).thenReturn(KnownVersion.GEODE_1_11_0);
+
+ when(member.getName()).thenReturn("member");
+ when(oldMember.getName()).thenReturn("oldMember");
+ when(node.getMemberId()).thenReturn(member);
+ when(oldNode.getMemberId()).thenReturn(oldMember);
when(member.getVersion()).thenReturn(KnownVersion.getCurrentVersion());
+ when(oldMember.getVersion()).thenReturn(KnownVersion.GEODE_1_11_0);
+
+ when(cache.getTxManager()).thenReturn(txManager);
when(distributionManager.getCancelCriterion()).thenReturn(mock(CancelCriterion.class));
when(distributionManager.getStats()).thenReturn(mock(DMStats.class));
+ when(partitionRegionConfig.getNodes()).thenReturn(configNodes);
+ when(partitionedRegion.getBucketPrimary(0)).thenReturn(member);
+ when(partitionedRegion.getBucketPrimary(1)).thenReturn(oldMember);
+ when(partitionedRegion.getCache()).thenReturn(cache);
+ when(partitionedRegion.getName()).thenReturn("prRegion");
+ when(partitionedRegion.getPRRoot()).thenReturn(prRoot);
+ when(partitionedRegion.getSystem()).thenReturn(system);
+ when(partitionedRegion.getTotalNumberOfBuckets()).thenReturn(2);
+ when(partitionedRegion.hasListener()).thenReturn(false);
+ when(partitionedRegion.hasAnyClientsInterested()).thenReturn(false);
+ when(prRoot.get(anyString())).thenReturn(partitionRegionConfig);
+ when(regionAdvisor.adviseAllPRNodes()).thenReturn(prNodes);
+ when(regionEvent.clone()).thenReturn(mock(RegionEventImpl.class));
+ when(system.getDistributionManager()).thenReturn(distributionManager);
+ when(txManager.isDistributed()).thenReturn(false);
+ // partial mocking to stub some methods
+ PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
+ doNothing().when(spyPartitionedRegionClear).acquireDistributedClearLock(any());
+ doNothing().when(spyPartitionedRegionClear).assignAllPrimaryBuckets();
+ doNothing().when(spyPartitionedRegionClear).obtainLockForClear(regionEvent);
+ doNothing().when(spyPartitionedRegionClear).releaseLockForClear(regionEvent);
+ doReturn(singleton("2")).when(spyPartitionedRegionClear).clearRegion(regionEvent);
+ // act
Throwable thrown =
- catchThrowable(() -> spyPartitionedRegionClear.doClear(regionEvent, cacheWrite));
+ catchThrowable(() -> spyPartitionedRegionClear.doClear(regionEvent, false));
+ // assert
assertThat(thrown)
.isInstanceOf(UnsupportedOperationException.class)
.hasMessage(
"A server's [oldMember] version was too old (< GEODE 1.14.0) for : Partitioned Region Clear");
}
-
-
@Test
public void handleClearFromDepartedMemberReleasesTheLockForRequesterDeparture() {
+ // arrange
InternalDistributedMember member = mock(InternalDistributedMember.class);
partitionedRegionClear.lockForListenerAndClientNotification.setLocked(member);
+
+ // partial mocking to verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
+ // act
spyPartitionedRegionClear.handleClearFromDepartedMember(member);
- verify(spyPartitionedRegionClear, times(1)).releaseClearLockLocal();
+ // assert
+ verify(spyPartitionedRegionClear).releaseClearLockLocal();
}
@Test
public void handleClearFromDepartedMemberDoesNotReleasesTheLockForNonRequesterDeparture() {
+ // arrange
InternalDistributedMember requesterMember = mock(InternalDistributedMember.class);
InternalDistributedMember member = mock(InternalDistributedMember.class);
partitionedRegionClear.lockForListenerAndClientNotification.setLocked(requesterMember);
+
+ // partial mocking to verify
PartitionedRegionClear spyPartitionedRegionClear = spy(partitionedRegionClear);
+ // act
spyPartitionedRegionClear.handleClearFromDepartedMember(member);
- verify(spyPartitionedRegionClear, times(0)).releaseClearLockLocal();
+ // assert
+ verify(spyPartitionedRegionClear, never()).releaseClearLockLocal();
}
@Test
public void partitionedRegionClearRegistersMembershipListener() {
+ // assert
MembershipListener membershipListener =
partitionedRegionClear.getPartitionedRegionClearListener();
-
- verify(distributionManager, times(1)).addMembershipListener(membershipListener);
+ verify(distributionManager).addMembershipListener(membershipListener);
}
@Test
public void lockRequesterDepartureReleasesTheLock() {
+ // arrange
InternalDistributedMember member = mock(InternalDistributedMember.class);
partitionedRegionClear.lockForListenerAndClientNotification.setLocked(member);
- PartitionedRegionClear.PartitionedRegionClearListener partitionedRegionClearListener =
+ PartitionedRegionClearListener partitionedRegionClearListener =
partitionedRegionClear.getPartitionedRegionClearListener();
+ // act
partitionedRegionClearListener.memberDeparted(distributionManager, member, true);
- assertThat(partitionedRegionClear.getMembershipChange()).isTrue();
+ // assert
+ assertThat(partitionedRegionClear.getMembershipChange())
+ .isTrue();
assertThat(partitionedRegionClear.lockForListenerAndClientNotification.getLockRequester())
.isNull();
}
@Test
public void nonLockRequesterDepartureDoesNotReleasesTheLock() {
+ // arrange
InternalDistributedMember requesterMember = mock(InternalDistributedMember.class);
InternalDistributedMember member = mock(InternalDistributedMember.class);
partitionedRegionClear.lockForListenerAndClientNotification.setLocked(requesterMember);
- PartitionedRegionClear.PartitionedRegionClearListener partitionedRegionClearListener =
+ PartitionedRegionClearListener partitionedRegionClearListener =
partitionedRegionClear.getPartitionedRegionClearListener();
+ // act
partitionedRegionClearListener.memberDeparted(distributionManager, member, true);
- assertThat(partitionedRegionClear.getMembershipChange()).isTrue();
+ // assert
+ assertThat(partitionedRegionClear.getMembershipChange())
+ .isTrue();
assertThat(partitionedRegionClear.lockForListenerAndClientNotification.getLockRequester())
.isNotNull();
}
+
+ private Set<BucketRegion> setupBucketRegions(
+ PartitionedRegionDataStore dataStore,
+ BucketAdvisor bucketAdvisor) {
+ return setupBucketRegions(dataStore, bucketAdvisor, 2);
+ }
+
+ private Set<BucketRegion> setupBucketRegions(
+ PartitionedRegionDataStore dataStore,
+ BucketAdvisor bucketAdvisor,
+ int bucketCount) {
+ Set<BucketRegion> bucketRegions = new HashSet<>();
+
+ for (int i = 0; i < bucketCount; i++) {
+ BucketRegion bucketRegion = mock(BucketRegion.class);
+
+ when(bucketRegion.getBucketAdvisor())
+ .thenReturn(bucketAdvisor);
+ when(bucketRegion.getId())
+ .thenReturn(i);
+ when(bucketRegion.size())
+ .thenReturn(1)
+ .thenReturn(0);
+
+ bucketRegions.add(bucketRegion);
+ }
+
+ when(dataStore.getAllLocalBucketRegions())
+ .thenReturn(bucketRegions);
+ when(dataStore.getAllLocalPrimaryBucketRegions())
+ .thenReturn(bucketRegions);
+
+ return bucketRegions;
+ }
}