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.atLeastOnce;
14 import static org.mockito.Mockito.doNothing;
15 import static org.mockito.Mockito.doReturn;
16 import static org.mockito.Mockito.doThrow;
17 import static org.mockito.Mockito.never;
18 import static org.mockito.Mockito.verify;
20 import com.google.common.util.concurrent.Futures;
21 import com.google.common.util.concurrent.ListenableFuture;
22 import org.junit.Assert;
23 import org.junit.Before;
24 import org.junit.Test;
25 import org.mockito.Mock;
26 import org.mockito.MockitoAnnotations;
27 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
28 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
29 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
30 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
31 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
32 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
33 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
34 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
35 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
36 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
39 * Testing {@link DOMClusterSingletonServiceProviderImpl} implementation.
41 public class DOMClusterSingletonServiceProviderImplTest {
43 private static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
44 private static final String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
45 private static final String SERVICE_NAME = "testServiceName";
48 private DOMEntityOwnershipService mockEos;
50 private DOMEntityOwnershipCandidateRegistration mockEntityCandReg;
52 private DOMEntityOwnershipCandidateRegistration mockDoubleEntityCandReg;
54 private DOMEntityOwnershipListenerRegistration mockEosEntityListReg;
56 private DOMEntityOwnershipListenerRegistration mockEosDoubleEntityListReg;
58 private DOMClusterSingletonServiceProviderImpl clusterSingletonServiceProvider;
59 private TestClusterSingletonServiceInstance clusterSingletonService;
60 private TestClusterSingletonServiceInstance clusterSingletonService2;
62 private final DOMEntity entity = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
63 private final DOMEntity doubleEntity = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
66 * Initialization functionality for every Tests in this suite.
68 * @throws Exception if the condition does not meet
71 public void setup() throws Exception {
72 MockitoAnnotations.initMocks(this);
74 doNothing().when(mockEosEntityListReg).close();
75 doNothing().when(mockEosDoubleEntityListReg).close();
76 doNothing().when(mockEntityCandReg).close();
77 doNothing().when(mockDoubleEntityCandReg).close();
78 doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
79 any(DOMClusterSingletonServiceProviderImpl.class));
80 doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
81 any(DOMClusterSingletonServiceProviderImpl.class));
82 doReturn(mockEntityCandReg).when(mockEos).registerCandidate(entity);
83 doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(doubleEntity);
85 clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(mockEos);
86 clusterSingletonServiceProvider.initializeProvider();
87 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
88 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
90 clusterSingletonService = new TestClusterSingletonServiceInstance();
91 clusterSingletonService2 = new TestClusterSingletonServiceInstance();
93 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
94 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
98 * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
100 * @throws Exception if the condition does not meet
102 @Test(expected = NullPointerException.class)
103 public void initializationClusterSingletonServiceProviderNullInputTest() throws Exception {
104 clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(null);
108 * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}.
110 * @throws Exception if the condition does not meet
113 public void closeClusterSingletonServiceProviderTest() throws Exception {
114 verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
115 verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
116 clusterSingletonServiceProvider.close();
117 verify(mockEosEntityListReg).close();
118 verify(mockEosDoubleEntityListReg).close();
122 * Test parser ServiceIdentifier from Entity.
124 * @throws Exception if the condition does not meet
127 public void makeEntityClusterSingletonServiceProviderTest() throws Exception {
128 final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
129 Assert.assertEquals(entity, testEntity);
130 final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
132 Assert.assertEquals(doubleEntity, testDbEn);
136 * Test parser ServiceIdentifier from Entity.
138 * @throws Exception if the condition does not meet
141 public void getIdentifierClusterSingletonServiceProviderTest() throws Exception {
142 final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(entity);
143 Assert.assertEquals(SERVICE_NAME, entityIdentifier);
144 final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(doubleEntity);
145 Assert.assertEquals(SERVICE_NAME, doubleEntityId);
149 * Test GoldPath for initialization {@link ClusterSingletonService}.
151 * @throws Exception if the condition does not meet
154 public void initializationClusterSingletonServiceTest() throws Exception {
155 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
156 .registerClusterSingletonService(clusterSingletonService);
157 Assert.assertNotNull(reg);
158 verify(mockEos).registerCandidate(entity);
159 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
163 * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
165 * @throws Exception if the condition does not meet
168 public void slaveInitClusterSingletonServiceTest() throws Exception {
169 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
170 .registerClusterSingletonService(clusterSingletonService);
171 Assert.assertNotNull(reg);
172 verify(mockEos).registerCandidate(entity);
173 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
174 verify(mockEos, never()).registerCandidate(doubleEntity);
175 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
179 * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
181 * @throws Exception if the condition does not meet
184 public void slaveInitNoMasterClusterSingletonServiceTest() throws Exception {
185 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
186 .registerClusterSingletonService(clusterSingletonService);
187 Assert.assertNotNull(reg);
188 verify(mockEos).registerCandidate(entity);
189 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
190 verify(mockEos, never()).registerCandidate(doubleEntity);
191 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
195 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
197 * @throws Exception if the condition does not meet
200 public void masterInitClusterSingletonServiceTest() throws Exception {
201 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
202 .registerClusterSingletonService(clusterSingletonService);
203 Assert.assertNotNull(reg);
204 verify(mockEos).registerCandidate(entity);
205 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
206 verify(mockEos).registerCandidate(doubleEntity);
207 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
211 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
213 * @throws Exception if the condition does not meet
216 public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws Exception {
217 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
218 .registerClusterSingletonService(clusterSingletonService);
219 Assert.assertNotNull(reg);
220 verify(mockEos).registerCandidate(entity);
221 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
222 verify(mockEos).registerCandidate(doubleEntity);
223 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
224 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
228 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
230 * @throws Exception if the condition does not meet
233 public void takeLeadershipClusterSingletonServiceTest() throws Exception {
234 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
235 .registerClusterSingletonService(clusterSingletonService);
236 Assert.assertNotNull(reg);
237 verify(mockEos).registerCandidate(entity);
238 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
239 verify(mockEos).registerCandidate(doubleEntity);
240 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
241 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
242 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
246 * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
248 * @throws Exception if the condition does not meet
251 public void masterInitClusterSingletonServiceTwoServicesTest() throws Exception {
252 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
253 .registerClusterSingletonService(clusterSingletonService);
254 Assert.assertNotNull(reg);
255 verify(mockEos).registerCandidate(entity);
256 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
257 verify(mockEos).registerCandidate(doubleEntity);
258 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
259 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
260 .registerClusterSingletonService(clusterSingletonService2);
261 Assert.assertNotNull(reg2);
262 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
266 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
268 * @throws Exception if the condition does not meet
271 public void takeDoubleLeadershipClusterSingletonServiceTest() throws Exception {
272 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
273 .registerClusterSingletonService(clusterSingletonService);
274 Assert.assertNotNull(reg);
275 verify(mockEos).registerCandidate(entity);
276 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
277 verify(mockEos).registerCandidate(doubleEntity);
278 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
279 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
280 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
281 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
282 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
283 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
284 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
285 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
286 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
287 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
288 verify(mockEosDoubleEntityListReg, never()).close();
289 verify(mockEosEntityListReg, never()).close();
290 verify(mockEntityCandReg, never()).close();
291 verify(mockDoubleEntityCandReg).close();
295 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
297 * @throws Exception if the condition does not meet
300 public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
301 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
302 .registerClusterSingletonService(clusterSingletonService);
303 Assert.assertNotNull(reg);
304 verify(mockEos).registerCandidate(entity);
305 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
306 verify(mockEos).registerCandidate(doubleEntity);
307 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
308 .registerClusterSingletonService(clusterSingletonService2);
309 Assert.assertNotNull(reg2);
310 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
311 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
312 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
313 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
314 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
318 * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
320 * @throws Exception if the condition does not meet
323 public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
324 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
325 .registerClusterSingletonService(clusterSingletonService);
326 Assert.assertNotNull(reg);
327 verify(mockEos).registerCandidate(entity);
328 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
329 verify(mockEos).registerCandidate(doubleEntity);
330 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
331 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
332 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
333 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
334 .registerClusterSingletonService(clusterSingletonService2);
335 Assert.assertNotNull(reg2);
336 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
340 * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
342 * @throws Exception if the condition does not meet
344 @Test(expected = RuntimeException.class)
345 public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
346 doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(entity);
347 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
348 .registerClusterSingletonService(clusterSingletonService);
349 Assert.assertNull(reg);
353 * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
354 * {@link ClusterSingletonService}.
356 * @throws Exception if the condition does not meet
359 public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
360 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
361 .registerClusterSingletonService(clusterSingletonService);
362 Assert.assertNotNull(reg);
363 verify(mockEos).registerCandidate(entity);
364 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
365 verify(mockEos).registerCandidate(doubleEntity);
366 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
367 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
368 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
369 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
370 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
374 * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
376 * @throws Exception if the condition does not meet
379 public void lostLeadershipClusterSingletonServiceTest() throws Exception {
380 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
381 .registerClusterSingletonService(clusterSingletonService);
382 Assert.assertNotNull(reg);
383 verify(mockEos).registerCandidate(entity);
384 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
385 verify(mockEos).registerCandidate(doubleEntity);
386 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
387 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
388 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
389 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
390 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
391 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
392 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
396 * Test checks unexpected change for MASTER-TO-SLAVE double Candidate role change.
398 * @throws Exception if the condition does not meet
401 public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
402 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
403 .registerClusterSingletonService(clusterSingletonService);
404 Assert.assertNotNull(reg);
405 verify(mockEos).registerCandidate(entity);
406 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
407 verify(mockEos).registerCandidate(doubleEntity);
408 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
409 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
410 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
411 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
412 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
413 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
414 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
415 verify(mockEosDoubleEntityListReg, never()).close();
416 verify(mockEntityCandReg, never()).close();
417 verify(mockDoubleEntityCandReg, never()).close();
419 verify(mockEosEntityListReg, never()).close();
420 verify(mockEosDoubleEntityListReg, never()).close();
421 verify(mockEntityCandReg, atLeastOnce()).close();
422 verify(mockDoubleEntityCandReg, never()).close();
423 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
424 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
425 verify(mockEntityCandReg, atLeastOnce()).close();
426 verify(mockDoubleEntityCandReg, atLeastOnce()).close();
427 verify(mockEosDoubleEntityListReg, never()).close();
428 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
432 * Test checks inJeopardy Cluster Node state for Master Instance.
434 * @throws Exception if the condition does not meet
437 public void inJeopardyMasterTest() throws Exception {
438 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
439 .registerClusterSingletonService(clusterSingletonService);
440 Assert.assertNotNull(reg);
441 verify(mockEos).registerCandidate(entity);
442 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
443 verify(mockEos).registerCandidate(doubleEntity);
444 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
445 clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
446 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
447 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
448 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
449 clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
450 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
451 verify(mockEosEntityListReg, never()).close();
452 verify(mockEosDoubleEntityListReg, never()).close();
453 verify(mockEntityCandReg, never()).close();
454 verify(mockDoubleEntityCandReg).close();
458 * Test checks inJeopardy Cluster Node state for Slave Instance.
460 * @throws Exception if the condition does not meet
463 public void inJeopardySlaveTest() throws Exception {
464 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
465 .registerClusterSingletonService(clusterSingletonService);
466 Assert.assertNotNull(reg);
467 verify(mockEos).registerCandidate(entity);
468 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
469 verify(mockEos, never()).registerCandidate(doubleEntity);
470 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
471 clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
472 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
473 verify(mockEosEntityListReg, never()).close();
474 verify(mockEosDoubleEntityListReg, never()).close();
475 verify(mockEntityCandReg, never()).close();
476 verify(mockDoubleEntityCandReg, never()).close();
480 * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
482 * @throws Exception if the condition does not meet
485 public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
486 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
487 .registerClusterSingletonService(clusterSingletonService);
488 Assert.assertNotNull(reg);
489 verify(mockEos).registerCandidate(entity);
490 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
492 verify(mockEosEntityListReg, never()).close();
493 verify(mockEosDoubleEntityListReg, never()).close();
494 verify(mockEntityCandReg).close();
495 verify(mockDoubleEntityCandReg, never()).close();
496 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
500 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
502 * @throws Exception if the condition does not meet
505 public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
506 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
507 .registerClusterSingletonService(clusterSingletonService);
508 Assert.assertNotNull(reg);
509 verify(mockEos).registerCandidate(entity);
510 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
511 .registerClusterSingletonService(clusterSingletonService2);
512 Assert.assertNotNull(reg2);
513 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
514 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
516 verify(mockEosEntityListReg, never()).close();
517 verify(mockEosDoubleEntityListReg, never()).close();
518 verify(mockEntityCandReg, never()).close();
519 verify(mockDoubleEntityCandReg, never()).close();
520 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
521 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
525 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
527 * @throws Exception if the condition does not meet
530 public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
531 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
532 .registerClusterSingletonService(clusterSingletonService);
533 Assert.assertNotNull(reg);
534 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
535 verify(mockEos).registerCandidate(entity);
536 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
538 verify(mockEosEntityListReg, never()).close();
539 verify(mockEosDoubleEntityListReg, never()).close();
540 verify(mockEntityCandReg).close();
541 verify(mockDoubleEntityCandReg, never()).close();
542 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
546 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
548 * @throws Exception if the condition does not meet
551 public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
552 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
553 .registerClusterSingletonService(clusterSingletonService);
554 Assert.assertNotNull(reg);
555 verify(mockEos).registerCandidate(entity);
556 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
557 .registerClusterSingletonService(clusterSingletonService2);
558 Assert.assertNotNull(reg2);
559 clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
560 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
561 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
563 verify(mockEosEntityListReg, never()).close();
564 verify(mockEosDoubleEntityListReg, never()).close();
565 verify(mockEntityCandReg, never()).close();
566 verify(mockDoubleEntityCandReg, never()).close();
567 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
568 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
572 * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
574 * @throws Exception if the condition does not meet
577 public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
578 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
579 .registerClusterSingletonService(clusterSingletonService);
580 Assert.assertNotNull(reg);
581 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
582 verify(mockEos).registerCandidate(entity);
583 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
584 verify(mockEos).registerCandidate(doubleEntity);
585 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
586 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
588 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
589 verify(mockEosEntityListReg, never()).close();
590 verify(mockEosDoubleEntityListReg, never()).close();
591 verify(mockEntityCandReg).close();
592 verify(mockDoubleEntityCandReg).close();
593 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
597 * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
599 * @throws Exception if the condition does not meet
602 public void closeClusterSingletonServiceRegistrationMasterCloseWithNotificationTimesTest() throws Exception {
603 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
604 .registerClusterSingletonService(clusterSingletonService);
605 Assert.assertNotNull(reg);
606 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
607 verify(mockEos).registerCandidate(entity);
608 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
609 verify(mockEos).registerCandidate(doubleEntity);
610 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
611 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
613 verify(mockEosEntityListReg, never()).close();
614 verify(mockEosDoubleEntityListReg, never()).close();
615 verify(mockEntityCandReg, atLeastOnce()).close();
616 verify(mockDoubleEntityCandReg, never()).close();
617 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
618 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
619 verify(mockEntityCandReg, atLeastOnce()).close();
620 verify(mockDoubleEntityCandReg, atLeastOnce()).close();
621 verify(mockEosDoubleEntityListReg, never()).close();
622 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
626 * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
628 * @throws Exception if the condition does not meet
631 public void closeClusterSingletonServiceRegistrationMasterCloseCoupleTimesTest() throws Exception {
632 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
633 .registerClusterSingletonService(clusterSingletonService);
634 Assert.assertNotNull(reg);
635 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
636 verify(mockEos).registerCandidate(entity);
637 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
638 verify(mockEos).registerCandidate(doubleEntity);
639 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
640 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
643 verify(mockEosEntityListReg, never()).close();
644 verify(mockEosDoubleEntityListReg, never()).close();
645 verify(mockEntityCandReg, atLeastOnce()).close();
646 verify(mockDoubleEntityCandReg, never()).close();
647 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
648 clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
649 verify(mockEntityCandReg, atLeastOnce()).close();
650 verify(mockDoubleEntityCandReg, atLeastOnce()).close();
651 verify(mockEosDoubleEntityListReg, never()).close();
652 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
656 * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
658 * @throws Exception if the condition does not meet
661 public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
662 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
663 .registerClusterSingletonService(clusterSingletonService);
664 Assert.assertNotNull(reg);
665 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
666 .registerClusterSingletonService(clusterSingletonService2);
667 Assert.assertNotNull(reg2);
668 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
669 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
670 verify(mockEos).registerCandidate(entity);
671 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
672 verify(mockEos).registerCandidate(doubleEntity);
673 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
674 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
675 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
677 verify(mockEosEntityListReg, never()).close();
678 verify(mockEosDoubleEntityListReg, never()).close();
679 verify(mockEntityCandReg, never()).close();
680 verify(mockDoubleEntityCandReg, never()).close();
681 Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
682 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
686 * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
688 * @throws Exception if the condition does not meet
691 public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
692 final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
693 .registerClusterSingletonService(clusterSingletonService);
694 Assert.assertNotNull(reg);
695 final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
696 .registerClusterSingletonService(clusterSingletonService2);
697 Assert.assertNotNull(reg2);
698 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
699 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
700 verify(mockEos).registerCandidate(entity);
702 clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
703 verify(mockEos).registerCandidate(doubleEntity);
704 clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
705 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
706 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
707 verify(mockEosEntityListReg, never()).close();
708 verify(mockEosDoubleEntityListReg, never()).close();
709 verify(mockEntityCandReg, never()).close();
710 verify(mockDoubleEntityCandReg, never()).close();
711 Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
712 Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
715 private DOMEntityOwnershipChange getEntityToMaster() {
716 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, true, true));
719 private DOMEntityOwnershipChange getEntityToSlave() {
720 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(true, false, true));
723 private DOMEntityOwnershipChange getInitEntityToSlave() {
724 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, true));
727 private DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
728 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false));
731 private DOMEntityOwnershipChange getDoubleEntityToMaster() {
732 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, true, true));
735 private DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
736 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, false, true));
739 private DOMEntityOwnershipChange getDoubleEntityToSlave() {
740 return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(true, false, true));
743 private DOMEntityOwnershipChange getEntityToJeopardy() {
744 return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false), true);
748 * Base states for AbstractClusterProjectProvider.
750 enum TestClusterSingletonServiceState {
753 * State represents a correct Instantiated process.
758 * State represents a correct call abstract method instantiatingProject.
763 * State represents a correct call abstract method destryingProject.
769 * Test implementation of {@link ClusterSingletonService}.
771 class TestClusterSingletonServiceInstance implements ClusterSingletonService {
773 private final ServiceGroupIdentifier serviceIndent = ServiceGroupIdentifier.create(SERVICE_NAME);
774 private TestClusterSingletonServiceState serviceState;
776 TestClusterSingletonServiceInstance() {
777 this.serviceState = TestClusterSingletonServiceState.INITIALIZED;
781 public void instantiateServiceInstance() {
782 this.serviceState = TestClusterSingletonServiceState.STARTED;
786 public ListenableFuture<Void> closeServiceInstance() {
787 this.serviceState = TestClusterSingletonServiceState.DESTROYED;
788 return Futures.immediateFuture(null);
791 public TestClusterSingletonServiceState getServiceState() {
796 public ServiceGroupIdentifier getIdentifier() {
797 return serviceIndent;