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;
19 import com.google.common.util.concurrent.Futures;
20 import com.google.common.util.concurrent.ListenableFuture;
21 import org.junit.Assert;
22 import org.junit.Before;
23 import org.junit.Test;
24 import org.mockito.Mock;
25 import org.mockito.MockitoAnnotations;
26 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
27 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
28 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
29 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
30 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
31 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
32 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
33 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
34 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
35 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
38 * Testing {@link DOMClusterSingletonServiceProviderImpl} implementation.
40 public class DOMClusterSingletonServiceProviderImplTest {
42 private static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
43 private static final String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
44 private static final String SERVICE_NAME = "testServiceName";
47 private DOMEntityOwnershipService mockEos;
49 private DOMEntityOwnershipCandidateRegistration mockEntityCandReg;
51 private DOMEntityOwnershipCandidateRegistration mockDoubleEntityCandReg;
53 private DOMEntityOwnershipListenerRegistration mockEosEntityListReg;
55 private DOMEntityOwnershipListenerRegistration mockEosDoubleEntityListReg;
57 private DOMClusterSingletonServiceProviderImpl clusterSingletonServiceProvider;
58 private TestClusterSingletonServiceInstance clusterSingletonService;
59 private TestClusterSingletonServiceInstance clusterSingletonService2;
61 private final DOMEntity entity = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
62 private final DOMEntity doubleEntity = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
65 * Initialization functionality for every Tests in this suite.
67 * @throws Exception if the condition does not meet
70 public void setup() throws Exception {
71 MockitoAnnotations.initMocks(this);
73 doNothing().when(mockEosEntityListReg).close();
74 doNothing().when(mockEosDoubleEntityListReg).close();
75 doNothing().when(mockEntityCandReg).close();
76 doNothing().when(mockDoubleEntityCandReg).close();
77 doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
78 any(DOMClusterSingletonServiceProviderImpl.class));
79 doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
80 any(DOMClusterSingletonServiceProviderImpl.class));
81 doReturn(mockEntityCandReg).when(mockEos).registerCandidate(entity);
82 doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(doubleEntity);
84 clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(mockEos);
85 clusterSingletonServiceProvider.initializeProvider();
86 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
87 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
89 clusterSingletonService = new TestClusterSingletonServiceInstance();
90 clusterSingletonService2 = new TestClusterSingletonServiceInstance();
92 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
93 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
97 * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
99 * @throws Exception if the condition does not meet
101 @Test(expected = NullPointerException.class)
102 public void initializationClusterSingletonServiceProviderNullInputTest() throws Exception {
103 clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(null);
107 * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}.
109 * @throws Exception if the condition does not meet
112 public void closeClusterSingletonServiceProviderTest() throws Exception {
113 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
114 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
115 clusterSingletonServiceProvider.close();
116 verify(mockEosEntityListReg).close();
117 verify(mockEosDoubleEntityListReg).close();
121 * Test parser ServiceIdentifier from Entity.
123 * @throws Exception if the condition does not meet
126 public void makeEntityClusterSingletonServiceProviderTest() throws Exception {
127 final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
128 Assert.assertEquals(entity, testEntity);
129 final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
131 Assert.assertEquals(doubleEntity, testDbEn);
135 * Test parser ServiceIdentifier from Entity.
137 * @throws Exception if the condition does not meet
140 public void getIdentifierClusterSingletonServiceProviderTest() throws Exception {
141 final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(entity);
142 Assert.assertEquals(SERVICE_NAME, entityIdentifier);
143 final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(doubleEntity);
144 Assert.assertEquals(SERVICE_NAME, doubleEntityId);
148 * Test GoldPath for initialization {@link ClusterSingletonService}.
150 * @throws Exception if the condition does not meet
153 public void initializationClusterSingletonServiceTest() throws Exception {
154 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
155 .registerClusterSingletonService(clusterSingletonService);
156 Assert.assertNotNull(reg);
157 verify(mockEos).registerCandidate(entity);
158 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
162 * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
164 * @throws Exception if the condition does not meet
167 public void slaveInitClusterSingletonServiceTest() throws Exception {
168 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
169 .registerClusterSingletonService(clusterSingletonService);
170 Assert.assertNotNull(reg);
171 verify(mockEos).registerCandidate(entity);
172 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
173 verify(mockEos, never()).registerCandidate(doubleEntity);
174 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
178 * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
180 * @throws Exception if the condition does not meet
183 public void slaveInitNoMasterClusterSingletonServiceTest() throws Exception {
184 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
185 .registerClusterSingletonService(clusterSingletonService);
186 Assert.assertNotNull(reg);
187 verify(mockEos).registerCandidate(entity);
188 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
189 verify(mockEos, never()).registerCandidate(doubleEntity);
190 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
194 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
196 * @throws Exception if the condition does not meet
199 public void masterInitClusterSingletonServiceTest() throws Exception {
200 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
201 .registerClusterSingletonService(clusterSingletonService);
202 Assert.assertNotNull(reg);
203 verify(mockEos).registerCandidate(entity);
204 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
205 verify(mockEos).registerCandidate(doubleEntity);
206 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
210 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
212 * @throws Exception if the condition does not meet
215 public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws Exception {
216 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
217 .registerClusterSingletonService(clusterSingletonService);
218 Assert.assertNotNull(reg);
219 verify(mockEos).registerCandidate(entity);
220 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
221 verify(mockEos).registerCandidate(doubleEntity);
222 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
223 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
227 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
229 * @throws Exception if the condition does not meet
232 public void takeLeadershipClusterSingletonServiceTest() throws Exception {
233 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
234 .registerClusterSingletonService(clusterSingletonService);
235 Assert.assertNotNull(reg);
236 verify(mockEos).registerCandidate(entity);
237 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
238 verify(mockEos).registerCandidate(doubleEntity);
239 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
240 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
241 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
245 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
247 * @throws Exception if the condition does not meet
250 public void masterInitClusterSingletonServiceTwoServicesTest() throws Exception {
251 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
252 .registerClusterSingletonService(clusterSingletonService);
253 Assert.assertNotNull(reg);
254 verify(mockEos).registerCandidate(entity);
255 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
256 verify(mockEos).registerCandidate(doubleEntity);
257 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
258 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
259 .registerClusterSingletonService(clusterSingletonService2);
260 Assert.assertNotNull(reg2);
261 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
265 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
267 * @throws Exception if the condition does not meet
270 public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
271 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
272 .registerClusterSingletonService(clusterSingletonService);
273 Assert.assertNotNull(reg);
274 verify(mockEos).registerCandidate(entity);
275 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
276 verify(mockEos).registerCandidate(doubleEntity);
277 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
278 .registerClusterSingletonService(clusterSingletonService2);
279 Assert.assertNotNull(reg2);
280 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
281 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
282 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
283 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
284 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
288 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
290 * @throws Exception if the condition does not meet
293 public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
294 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
295 .registerClusterSingletonService(clusterSingletonService);
296 Assert.assertNotNull(reg);
297 verify(mockEos).registerCandidate(entity);
298 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
299 verify(mockEos).registerCandidate(doubleEntity);
300 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
301 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
302 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
303 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
304 .registerClusterSingletonService(clusterSingletonService2);
305 Assert.assertNotNull(reg2);
306 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
310 * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
312 * @throws Exception if the condition does not meet
315 public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
316 doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(entity);
317 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
318 .registerClusterSingletonService(clusterSingletonService);
319 Assert.assertNull(reg);
323 * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
324 * {@link ClusterSingletonService}.
326 * @throws Exception if the condition does not meet
329 public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
330 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
331 .registerClusterSingletonService(clusterSingletonService);
332 Assert.assertNotNull(reg);
333 verify(mockEos).registerCandidate(entity);
334 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
335 verify(mockEos).registerCandidate(doubleEntity);
336 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
337 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
338 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
339 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
340 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
344 * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
346 * @throws Exception if the condition does not meet
349 public void lostLeadershipClusterSingletonServiceTest() throws Exception {
350 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
351 .registerClusterSingletonService(clusterSingletonService);
352 Assert.assertNotNull(reg);
353 verify(mockEos).registerCandidate(entity);
354 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
355 verify(mockEos).registerCandidate(doubleEntity);
356 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
357 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
358 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
359 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
360 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
361 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
362 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
366 * Test checks umexpected change for MASTER-TO-SLAVE double Candidate role change.
368 * @throws Exception if the condition does not meet
371 public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
372 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
373 .registerClusterSingletonService(clusterSingletonService);
374 Assert.assertNotNull(reg);
375 verify(mockEos).registerCandidate(entity);
376 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
377 verify(mockEos).registerCandidate(doubleEntity);
378 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
379 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
380 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
381 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
382 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
383 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
384 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
385 verify(mockEosDoubleEntityListReg, never()).close();
386 verify(mockEntityCandReg, never()).close();
387 verify(mockDoubleEntityCandReg).close();
391 * Test checks inJeopardy Cluster Node state for Master Instance.
393 * @throws Exception if the condition does not meet
396 public void inJeopardyMasterTest() throws Exception {
397 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
398 .registerClusterSingletonService(clusterSingletonService);
399 Assert.assertNotNull(reg);
400 verify(mockEos).registerCandidate(entity);
401 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
402 verify(mockEos).registerCandidate(doubleEntity);
403 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
404 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
405 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
406 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
407 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
408 clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
409 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
410 verify(mockEosEntityListReg, never()).close();
411 verify(mockEosDoubleEntityListReg, never()).close();
412 verify(mockEntityCandReg, never()).close();
413 verify(mockDoubleEntityCandReg).close();
417 * Test checks inJeopardy Cluster Node state for Slave Instance.
419 * @throws Exception if the condition does not meet
422 public void inJeopardySlaveTest() throws Exception {
423 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
424 .registerClusterSingletonService(clusterSingletonService);
425 Assert.assertNotNull(reg);
426 verify(mockEos).registerCandidate(entity);
427 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
428 verify(mockEos, never()).registerCandidate(doubleEntity);
429 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
430 clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
431 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
432 verify(mockEosEntityListReg, never()).close();
433 verify(mockEosDoubleEntityListReg, never()).close();
434 verify(mockEntityCandReg, never()).close();
435 verify(mockDoubleEntityCandReg, never()).close();
439 * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
441 * @throws Exception if the condition does not meet
444 public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
445 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
446 .registerClusterSingletonService(clusterSingletonService);
447 Assert.assertNotNull(reg);
448 verify(mockEos).registerCandidate(entity);
449 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
451 verify(mockEosEntityListReg, never()).close();
452 verify(mockEosDoubleEntityListReg, never()).close();
453 verify(mockEntityCandReg).close();
454 verify(mockDoubleEntityCandReg, never()).close();
455 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
459 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
461 * @throws Exception if the condition does not meet
464 public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
465 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
466 .registerClusterSingletonService(clusterSingletonService);
467 Assert.assertNotNull(reg);
468 verify(mockEos).registerCandidate(entity);
469 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
470 .registerClusterSingletonService(clusterSingletonService2);
471 Assert.assertNotNull(reg2);
472 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
473 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
475 verify(mockEosEntityListReg, never()).close();
476 verify(mockEosDoubleEntityListReg, never()).close();
477 verify(mockEntityCandReg, never()).close();
478 verify(mockDoubleEntityCandReg, never()).close();
479 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
480 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
484 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
486 * @throws Exception if the condition does not meet
489 public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
490 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
491 .registerClusterSingletonService(clusterSingletonService);
492 Assert.assertNotNull(reg);
493 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
494 verify(mockEos).registerCandidate(entity);
495 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
497 verify(mockEosEntityListReg, never()).close();
498 verify(mockEosDoubleEntityListReg, never()).close();
499 verify(mockEntityCandReg).close();
500 verify(mockDoubleEntityCandReg, never()).close();
501 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
505 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
507 * @throws Exception if the condition does not meet
510 public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
511 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
512 .registerClusterSingletonService(clusterSingletonService);
513 Assert.assertNotNull(reg);
514 verify(mockEos).registerCandidate(entity);
515 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
516 .registerClusterSingletonService(clusterSingletonService2);
517 Assert.assertNotNull(reg2);
518 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
519 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
520 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
522 verify(mockEosEntityListReg, never()).close();
523 verify(mockEosDoubleEntityListReg, never()).close();
524 verify(mockEntityCandReg, never()).close();
525 verify(mockDoubleEntityCandReg, never()).close();
526 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
527 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
531 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
533 * @throws Exception if the condition does not meet
536 public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
537 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
538 .registerClusterSingletonService(clusterSingletonService);
539 Assert.assertNotNull(reg);
540 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
541 verify(mockEos).registerCandidate(entity);
542 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
543 verify(mockEos).registerCandidate(doubleEntity);
544 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
545 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
547 verify(mockEosEntityListReg, never()).close();
548 verify(mockEosDoubleEntityListReg, never()).close();
549 verify(mockEntityCandReg).close();
550 verify(mockDoubleEntityCandReg).close();
551 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
555 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
557 * @throws Exception if the condition does not meet
560 public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
561 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
562 .registerClusterSingletonService(clusterSingletonService);
563 Assert.assertNotNull(reg);
564 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
565 .registerClusterSingletonService(clusterSingletonService2);
566 Assert.assertNotNull(reg2);
567 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
568 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
569 verify(mockEos).registerCandidate(entity);
570 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
571 verify(mockEos).registerCandidate(doubleEntity);
572 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
573 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
574 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
576 verify(mockEosEntityListReg, never()).close();
577 verify(mockEosDoubleEntityListReg, never()).close();
578 verify(mockEntityCandReg, never()).close();
579 verify(mockDoubleEntityCandReg, never()).close();
580 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
581 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
585 * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
587 * @throws Exception if the condition does not meet
590 public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
591 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
592 .registerClusterSingletonService(clusterSingletonService);
593 Assert.assertNotNull(reg);
594 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
595 .registerClusterSingletonService(clusterSingletonService2);
596 Assert.assertNotNull(reg2);
597 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
598 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
599 verify(mockEos).registerCandidate(entity);
601 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
602 verify(mockEos).registerCandidate(doubleEntity);
603 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
604 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
605 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
606 verify(mockEosEntityListReg, never()).close();
607 verify(mockEosDoubleEntityListReg, never()).close();
608 verify(mockEntityCandReg, never()).close();
609 verify(mockDoubleEntityCandReg, never()).close();
610 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
611 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
614 private DOMEntityOwnershipChange getEntityToMaster() {
615 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, true, true));
618 private DOMEntityOwnershipChange getEntityToSlave() {
619 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(true, false, true));
622 private DOMEntityOwnershipChange getInitEntityToSlave() {
623 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, true));
626 private DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
627 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false));
630 private DOMEntityOwnershipChange getDoubleEntityToMaster() {
631 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, true, true));
634 private DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
635 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, false, true));
638 private DOMEntityOwnershipChange getDoubleEntityToSlave() {
639 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(true, false, true));
642 private DOMEntityOwnershipChange getEntityToJeopardy() {
643 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false), true);
647 * Base states for AbstractClusterProjectProvider.
649 enum TestClusterSingletonServiceState {
651 * State represents a correct Instantiated process.
655 * State represents a correct call abstract method instantiatingProject.
659 * State represents a correct call abstract method destryingProject.
665 * Test implementation of {@link ClusterSingletonService}.
667 class TestClusterSingletonServiceInstance implements ClusterSingletonService {
669 private final ServiceGroupIdentifier serviceIndent = ServiceGroupIdentifier.create(SERVICE_NAME);
670 private TestClusterSingletonServiceState serviceState;
672 TestClusterSingletonServiceInstance() {
673 this.serviceState = TestClusterSingletonServiceState.INITIALIZED;
677 public void instantiateServiceInstance() {
678 this.serviceState = TestClusterSingletonServiceState.STARTED;
682 public ListenableFuture<Void> closeServiceInstance() {
683 this.serviceState = TestClusterSingletonServiceState.DESTROYED;
684 return Futures.immediateFuture(null);
687 public TestClusterSingletonServiceState getServiceState() {
692 public ServiceGroupIdentifier getIdentifier() {
693 return serviceIndent;