dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/ShardedDOMDataTreeProducerMultiShardTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.mdsal.dom.broker;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.ArgumentMatchers.anyCollection;
  14 import static org.mockito.ArgumentMatchers.anyMap;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.inOrder;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.timeout;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.verifyNoMoreInteractions;
  22
  23 import com.google.common.collect.Iterables;
  24 import com.google.common.util.concurrent.Futures;
  25 import java.util.Collection;
  26 import java.util.Collections;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.concurrent.ExecutorService;
  30 import java.util.concurrent.Executors;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.ArgumentCaptor;
  34 import org.mockito.Captor;
  35 import org.mockito.InOrder;
  36 import org.mockito.MockitoAnnotations;
  37 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  38 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
  39 import org.opendaylight.mdsal.dom.api.DOMDataTreeListener;
  40 import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
  41 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
  42 import org.opendaylight.mdsal.dom.broker.util.TestModel;
  43 import org.opendaylight.mdsal.dom.spi.shard.DOMDataTreeShardProducer;
  44 import org.opendaylight.mdsal.dom.spi.shard.DOMDataTreeShardWriteTransaction;
  45 import org.opendaylight.mdsal.dom.spi.shard.WriteableDOMDataTreeShard;
  46 import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataTreeShard;
  47 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  51 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  52 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  53 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  54 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
  55 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
  56 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  57 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
  58 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  59
  60 public class ShardedDOMDataTreeProducerMultiShardTest {
  61
  62     private static final SchemaContext SCHEMA_CONTEXT = TestModel.createTestContext();
  63
  64     private static final DOMDataTreeIdentifier ROOT_ID =
  65             new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
  66     private static final DOMDataTreeIdentifier TEST_ID =
  67             new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, TestModel.TEST_PATH);
  68
  69     private static final DOMDataTreeIdentifier TEST2_ID =
  70             new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, TestModel.TEST2_PATH);
  71
  72     private static final DOMDataTreeIdentifier INNER_CONTAINER_ID =
  73             new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, TestModel.INNER_CONTAINER_PATH);
  74     private static final DOMDataTreeIdentifier ANOTHER_SHARD_ID =
  75             new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, TestModel.ANOTHER_SHARD_PATH);
  76
  77     private InMemoryDOMDataTreeShard rootShard;
  78     private InMemoryDOMDataTreeShard anotherInnerShard;
  79
  80     private ShardedDOMDataTree dataTreeService;
  81     private ListenerRegistration<InMemoryDOMDataTreeShard> rootShardReg;
  82     private ListenerRegistration<InMemoryDOMDataTreeShard> innerShardReg;
  83
  84     private final ExecutorService executor = Executors.newSingleThreadExecutor();
  85
  86     @Captor
  87     private ArgumentCaptor<Collection<DataTreeCandidate>> captorForChanges;
  88     @Captor
  89     private ArgumentCaptor<Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>>> captorForSubtrees;
  90
  91     private final ContainerNode crossShardContainer = createCrossShardContainer();
  92
  93     @Before
  94     public void setUp() throws Exception {
  95         MockitoAnnotations.initMocks(this);
  96
  97         rootShard = InMemoryDOMDataTreeShard.create(ROOT_ID, executor, 1);
  98         rootShard.onGlobalContextUpdated(SCHEMA_CONTEXT);
  99
 100         final ShardedDOMDataTree dataTree = new ShardedDOMDataTree();
 101         final DOMDataTreeProducer shardRegProducer = dataTree.createProducer(Collections.singletonList(ROOT_ID));
 102         rootShardReg = dataTree.registerDataTreeShard(ROOT_ID, rootShard, shardRegProducer);
 103         shardRegProducer.close();
 104
 105         dataTreeService = dataTree;
 106     }
 107
 108     @Test(expected = IllegalStateException.class)
 109     public void testTxReadyMultiples() throws Exception {
 110         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 111         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 112         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
 113
 114         final ContainerNode testContainer = ImmutableContainerNodeBuilder.create()
 115                 .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
 116                 .build();
 117         cursor.write(TestModel.TEST_PATH.getLastPathArgument(), testContainer);
 118         transaction.ready();
 119
 120         transaction.ready();
 121     }
 122
 123     @Test(expected = IllegalStateException.class)
 124     public void testSubmitUnclosedCursor() throws Exception {
 125         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 126         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 127         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
 128
 129         final ContainerNode testContainer = ImmutableContainerNodeBuilder.create()
 130                 .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
 131                 .build();
 132
 133         cursor.write(TestModel.TEST_PATH.getLastPathArgument(), testContainer);
 134         transaction.ready();
 135     }
 136
 137     @Test
 138     public void testMultipleCursorsFromOneTx() throws Exception {
 139         final DOMDataTreeListener mockedDataTreeListener = mock(DOMDataTreeListener.class);
 140         doNothing().when(mockedDataTreeListener).onDataTreeChanged(anyCollection(), anyMap());
 141
 142         dataTreeService.registerListener(mockedDataTreeListener, Collections.singletonList(INNER_CONTAINER_ID),
 143                 true, Collections.emptyList());
 144
 145         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 146         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 147         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
 148
 149         final ContainerNode testContainer = ImmutableContainerNodeBuilder.create()
 150                 .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
 151                 .build();
 152
 153         cursor.write(TestModel.TEST_PATH.getLastPathArgument(), testContainer);
 154         cursor.close();
 155
 156         final DOMDataTreeWriteCursor newCursor = transaction.createCursor(ROOT_ID);
 157         newCursor.enter(TestModel.TEST_PATH.getLastPathArgument());
 158         final ContainerNode innerContainer = ImmutableContainerNodeBuilder.create()
 159                 .withNodeIdentifier(new NodeIdentifier(TestModel.INNER_CONTAINER))
 160                 .withChild(ImmutableLeafNodeBuilder.<String>create()
 161                         .withNodeIdentifier(new NodeIdentifier(TestModel.SHARDED_VALUE_1))
 162                         .withValue("inner-value")
 163                         .build())
 164                 .build();
 165
 166         newCursor.write(TestModel.INNER_CONTAINER_PATH.getLastPathArgument(), innerContainer);
 167         newCursor.close();
 168         transaction.ready();
 169         transaction.submit();
 170
 171         verify(mockedDataTreeListener, timeout(1000).times(2)).onDataTreeChanged(
 172                 captorForChanges.capture(), captorForSubtrees.capture());
 173         final Collection<DataTreeCandidate> capturedValue = captorForChanges.getValue();
 174         assertTrue(capturedValue.size() == 1);
 175
 176         final ContainerNode dataAfter =
 177                 (ContainerNode) capturedValue.iterator().next().getRootNode().getDataAfter().get();
 178         assertEquals(innerContainer, dataAfter);
 179         verifyNoMoreInteractions(mockedDataTreeListener);
 180     }
 181
 182     @Test
 183     public void testSingleShardListener() throws Exception {
 184         final DOMDataTreeListener mockedDataTreeListener = mock(DOMDataTreeListener.class);
 185         doNothing().when(mockedDataTreeListener).onDataTreeChanged(anyCollection(), anyMap());
 186
 187         dataTreeService.registerListener(mockedDataTreeListener, Collections.singletonList(INNER_CONTAINER_ID), true,
 188                 Collections.emptyList());
 189
 190         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 191         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 192         writeCrossShardContainer(transaction);
 193
 194         verify(mockedDataTreeListener, timeout(1000).times(2)).onDataTreeChanged(
 195                 captorForChanges.capture(), captorForSubtrees.capture());
 196         final Collection<DataTreeCandidate> capturedValue = captorForChanges.getValue();
 197         assertTrue(capturedValue.size() == 1);
 198
 199         final ContainerNode dataAfter =
 200                 (ContainerNode) capturedValue.iterator().next().getRootNode().getDataAfter().get();
 201         assertEquals(crossShardContainer.getChild(
 202                 TestModel.INNER_CONTAINER_PATH.getLastPathArgument()).get(), dataAfter);
 203
 204         final Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> capturedSubtrees = captorForSubtrees.getValue();
 205         assertTrue(capturedSubtrees.size() == 1);
 206         assertTrue(capturedSubtrees.containsKey(INNER_CONTAINER_ID));
 207         assertEquals(crossShardContainer.getChild(TestModel.INNER_CONTAINER_PATH.getLastPathArgument()).get(),
 208                 capturedSubtrees.get(INNER_CONTAINER_ID));
 209
 210         verifyNoMoreInteractions(mockedDataTreeListener);
 211     }
 212
 213     @Test
 214     public void testMultipleShards() throws Exception {
 215         final DOMDataTreeListener mockedDataTreeListener = mock(DOMDataTreeListener.class);
 216         doNothing().when(mockedDataTreeListener).onDataTreeChanged(anyCollection(), anyMap());
 217
 218         final InMemoryDOMDataTreeShard innerShard = InMemoryDOMDataTreeShard.create(INNER_CONTAINER_ID, executor, 1);
 219         innerShard.onGlobalContextUpdated(SCHEMA_CONTEXT);
 220         final DOMDataTreeProducer shardRegProducer =
 221                 dataTreeService.createProducer(Collections.singletonList(INNER_CONTAINER_ID));
 222         innerShardReg = dataTreeService.registerDataTreeShard(INNER_CONTAINER_ID, innerShard, shardRegProducer);
 223         shardRegProducer.close();
 224
 225         dataTreeService.registerListener(mockedDataTreeListener, Collections.singletonList(TEST_ID),
 226                 true, Collections.emptyList());
 227
 228         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 229         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 230         writeCrossShardContainer(transaction);
 231
 232         final ContainerNode testContainerVerificationNode = ImmutableContainerNodeBuilder.create()
 233                 .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
 234                 .build();
 235
 236         //verify listeners have been notified
 237         verify(mockedDataTreeListener, timeout(1000).times(4)).onDataTreeChanged(
 238                 captorForChanges.capture(), captorForSubtrees.capture());
 239         final List<Collection<DataTreeCandidate>> capturedChanges = captorForChanges.getAllValues();
 240         final List<Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>>> capturedSubtrees =
 241                 captorForSubtrees.getAllValues();
 242         final DataTreeCandidate firstNotificationCandidate = capturedChanges.get(2).iterator().next();
 243
 244         assertTrue(capturedSubtrees.get(2).size() == 1);
 245         assertEquals(testContainerVerificationNode, firstNotificationCandidate.getRootNode().getDataAfter().get());
 246         assertEquals(testContainerVerificationNode, capturedSubtrees.get(2).get(TEST_ID));
 247
 248         final DataTreeCandidate secondNotificationCandidate = capturedChanges.get(3).iterator().next();
 249         assertTrue(capturedSubtrees.get(3).size() == 1);
 250         assertEquals(crossShardContainer, secondNotificationCandidate.getRootNode().getDataAfter().get());
 251         assertEquals(crossShardContainer, capturedSubtrees.get(3).get(TEST_ID));
 252
 253         verifyNoMoreInteractions(mockedDataTreeListener);
 254     }
 255
 256     @Test
 257     public void testMultipleShardsProducerClose() throws Exception {
 258         final InMemoryDOMDataTreeShard innerShard = InMemoryDOMDataTreeShard.create(INNER_CONTAINER_ID, executor, 1);
 259         innerShard.onGlobalContextUpdated(SCHEMA_CONTEXT);
 260
 261         assertTrue(rootShard.getProducers().isEmpty());
 262
 263         final DOMDataTreeProducer innerShardRegProducer =
 264                 dataTreeService.createProducer(Collections.singletonList(INNER_CONTAINER_ID));
 265         assertTrue(rootShard.getProducers().size() == 1);
 266         final DOMDataTreeShardProducer rootShardProducer = Iterables.getOnlyElement(rootShard.getProducers());
 267         assertEquals(rootShardProducer.getPrefixes().toString(),
 268                 Collections.singletonList(INNER_CONTAINER_ID).toString());
 269
 270         dataTreeService.registerDataTreeShard(INNER_CONTAINER_ID, innerShard, innerShardRegProducer);
 271
 272         assertTrue(rootShard.getProducers().isEmpty());
 273         assertTrue(innerShard.getProducers().size() == 1);
 274         final DOMDataTreeShardProducer innerShardProducer = Iterables.getOnlyElement(innerShard.getProducers());
 275         assertEquals(innerShardProducer.getPrefixes().toString(),
 276                 Collections.singletonList(INNER_CONTAINER_ID).toString());
 277
 278         innerShardRegProducer.close();
 279         assertTrue(rootShard.getProducers().isEmpty());
 280         assertTrue(innerShard.getProducers().isEmpty());
 281
 282         final DOMDataTreeProducer testProducer =
 283                 dataTreeService.createProducer(Collections.singletonList(TEST_ID));
 284         assertTrue(rootShard.getProducers().size() == 1);
 285         final DOMDataTreeShardProducer rootShardProducer2 = Iterables.getOnlyElement(rootShard.getProducers());
 286         assertEquals(rootShardProducer2.getPrefixes().toString(),
 287                 Collections.singletonList(TEST_ID).toString());
 288
 289         assertTrue(innerShard.getProducers().size() == 1);
 290         final DOMDataTreeShardProducer innerShardProducer2 = Iterables.getOnlyElement(innerShard.getProducers());
 291         assertEquals(innerShardProducer2.getPrefixes().toString(),
 292                 Collections.singletonList(INNER_CONTAINER_ID).toString());
 293
 294         testProducer.close();
 295         assertTrue(rootShard.getProducers().isEmpty());
 296         assertTrue(innerShard.getProducers().isEmpty());
 297     }
 298
 299     @Test
 300     public void testMultipleShardsChildProducerClose() throws Exception {
 301         final InMemoryDOMDataTreeShard innerShard = InMemoryDOMDataTreeShard.create(INNER_CONTAINER_ID, executor, 1);
 302         innerShard.onGlobalContextUpdated(SCHEMA_CONTEXT);
 303
 304         final DOMDataTreeProducer innerShardRegProducer =
 305                 dataTreeService.createProducer(Collections.singletonList(INNER_CONTAINER_ID));
 306         dataTreeService.registerDataTreeShard(INNER_CONTAINER_ID, innerShard, innerShardRegProducer);
 307         innerShardRegProducer.close();
 308         assertTrue(rootShard.getProducers().isEmpty());
 309         assertTrue(innerShard.getProducers().isEmpty());
 310
 311         final DOMDataTreeProducer testProducer =
 312                 dataTreeService.createProducer(Collections.singletonList(TEST_ID));
 313         final DOMDataTreeProducer testChildProducer = testProducer.createProducer(
 314                 Collections.singletonList(INNER_CONTAINER_ID));
 315         assertTrue(rootShard.getProducers().size() == 1);
 316         assertTrue(innerShard.getProducers().size() == 2);
 317
 318         final DOMDataTreeShardProducer rootShardProducer = Iterables.getOnlyElement(rootShard.getProducers());
 319         assertEquals(rootShardProducer.getPrefixes().toString(),
 320                 Collections.singletonList(TEST_ID).toString());
 321
 322         for (DOMDataTreeShardProducer producer : innerShard.getProducers()) {
 323             assertEquals(producer.getPrefixes().toString(),
 324                     Collections.singletonList(INNER_CONTAINER_ID).toString());
 325         }
 326
 327         testProducer.close();
 328         assertTrue(rootShard.getProducers().isEmpty());
 329         assertTrue(innerShard.getProducers().size() == 1);
 330         final DOMDataTreeShardProducer innerShardProducer = Iterables.getOnlyElement(innerShard.getProducers());
 331         assertEquals(innerShardProducer.getPrefixes().toString(),
 332                 Collections.singletonList(INNER_CONTAINER_ID).toString());
 333
 334         testChildProducer.close();
 335         assertTrue(rootShard.getProducers().isEmpty());
 336         assertTrue(innerShard.getProducers().isEmpty());
 337     }
 338
 339     @Test
 340     public void testMultipleShardsProducerCloseForSubshardAttached() throws Exception {
 341         final InMemoryDOMDataTreeShard innerShard = InMemoryDOMDataTreeShard.create(INNER_CONTAINER_ID, executor, 1);
 342         innerShard.onGlobalContextUpdated(SCHEMA_CONTEXT);
 343
 344         final DOMDataTreeProducer innerShardRegProducer =
 345                 dataTreeService.createProducer(Collections.singletonList(INNER_CONTAINER_ID));
 346         dataTreeService.registerDataTreeShard(INNER_CONTAINER_ID, innerShard, innerShardRegProducer);
 347         innerShardRegProducer.close();
 348         assertTrue(rootShard.getProducers().isEmpty());
 349         assertTrue(innerShard.getProducers().isEmpty());
 350
 351         final DOMDataTreeProducer testProducer =
 352                 dataTreeService.createProducer(Collections.singletonList(TEST_ID));
 353         assertTrue(rootShard.getProducers().size() == 1);
 354         assertTrue(innerShard.getProducers().size() == 1);
 355
 356         final DOMDataTreeShardProducer rootShardProducer = Iterables.getOnlyElement(rootShard.getProducers());
 357         assertEquals(rootShardProducer.getPrefixes().toString(),
 358                 Collections.singletonList(TEST_ID).toString());
 359
 360         final DOMDataTreeShardProducer innerShardProducer = Iterables.getOnlyElement(innerShard.getProducers());
 361         assertEquals(innerShardProducer.getPrefixes().toString(),
 362                 Collections.singletonList(INNER_CONTAINER_ID).toString());
 363
 364         final InMemoryDOMDataTreeShard test2Shard = InMemoryDOMDataTreeShard.create(TEST2_ID, executor, 1);
 365         innerShard.onGlobalContextUpdated(SCHEMA_CONTEXT);
 366
 367         final DOMDataTreeProducer test2ShardRegProducer =
 368                 dataTreeService.createProducer(Collections.singletonList(TEST2_ID));
 369         dataTreeService.registerDataTreeShard(TEST2_ID, test2Shard, test2ShardRegProducer);
 370         test2ShardRegProducer.close();
 371
 372         assertTrue(rootShard.getProducers().size() == 1);
 373         assertTrue(innerShard.getProducers().size() == 1);
 374
 375         final DOMDataTreeShardProducer rootShardProducer2 = Iterables.getOnlyElement(rootShard.getProducers());
 376         assertEquals(rootShardProducer2.getPrefixes().toString(),
 377                 Collections.singletonList(TEST_ID).toString());
 378
 379         final DOMDataTreeShardProducer innerShardProducer2 = Iterables.getOnlyElement(innerShard.getProducers());
 380         assertEquals(innerShardProducer2.getPrefixes().toString(),
 381                 Collections.singletonList(INNER_CONTAINER_ID).toString());
 382     }
 383
 384     @Test
 385     public void testMultipleWritesIntoSingleShard() throws Exception {
 386         final DOMDataTreeListener mockedDataTreeListener = mock(DOMDataTreeListener.class);
 387         doNothing().when(mockedDataTreeListener).onDataTreeChanged(anyCollection(), anyMap());
 388
 389         dataTreeService.registerListener(mockedDataTreeListener, Collections.singletonList(INNER_CONTAINER_ID),
 390                 true, Collections.emptyList());
 391
 392         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 393         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 394         writeCrossShardContainer(transaction);
 395
 396         final DOMDataTreeShardWriteTransaction newTx = producer.createTransaction();
 397         final DOMDataTreeWriteCursor newCursor = newTx.createCursor(ROOT_ID);
 398
 399         newCursor.delete(TestModel.TEST_PATH.getLastPathArgument());
 400     }
 401
 402     @Test
 403     public void testMockedSubshards() throws Exception {
 404         final WriteableDOMDataTreeShard mockedInnerShard = mock(WriteableDOMDataTreeShard.class);
 405         final DOMDataTreeShardProducer mockedProducer = mock(DOMDataTreeShardProducer.class);
 406         doReturn(mockedProducer).when(mockedInnerShard).createProducer(anyCollection());
 407         final ShardedDOMDataTreeProducer shardRegProducer = mock(ShardedDOMDataTreeProducer.class);
 408         doReturn(Collections.singleton(INNER_CONTAINER_ID)).when(shardRegProducer).getSubtrees();
 409         doNothing().when(shardRegProducer).subshardAdded(anyMap());
 410
 411         dataTreeService.registerDataTreeShard(INNER_CONTAINER_ID, mockedInnerShard, shardRegProducer);
 412
 413         final DOMDataTreeShardProducer producer = rootShard.createProducer(Collections.singletonList(TEST_ID));
 414
 415         final DOMDataTreeShardWriteTransaction transaction = producer.createTransaction();
 416         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
 417         cursor.enter(TestModel.TEST_PATH.getLastPathArgument());
 418
 419         final LeafNode<String> shardedValue1 =
 420                 ImmutableLeafNodeBuilder.<String>create().withNodeIdentifier(
 421                         new NodeIdentifier(TestModel.SHARDED_VALUE_1)).withValue("sharded value 1").build();
 422         final LeafNode<String> shardedValue2 =
 423                 ImmutableLeafNodeBuilder.<String>create().withNodeIdentifier(
 424                         new NodeIdentifier(TestModel.SHARDED_VALUE_2)).withValue("sharded value 2").build();
 425
 426         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerNodeBuilder =
 427                 ImmutableContainerNodeBuilder.create();
 428         final ContainerNode containerNode =
 429                 containerNodeBuilder
 430                         .withNodeIdentifier(new NodeIdentifier(TestModel.INNER_CONTAINER))
 431                         .withChild(shardedValue1)
 432                         .withChild(shardedValue2)
 433                         .build();
 434
 435         final DOMDataTreeShardWriteTransaction mockedTx = mock(DOMDataTreeShardWriteTransaction.class);
 436         doReturn(mockedTx).when(mockedProducer).createTransaction();
 437
 438         doNothing().when(mockedTx).ready();
 439         doReturn(Futures.immediateFuture(true)).when(mockedTx).validate();
 440         doReturn(Futures.immediateFuture(null)).when(mockedTx).prepare();
 441         doReturn(Futures.immediateFuture(null)).when(mockedTx).commit();
 442
 443         final DOMDataTreeWriteCursor mockedCursor = mock(DOMDataTreeWriteCursor.class);
 444         doNothing().when(mockedCursor).write(any(PathArgument.class), any(NormalizedNode.class));
 445         doNothing().when(mockedCursor).close();
 446         doReturn(mockedCursor).when(mockedTx).createCursor(any(DOMDataTreeIdentifier.class));
 447
 448         cursor.write(TestModel.INNER_CONTAINER_PATH.getLastPathArgument(), containerNode);
 449         cursor.enter(TestModel.INNER_CONTAINER_PATH.getLastPathArgument());
 450
 451         final ContainerNode lowerShardContainer = ImmutableContainerNodeBuilder.create()
 452                 .withNodeIdentifier(new NodeIdentifier(TestModel.ANOTHER_SHARD_CONTAINER))
 453                 .withChild(ImmutableLeafNodeBuilder.create().withNodeIdentifier(
 454                         new NodeIdentifier(TestModel.ANOTHER_SHARD_VALUE)).withValue("").build())
 455                 .build();
 456
 457         cursor.write(TestModel.ANOTHER_SHARD_PATH.getLastPathArgument(), lowerShardContainer);
 458         cursor.close();
 459         transaction.ready();
 460         transaction.submit().get();
 461
 462         final InOrder inOrder = inOrder(mockedTx);
 463         inOrder.verify(mockedTx).ready();
 464         inOrder.verify(mockedTx).validate();
 465         inOrder.verify(mockedTx).prepare();
 466         inOrder.verify(mockedTx).commit();
 467
 468     }
 469
 470     private static ContainerNode createCrossShardContainer() {
 471         final LeafNode<String> shardedValue1 =
 472                 ImmutableLeafNodeBuilder.<String>create().withNodeIdentifier(
 473                         new NodeIdentifier(TestModel.SHARDED_VALUE_1)).withValue("sharded value 1").build();
 474         final LeafNode<String> shardedValue2 =
 475                 ImmutableLeafNodeBuilder.<String>create().withNodeIdentifier(new NodeIdentifier(
 476                         TestModel.SHARDED_VALUE_2)).withValue("sharded value 2").build();
 477
 478
 479         final ContainerNode lowerShardContainer = ImmutableContainerNodeBuilder.create()
 480                 .withNodeIdentifier(new NodeIdentifier(TestModel.ANOTHER_SHARD_CONTAINER))
 481                 .withChild(ImmutableLeafNodeBuilder.create()
 482                         .withNodeIdentifier(new NodeIdentifier(TestModel.ANOTHER_SHARD_VALUE))
 483                         .withValue("testing-value")
 484                         .build())
 485                 .build();
 486
 487         final ContainerNode containerNode =
 488                 ImmutableContainerNodeBuilder.create()
 489                         .withNodeIdentifier(new NodeIdentifier(TestModel.INNER_CONTAINER))
 490                         .withChild(shardedValue1)
 491                         .withChild(shardedValue2)
 492                         .withChild(lowerShardContainer)
 493                         .build();
 494
 495         final ContainerNode testContainer = ImmutableContainerNodeBuilder.create()
 496                 .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
 497                 .withChild(containerNode)
 498                 .build();
 499
 500         return testContainer;
 501     }
 502
 503     private void writeCrossShardContainer(final DOMDataTreeShardWriteTransaction transaction) throws Exception {
 504         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
 505
 506         cursor.write(TestModel.TEST_PATH.getLastPathArgument(), crossShardContainer);
 507
 508         cursor.close();
 509         transaction.ready();
 510         transaction.submit().get();
 511     }
 512 }