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:21:38 UTC
[geode] branch GEODE-7665-PR-clear-develop created (now 96b2a49)
This is an automated email from the ASF dual-hosted git repository.
klund pushed a change to branch GEODE-7665-PR-clear-develop
in repository https://gitbox.apache.org/repos/asf/geode.git.
at 96b2a49 GEODE-9132: Minor cleanup of PartitionedRegionClearTest
This branch includes the following new commits:
new 96b2a49 GEODE-9132: Minor cleanup of PartitionedRegionClearTest
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[geode] 01/01: GEODE-9132: Minor cleanup of
PartitionedRegionClearTest
Posted by kl...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
klund pushed a commit to branch GEODE-7665-PR-clear-develop
in repository https://gitbox.apache.org/repos/asf/geode.git
commit 96b2a49a5d1ac963ee0070bf6a95152cccf16e22
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;
+ }
}