2 * Copyright (c) 2016 Cisco Systems, Inc. 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
9 package org.opendaylight.mdsal.singleton.dom.impl;
11 import static org.mockito.Matchers.any;
12 import static org.mockito.Matchers.eq;
13 import static org.mockito.Mockito.doNothing;
14 import static org.mockito.Mockito.doReturn;
15 import static org.mockito.Mockito.doThrow;
16 import static org.mockito.Mockito.never;
17 import static org.mockito.Mockito.verify;
18 import com.google.common.util.concurrent.Futures;
19 import com.google.common.util.concurrent.ListenableFuture;
20 import org.junit.Assert;
21 import org.junit.Before;
22 import org.junit.Test;
23 import org.mockito.Mock;
24 import org.mockito.MockitoAnnotations;
25 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
26 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
27 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
28 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
29 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
30 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
31 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
32 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
33 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
34 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
37 * Testing {@link DOMClusterSingletonServiceProviderImpl} implementation
39 public class DOMClusterSingletonServiceProviderImplTest {
41 private static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
42 private static final String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
43 private static final String SERVICE_NAME = "testServiceName";
46 private DOMEntityOwnershipService mockEos;
48 private DOMEntityOwnershipCandidateRegistration mockEntityCandReg;
50 private DOMEntityOwnershipCandidateRegistration mockDoubleEntityCandReg;
52 private DOMEntityOwnershipListenerRegistration mockEosEntityListReg;
54 private DOMEntityOwnershipListenerRegistration mockEosDoubleEntityListReg;
56 private DOMClusterSingletonServiceProviderImpl clusterSingletonServiceProvider;
57 private TestClusterSingletonServiceInstance clusterSingletonService;
58 private TestClusterSingletonServiceInstance clusterSingletonService2;
60 private final DOMEntity entity = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
61 private final DOMEntity doubleEntity = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
64 * Initialization functionality for every Tests in this suite
69 public void setup() throws Exception {
70 MockitoAnnotations.initMocks(this);
72 doNothing().when(mockEosEntityListReg).close();
73 doNothing().when(mockEosDoubleEntityListReg).close();
74 doNothing().when(mockEntityCandReg).close();
75 doNothing().when(mockDoubleEntityCandReg).close();
76 doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
77 any(DOMClusterSingletonServiceProviderImpl.class));
78 doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
79 any(DOMClusterSingletonServiceProviderImpl.class));
80 doReturn(mockEntityCandReg).when(mockEos).registerCandidate(entity);
81 doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(doubleEntity);
83 clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(mockEos);
84 clusterSingletonServiceProvider.initializeProvider();
85 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
86 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
88 clusterSingletonService = new TestClusterSingletonServiceInstance();
89 clusterSingletonService2 = new TestClusterSingletonServiceInstance();
91 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
92 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
96 * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value
100 @Test(expected = NullPointerException.class)
101 public void initializationClusterSingletonServiceProviderNullInputTest() throws Exception {
102 clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(null);
106 * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}
111 public void closeClusterSingletonServiceProviderTest() throws Exception {
112 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
113 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
114 clusterSingletonServiceProvider.close();
115 verify(mockEosEntityListReg).close();
116 verify(mockEosDoubleEntityListReg).close();
120 * Test parser ServiceIdentifier from Entity
125 public void makeEntityClusterSingletonServiceProviderTest() throws Exception {
126 final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
127 Assert.assertEquals(entity, testEntity);
128 final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
130 Assert.assertEquals(doubleEntity, testDbEn);
134 * Test parser ServiceIdentifier from Entity
139 public void getIdentifierClusterSingletonServiceProviderTest() throws Exception {
140 final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(entity);
141 Assert.assertEquals(SERVICE_NAME, entityIdentifier);
142 final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(doubleEntity);
143 Assert.assertEquals(SERVICE_NAME, doubleEntityId);
147 * Test GoldPath for initialization {@link ClusterSingletonService}
152 public void initializationClusterSingletonServiceTest() throws Exception {
153 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
154 .registerClusterSingletonService(clusterSingletonService);
155 Assert.assertNotNull(reg);
156 verify(mockEos).registerCandidate(entity);
157 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
161 * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}
166 public void slaveInitClusterSingletonServiceTest() throws Exception {
167 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
168 .registerClusterSingletonService(clusterSingletonService);
169 Assert.assertNotNull(reg);
170 verify(mockEos).registerCandidate(entity);
171 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
172 verify(mockEos, never()).registerCandidate(doubleEntity);
173 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
177 * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}
182 public void slaveInitNoMasterClusterSingletonServiceTest() throws Exception {
183 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
184 .registerClusterSingletonService(clusterSingletonService);
185 Assert.assertNotNull(reg);
186 verify(mockEos).registerCandidate(entity);
187 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
188 verify(mockEos, never()).registerCandidate(doubleEntity);
189 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
193 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}
198 public void masterInitClusterSingletonServiceTest() throws Exception {
199 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
200 .registerClusterSingletonService(clusterSingletonService);
201 Assert.assertNotNull(reg);
202 verify(mockEos).registerCandidate(entity);
203 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
204 verify(mockEos).registerCandidate(doubleEntity);
205 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
209 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}
214 public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws Exception {
215 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
216 .registerClusterSingletonService(clusterSingletonService);
217 Assert.assertNotNull(reg);
218 verify(mockEos).registerCandidate(entity);
219 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
220 verify(mockEos).registerCandidate(doubleEntity);
221 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
222 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
226 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}
231 public void takeLeadershipClusterSingletonServiceTest() throws Exception {
232 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
233 .registerClusterSingletonService(clusterSingletonService);
234 Assert.assertNotNull(reg);
235 verify(mockEos).registerCandidate(entity);
236 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
237 verify(mockEos).registerCandidate(doubleEntity);
238 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
239 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
240 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
244 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}
249 public void masterInitClusterSingletonServiceTwoServicesTest() throws Exception {
250 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
251 .registerClusterSingletonService(clusterSingletonService);
252 Assert.assertNotNull(reg);
253 verify(mockEos).registerCandidate(entity);
254 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
255 verify(mockEos).registerCandidate(doubleEntity);
256 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
257 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
258 .registerClusterSingletonService(clusterSingletonService2);
259 Assert.assertNotNull(reg2);
260 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
264 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}
269 public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
270 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
271 .registerClusterSingletonService(clusterSingletonService);
272 Assert.assertNotNull(reg);
273 verify(mockEos).registerCandidate(entity);
274 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
275 verify(mockEos).registerCandidate(doubleEntity);
276 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
277 .registerClusterSingletonService(clusterSingletonService2);
278 Assert.assertNotNull(reg2);
279 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
280 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
281 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
282 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
283 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
287 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}
292 public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
293 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
294 .registerClusterSingletonService(clusterSingletonService);
295 Assert.assertNotNull(reg);
296 verify(mockEos).registerCandidate(entity);
297 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
298 verify(mockEos).registerCandidate(doubleEntity);
299 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
300 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
301 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
302 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
303 .registerClusterSingletonService(clusterSingletonService2);
304 Assert.assertNotNull(reg2);
305 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
309 * Test checks CandidateAlreadyRegisteredException processing in initialization phase
314 public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
315 doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(entity);
316 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
317 .registerClusterSingletonService(clusterSingletonService);
318 Assert.assertNull(reg);
322 * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
323 * {@link ClusterSingletonService}
328 public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
329 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
330 .registerClusterSingletonService(clusterSingletonService);
331 Assert.assertNotNull(reg);
332 verify(mockEos).registerCandidate(entity);
333 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
334 verify(mockEos).registerCandidate(doubleEntity);
335 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
336 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
337 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
338 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
339 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
343 * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}
348 public void lostLeadershipClusterSingletonServiceTest() throws Exception {
349 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
350 .registerClusterSingletonService(clusterSingletonService);
351 Assert.assertNotNull(reg);
352 verify(mockEos).registerCandidate(entity);
353 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
354 verify(mockEos).registerCandidate(doubleEntity);
355 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
356 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
357 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
358 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
359 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
360 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
361 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
365 * Test checks umexpected change for MASTER-TO-SLAVE double Candidate role change
370 public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
371 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
372 .registerClusterSingletonService(clusterSingletonService);
373 Assert.assertNotNull(reg);
374 verify(mockEos).registerCandidate(entity);
375 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
376 verify(mockEos).registerCandidate(doubleEntity);
377 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
378 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
379 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
380 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
381 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
382 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
383 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
384 verify(mockEosDoubleEntityListReg, never()).close();
385 verify(mockEntityCandReg, never()).close();
386 verify(mockDoubleEntityCandReg).close();
390 * Test checks inJeopardy Cluster Node state for Master Instance
395 public void inJeopardyMasterTest() throws Exception {
396 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
397 .registerClusterSingletonService(clusterSingletonService);
398 Assert.assertNotNull(reg);
399 verify(mockEos).registerCandidate(entity);
400 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
401 verify(mockEos).registerCandidate(doubleEntity);
402 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
403 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
404 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
405 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
406 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
407 clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
408 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
409 verify(mockEosEntityListReg, never()).close();
410 verify(mockEosDoubleEntityListReg, never()).close();
411 verify(mockEntityCandReg, never()).close();
412 verify(mockDoubleEntityCandReg).close();
416 * Test checks inJeopardy Cluster Node state for Slave Instance
421 public void inJeopardySlaveTest() throws Exception {
422 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
423 .registerClusterSingletonService(clusterSingletonService);
424 Assert.assertNotNull(reg);
425 verify(mockEos).registerCandidate(entity);
426 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
427 verify(mockEos, never()).registerCandidate(doubleEntity);
428 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
429 clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
430 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
431 verify(mockEosEntityListReg, never()).close();
432 verify(mockEosDoubleEntityListReg, never()).close();
433 verify(mockEntityCandReg, never()).close();
434 verify(mockDoubleEntityCandReg, never()).close();
438 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
443 public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
444 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
445 .registerClusterSingletonService(clusterSingletonService);
446 Assert.assertNotNull(reg);
447 verify(mockEos).registerCandidate(entity);
448 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
450 verify(mockEosEntityListReg, never()).close();
451 verify(mockEosDoubleEntityListReg, never()).close();
452 verify(mockEntityCandReg).close();
453 verify(mockDoubleEntityCandReg, never()).close();
454 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
458 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
463 public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
464 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
465 .registerClusterSingletonService(clusterSingletonService);
466 Assert.assertNotNull(reg);
467 verify(mockEos).registerCandidate(entity);
468 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
469 .registerClusterSingletonService(clusterSingletonService2);
470 Assert.assertNotNull(reg2);
471 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
472 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
474 verify(mockEosEntityListReg, never()).close();
475 verify(mockEosDoubleEntityListReg, never()).close();
476 verify(mockEntityCandReg, never()).close();
477 verify(mockDoubleEntityCandReg, never()).close();
478 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
479 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
483 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
488 public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
489 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
490 .registerClusterSingletonService(clusterSingletonService);
491 Assert.assertNotNull(reg);
492 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
493 verify(mockEos).registerCandidate(entity);
494 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
496 verify(mockEosEntityListReg, never()).close();
497 verify(mockEosDoubleEntityListReg, never()).close();
498 verify(mockEntityCandReg).close();
499 verify(mockDoubleEntityCandReg, never()).close();
500 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
504 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
509 public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
510 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
511 .registerClusterSingletonService(clusterSingletonService);
512 Assert.assertNotNull(reg);
513 verify(mockEos).registerCandidate(entity);
514 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
515 .registerClusterSingletonService(clusterSingletonService2);
516 Assert.assertNotNull(reg2);
517 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
518 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
519 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
521 verify(mockEosEntityListReg, never()).close();
522 verify(mockEosDoubleEntityListReg, never()).close();
523 verify(mockEntityCandReg, never()).close();
524 verify(mockDoubleEntityCandReg, never()).close();
525 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
526 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
530 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
535 public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
536 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
537 .registerClusterSingletonService(clusterSingletonService);
538 Assert.assertNotNull(reg);
539 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
540 verify(mockEos).registerCandidate(entity);
541 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
542 verify(mockEos).registerCandidate(doubleEntity);
543 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
544 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
546 verify(mockEosEntityListReg, never()).close();
547 verify(mockEosDoubleEntityListReg, never()).close();
548 verify(mockEntityCandReg).close();
549 verify(mockDoubleEntityCandReg).close();
550 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
554 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
559 public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
560 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
561 .registerClusterSingletonService(clusterSingletonService);
562 Assert.assertNotNull(reg);
563 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
564 .registerClusterSingletonService(clusterSingletonService2);
565 Assert.assertNotNull(reg2);
566 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
567 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
568 verify(mockEos).registerCandidate(entity);
569 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
570 verify(mockEos).registerCandidate(doubleEntity);
571 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
572 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
573 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
575 verify(mockEosEntityListReg, never()).close();
576 verify(mockEosDoubleEntityListReg, never()).close();
577 verify(mockEntityCandReg, never()).close();
578 verify(mockDoubleEntityCandReg, never()).close();
579 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
580 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
584 * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change
589 public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
590 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
591 .registerClusterSingletonService(clusterSingletonService);
592 Assert.assertNotNull(reg);
593 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
594 .registerClusterSingletonService(clusterSingletonService2);
595 Assert.assertNotNull(reg2);
596 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
597 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
598 verify(mockEos).registerCandidate(entity);
600 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
601 verify(mockEos).registerCandidate(doubleEntity);
602 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
603 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
604 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
605 verify(mockEosEntityListReg, never()).close();
606 verify(mockEosDoubleEntityListReg, never()).close();
607 verify(mockEntityCandReg, never()).close();
608 verify(mockDoubleEntityCandReg, never()).close();
609 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
610 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
613 private DOMEntityOwnershipChange getEntityToMaster() {
614 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, true, true));
617 private DOMEntityOwnershipChange getEntityToSlave() {
618 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(true, false, true));
621 private DOMEntityOwnershipChange getInitEntityToSlave() {
622 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, true));
625 private DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
626 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false));
629 private DOMEntityOwnershipChange getDoubleEntityToMaster() {
630 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, true, true));
633 private DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
634 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, false, true));
637 private DOMEntityOwnershipChange getDoubleEntityToSlave() {
638 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(true, false, true));
641 private DOMEntityOwnershipChange getEntityToJeopardy() {
642 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false), true);
646 * Base states for AbstractClusterProjectProvider
648 static enum TestClusterSingletonServiceState {
650 * State represents a correct Instantiated process
654 * State represents a correct call abstract method instantiatingProject
658 * State represents a correct call abstract method destryingProject
664 * Test implementation of {@link ClusterSingletonService}
666 class TestClusterSingletonServiceInstance implements ClusterSingletonService {
668 private final ServiceGroupIdentifier SERVICE_IDENT = ServiceGroupIdentifier.create(SERVICE_NAME);
669 private TestClusterSingletonServiceState serviceState;
671 public TestClusterSingletonServiceInstance() {
672 this.serviceState = TestClusterSingletonServiceState.INITIALIZED;
676 public void instantiateServiceInstance() {
677 this.serviceState = TestClusterSingletonServiceState.STARTED;
681 public ListenableFuture<Void> closeServiceInstance() {
682 this.serviceState = TestClusterSingletonServiceState.DESTROYED;
683 return Futures.immediateFuture(null);
686 public TestClusterSingletonServiceState getServiceState() {
691 public ServiceGroupIdentifier getIdentifier() {
692 return SERVICE_IDENT;