2 * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.mdsal.singleton.impl;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertThrows;
13 import static org.mockito.ArgumentMatchers.any;
14 import static org.mockito.ArgumentMatchers.eq;
15 import static org.mockito.Mockito.doNothing;
16 import static org.mockito.Mockito.doReturn;
17 import static org.mockito.Mockito.doThrow;
18 import static org.mockito.Mockito.never;
19 import static org.mockito.Mockito.verify;
20 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED;
21 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER;
22 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED;
23 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_LOST_NO_OWNER;
24 import static org.opendaylight.mdsal.singleton.impl.EOSClusterSingletonServiceProvider.CLOSE_SERVICE_ENTITY_TYPE;
25 import static org.opendaylight.mdsal.singleton.impl.EOSClusterSingletonServiceProvider.SERVICE_ENTITY_TYPE;
27 import com.google.common.util.concurrent.Futures;
28 import com.google.common.util.concurrent.ListenableFuture;
29 import org.eclipse.jdt.annotation.NonNull;
30 import org.junit.Before;
31 import org.junit.Test;
32 import org.mockito.Mock;
33 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
34 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
35 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
36 import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
37 import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
38 import org.opendaylight.yangtools.concepts.Registration;
41 * Abstract {@link EOSClusterSingletonServiceProvider} testing substrate.
43 abstract class AbstractEOSClusterSingletonServiceProviderTest {
45 * Base states for AbstractClusterProjectProvider.
47 enum TestClusterSingletonServiceState {
49 * State represents a correct Instantiated process.
53 * State represents a correct call abstract method instantiatingProject.
57 * State represents a correct call abstract method destryingProject.
62 static class TestClusterSingletonService implements ClusterSingletonService {
63 private TestClusterSingletonServiceState serviceState = TestClusterSingletonServiceState.INITIALIZED;
66 public final ServiceGroupIdentifier getIdentifier() {
71 public final void instantiateServiceInstance() {
72 serviceState = TestClusterSingletonServiceState.STARTED;
75 final TestClusterSingletonServiceState getServiceState() {
80 public ListenableFuture<Void> closeServiceInstance() {
81 serviceState = TestClusterSingletonServiceState.DESTROYED;
82 return Futures.immediateFuture(null);
86 private static final @NonNull String SERVICE_NAME = "testServiceName";
87 private static final @NonNull ServiceGroupIdentifier SERVICE_ID = new ServiceGroupIdentifier(SERVICE_NAME);
88 static final @NonNull DOMEntity ENTITY = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
89 static final @NonNull DOMEntity DOUBLE_ENTITY = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
92 public DOMEntityOwnershipService mockEos;
94 public Registration mockEntityCandReg;
96 public Registration mockDoubleEntityCandReg;
98 public Registration mockEosEntityListReg;
100 public Registration mockEosDoubleEntityListReg;
102 EOSClusterSingletonServiceProvider clusterSingletonServiceProvider;
103 TestClusterSingletonService clusterSingletonService;
104 TestClusterSingletonService clusterSingletonService2;
107 public void setup() throws Exception {
108 doNothing().when(mockEosEntityListReg).close();
109 doNothing().when(mockEosDoubleEntityListReg).close();
110 doNothing().when(mockEntityCandReg).close();
111 doNothing().when(mockDoubleEntityCandReg).close();
112 doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
113 any(EOSClusterSingletonServiceProvider.class));
114 doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
115 any(EOSClusterSingletonServiceProvider.class));
116 doReturn(mockEntityCandReg).when(mockEos).registerCandidate(ENTITY);
117 doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(DOUBLE_ENTITY);
119 clusterSingletonServiceProvider = new EOSClusterSingletonServiceProvider(mockEos);
120 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
121 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
123 clusterSingletonService = instantiateService();
124 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
125 clusterSingletonService2 = instantiateService();
126 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
129 TestClusterSingletonService instantiateService() {
130 return new TestClusterSingletonService();
134 * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
137 public void initializationClusterSingletonServiceProviderNullInputTest() {
138 assertThrows(NullPointerException.class, () -> new EOSClusterSingletonServiceProvider(null));
142 * Test GoldPath for close {@link EOSClusterSingletonServiceProvider}.
144 * @throws Exception if the condition does not meet
147 public void closeClusterSingletonServiceProviderTest() throws Exception {
148 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
149 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
150 clusterSingletonServiceProvider.close();
151 verify(mockEosEntityListReg).close();
152 verify(mockEosDoubleEntityListReg).close();
156 * Test parser ServiceIdentifier from Entity.
159 public void makeEntityClusterSingletonServiceProviderTest() {
160 assertEquals(ENTITY, EOSClusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_ID));
161 assertEquals(DOUBLE_ENTITY,
162 EOSClusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_ID));
166 * Test parser ServiceIdentifier from Entity.
169 public void getIdentifierClusterSingletonServiceProviderTest() {
170 assertEquals(SERVICE_NAME, EOSClusterSingletonServiceProvider.getServiceIdentifierFromEntity(ENTITY));
171 assertEquals(SERVICE_NAME, EOSClusterSingletonServiceProvider.getServiceIdentifierFromEntity(DOUBLE_ENTITY));
175 * Test GoldPath for initialization {@link ClusterSingletonService}.
178 public void initializationClusterSingletonServiceTest() throws Exception {
179 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
181 verify(mockEos).registerCandidate(ENTITY);
182 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
186 * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
189 public void slaveInitClusterSingletonServiceTest() throws Exception {
190 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
192 verify(mockEos).registerCandidate(ENTITY);
193 clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
194 verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
195 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
199 * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
202 public void slaveInitNoMasterClusterSingletonServiceTest() throws Exception {
203 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
205 verify(mockEos).registerCandidate(ENTITY);
206 clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, false);
207 verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
208 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
212 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
215 public void masterInitClusterSingletonServiceTest() throws Exception {
216 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
218 verify(mockEos).registerCandidate(ENTITY);
219 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
220 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
221 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
225 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
228 public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws Exception {
229 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
231 verify(mockEos).registerCandidate(ENTITY);
232 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
233 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
234 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
235 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
239 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
242 public void takeLeadershipClusterSingletonServiceTest() throws Exception {
243 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
245 verify(mockEos).registerCandidate(ENTITY);
246 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
247 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
248 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
249 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
250 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
254 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
257 public void masterInitClusterSingletonServiceTwoServicesTest() throws Exception {
258 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
260 verify(mockEos).registerCandidate(ENTITY);
261 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
262 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
263 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
264 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
266 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
270 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
273 public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
274 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
276 verify(mockEos).registerCandidate(ENTITY);
277 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
278 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
279 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
281 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
282 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
283 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
284 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
285 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
289 * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
292 public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
293 doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(ENTITY);
294 assertThrows(RuntimeException.class,
295 () -> clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService));
299 * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
300 * {@link ClusterSingletonService}.
303 public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
304 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
306 verify(mockEos).registerCandidate(ENTITY);
307 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
308 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
309 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
310 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
311 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
312 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
313 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
317 * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
320 public void lostLeadershipClusterSingletonServiceTest() throws Exception {
321 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
323 verify(mockEos).registerCandidate(ENTITY);
324 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
325 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
326 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
327 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
328 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
329 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
330 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
331 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
332 assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
336 * Test checks inJeopardy Cluster Node state for Slave Instance.
339 public void inJeopardySlaveTest() throws Exception {
340 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
342 verify(mockEos).registerCandidate(ENTITY);
343 clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
344 verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
345 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
346 clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
347 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
348 verify(mockEosEntityListReg, never()).close();
349 verify(mockEosDoubleEntityListReg, never()).close();
350 verify(mockEntityCandReg, never()).close();
351 verify(mockDoubleEntityCandReg, never()).close();
355 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
358 public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
359 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
361 verify(mockEos).registerCandidate(ENTITY);
362 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
363 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
364 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
365 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
366 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
367 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
369 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
373 * Test checks close processing for {@link ServiceRegistration}.
376 public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
377 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
379 verify(mockEos).registerCandidate(ENTITY);
380 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
382 verify(mockEosEntityListReg, never()).close();
383 verify(mockEosDoubleEntityListReg, never()).close();
384 verify(mockEntityCandReg).close();
385 verify(mockDoubleEntityCandReg, never()).close();
386 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
390 * Test checks close processing for {@link ServiceRegistration}.
393 public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
394 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
396 verify(mockEos).registerCandidate(ENTITY);
397 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
399 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
400 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
402 verify(mockEosEntityListReg, never()).close();
403 verify(mockEosDoubleEntityListReg, never()).close();
404 verify(mockEntityCandReg, never()).close();
405 verify(mockDoubleEntityCandReg, never()).close();
406 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
407 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
411 * Test checks close processing for {@link ServiceRegistration}.
414 public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
415 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
417 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
418 verify(mockEos).registerCandidate(ENTITY);
419 clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
421 verify(mockEosEntityListReg, never()).close();
422 verify(mockEosDoubleEntityListReg, never()).close();
423 verify(mockEntityCandReg).close();
424 verify(mockDoubleEntityCandReg, never()).close();
425 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
429 * Test checks close processing for {@link ServiceRegistration}.
432 public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
433 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
435 verify(mockEos).registerCandidate(ENTITY);
436 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
438 clusterSingletonServiceProvider.ownershipChanged(ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
439 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
440 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
442 verify(mockEosEntityListReg, never()).close();
443 verify(mockEosDoubleEntityListReg, never()).close();
444 verify(mockEntityCandReg, never()).close();
445 verify(mockDoubleEntityCandReg, never()).close();
446 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
447 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
451 * Test checks close processing for {@link ServiceRegistration}.
454 public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
455 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
457 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
459 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
460 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
461 verify(mockEos).registerCandidate(ENTITY);
462 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
463 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
464 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
465 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
466 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
468 verify(mockEosEntityListReg, never()).close();
469 verify(mockEosDoubleEntityListReg, never()).close();
470 verify(mockEntityCandReg, never()).close();
471 verify(mockDoubleEntityCandReg, never()).close();
472 assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
473 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
477 * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
480 public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
481 final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
483 final var reg2 = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
485 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
486 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
487 verify(mockEos).registerCandidate(ENTITY);
489 clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
490 verify(mockEos).registerCandidate(DOUBLE_ENTITY);
491 clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
492 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
493 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
494 verify(mockEosEntityListReg, never()).close();
495 verify(mockEosDoubleEntityListReg, never()).close();
496 verify(mockEntityCandReg, never()).close();
497 verify(mockDoubleEntityCandReg, never()).close();
498 assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
499 assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());