opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/bugfix/PutAugmentationTest.java

   1 /*
   2  * Copyright (c) 2014 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.controller.sal.binding.test.bugfix;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertNull;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.util.Collections;
  16 import java.util.Map;
  17
  18 import org.junit.Test;
  19 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  20 import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
  21 import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
  22 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
  23 import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.flow.node.SupportedActions;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  38 import org.opendaylight.yangtools.yang.binding.DataObject;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.opendaylight.yangtools.yang.common.QName;
  41 import org.opendaylight.yangtools.yang.common.RpcResult;
  42 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  43
  44 public class PutAugmentationTest extends AbstractDataServiceTest implements DataChangeListener {
  45
  46     private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
  47     private static final String NODE_ID = "openflow:1";
  48
  49     private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
  50
  51     private static final Map<QName, Object> NODE_KEY_BI = Collections.<QName, Object> singletonMap(NODE_ID_QNAME,
  52             NODE_ID);
  53
  54     private static final InstanceIdentifier<Nodes> NODES_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
  55             .toInstance();
  56
  57     private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier//
  58             .builder(NODES_INSTANCE_ID_BA) //
  59             .child(Node.class, NODE_KEY).toInstance();
  60
  61     private static final InstanceIdentifier<SupportedActions> SUPPORTED_ACTIONS_INSTANCE_ID_BA = InstanceIdentifier//
  62             .builder(NODES_INSTANCE_ID_BA) //
  63             .child(Node.class, NODE_KEY) //
  64             .augmentation(FlowCapableNode.class) //
  65             .child(SupportedActions.class).toInstance();
  66
  67     private static final InstanceIdentifier<FlowCapableNode> ALL_FLOW_CAPABLE_NODES = InstanceIdentifier //
  68             .builder(NODES_INSTANCE_ID_BA) //
  69             .child(Node.class) //
  70             .augmentation(FlowCapableNode.class) //
  71             .build();
  72
  73     private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
  74     org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
  75             .node(Nodes.QNAME) //
  76             .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
  77             .toInstance();
  78     private static final QName SUPPORTED_ACTIONS_QNAME = QName.create(FlowCapableNode.QNAME,
  79             SupportedActions.QNAME.getLocalName());
  80
  81     private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier SUPPORTED_ACTIONS_INSTANCE_ID_BI = //
  82     org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
  83             .node(Nodes.QNAME) //
  84             .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
  85             .node(SUPPORTED_ACTIONS_QNAME) //
  86             .toInstance();
  87     private static final InstanceIdentifier<FlowCapableNode> FLOW_AUGMENTATION_PATH = InstanceIdentifier //
  88             .builder(NODE_INSTANCE_ID_BA) //
  89             .augmentation(FlowCapableNode.class) //
  90             .build();
  91
  92     private DataChangeEvent<InstanceIdentifier<?>, DataObject> lastReceivedChangeEvent;
  93
  94     /**
  95      * Test for Bug 148
  96      *
  97      * @throws Exception
  98      */
  99     @Test
 100     public void putNodeAndAugmentation() throws Exception {
 101
 102         baDataService.registerDataChangeListener(ALL_FLOW_CAPABLE_NODES, this);
 103
 104
 105         NodeBuilder nodeBuilder = new NodeBuilder();
 106         nodeBuilder.setId(new NodeId(NODE_ID));
 107         nodeBuilder.setKey(NODE_KEY);
 108         DataModificationTransaction baseTransaction = baDataService.beginTransaction();
 109         baseTransaction.putOperationalData(NODE_INSTANCE_ID_BA, nodeBuilder.build());
 110         RpcResult<TransactionStatus> result = baseTransaction.commit().get();
 111         assertEquals(TransactionStatus.COMMITED, result.getResult());
 112
 113         Node node = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
 114         assertNotNull(node);
 115         assertEquals(NODE_KEY, node.getKey());
 116
 117         FlowCapableNodeBuilder fnub = new FlowCapableNodeBuilder();
 118         fnub.setHardware("Hardware Foo");
 119         fnub.setManufacturer("Manufacturer Foo");
 120         fnub.setSerialNumber("Serial Foo");
 121         fnub.setDescription("Description Foo");
 122         fnub.setSoftware("JUnit emulated");
 123         FlowCapableNode fnu = fnub.build();
 124         InstanceIdentifier<FlowCapableNode> augmentIdentifier = InstanceIdentifier.builder(NODE_INSTANCE_ID_BA)
 125                 .augmentation(FlowCapableNode.class).toInstance();
 126         DataModificationTransaction augmentedTransaction = baDataService.beginTransaction();
 127         augmentedTransaction.putOperationalData(augmentIdentifier, fnu);
 128
 129         result = augmentedTransaction.commit().get();
 130         assertEquals(TransactionStatus.COMMITED, result.getResult());
 131
 132         assertNotNull(lastReceivedChangeEvent);
 133         assertTrue(lastReceivedChangeEvent.getCreatedOperationalData().containsKey(FLOW_AUGMENTATION_PATH));
 134
 135         Node augmentedNode = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
 136         assertNotNull(node);
 137         assertEquals(NODE_KEY, augmentedNode.getKey());
 138         System.out.println("Before assertion");
 139         assertNotNull(augmentedNode.getAugmentation(FlowCapableNode.class));
 140         FlowCapableNode readedAugmentation = augmentedNode.getAugmentation(FlowCapableNode.class);
 141         assertEquals(fnu.getDescription(), readedAugmentation.getDescription());
 142         assertBindingIndependentVersion(NODE_INSTANCE_ID_BI);
 143         testNodeRemove();
 144         assertTrue(lastReceivedChangeEvent.getRemovedOperationalData().contains(FLOW_AUGMENTATION_PATH));
 145     }
 146
 147     @Test
 148     public void putNodeWithAugmentation() throws Exception {
 149
 150         baDataService.registerDataChangeListener(ALL_FLOW_CAPABLE_NODES, this);
 151
 152         NodeBuilder nodeBuilder = new NodeBuilder();
 153         nodeBuilder.setId(new NodeId(NODE_ID));
 154         nodeBuilder.setKey(NODE_KEY);
 155         FlowCapableNodeBuilder fnub = new FlowCapableNodeBuilder();
 156         fnub.setHardware("Hardware Foo");
 157         fnub.setManufacturer("Manufacturer Foo");
 158         fnub.setSerialNumber("Serial Foo");
 159         fnub.setDescription("Description Foo");
 160         fnub.setSoftware("JUnit emulated");
 161         FlowCapableNode fnu = fnub.build();
 162
 163         nodeBuilder.addAugmentation(FlowCapableNode.class, fnu);
 164         DataModificationTransaction baseTransaction = baDataService.beginTransaction();
 165         baseTransaction.putOperationalData(NODE_INSTANCE_ID_BA, nodeBuilder.build());
 166         RpcResult<TransactionStatus> result = baseTransaction.commit().get();
 167
 168         assertNotNull(lastReceivedChangeEvent);
 169         assertTrue(lastReceivedChangeEvent.getCreatedOperationalData().containsKey(FLOW_AUGMENTATION_PATH));
 170         lastReceivedChangeEvent = null;
 171         assertEquals(TransactionStatus.COMMITED, result.getResult());
 172
 173         FlowCapableNode readedAugmentation = (FlowCapableNode) baDataService.readOperationalData(InstanceIdentifier
 174                 .builder(NODE_INSTANCE_ID_BA).augmentation(FlowCapableNode.class).toInstance());
 175         assertNotNull(readedAugmentation);
 176
 177         assertEquals(fnu.getHardware(), readedAugmentation.getHardware());
 178
 179         testPutNodeConnectorWithAugmentation();
 180         lastReceivedChangeEvent = null;
 181         testNodeRemove();
 182
 183         assertTrue(lastReceivedChangeEvent.getRemovedOperationalData().contains(FLOW_AUGMENTATION_PATH));
 184     }
 185
 186     private void testPutNodeConnectorWithAugmentation() throws Exception {
 187         NodeConnectorKey ncKey = new NodeConnectorKey(new NodeConnectorId("test:0:0"));
 188         InstanceIdentifier<NodeConnector> ncPath = InstanceIdentifier.builder(NODE_INSTANCE_ID_BA)
 189                 .child(NodeConnector.class, ncKey).toInstance();
 190         InstanceIdentifier<FlowCapableNodeConnector> ncAugmentPath = InstanceIdentifier.builder(ncPath)
 191                 .augmentation(FlowCapableNodeConnector.class).toInstance();
 192
 193         NodeConnectorBuilder nc = new NodeConnectorBuilder();
 194         nc.setKey(ncKey);
 195
 196         FlowCapableNodeConnectorBuilder fncb = new FlowCapableNodeConnectorBuilder();
 197         fncb.setName("Baz");
 198         nc.addAugmentation(FlowCapableNodeConnector.class, fncb.build());
 199
 200         DataModificationTransaction baseTransaction = baDataService.beginTransaction();
 201         baseTransaction.putOperationalData(ncPath, nc.build());
 202         RpcResult<TransactionStatus> result = baseTransaction.commit().get();
 203         assertEquals(TransactionStatus.COMMITED, result.getResult());
 204
 205         FlowCapableNodeConnector readedAugmentation = (FlowCapableNodeConnector) baDataService
 206                 .readOperationalData(ncAugmentPath);
 207         assertNotNull(readedAugmentation);
 208         assertEquals(fncb.getName(), readedAugmentation.getName());
 209     }
 210
 211     private void testNodeRemove() throws Exception {
 212         DataModificationTransaction transaction = baDataService.beginTransaction();
 213         transaction.removeOperationalData(NODE_INSTANCE_ID_BA);
 214         RpcResult<TransactionStatus> result = transaction.commit().get();
 215         assertEquals(TransactionStatus.COMMITED, result.getResult());
 216
 217         Node node = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
 218         assertNull(node);
 219     }
 220
 221     private void verifyNodes(Nodes nodes, Node original) {
 222         assertNotNull(nodes);
 223         assertNotNull(nodes.getNode());
 224         assertEquals(1, nodes.getNode().size());
 225         Node readedNode = nodes.getNode().get(0);
 226         assertEquals(original.getId(), readedNode.getId());
 227         assertEquals(original.getKey(), readedNode.getKey());
 228
 229         FlowCapableNode fnu = original.getAugmentation(FlowCapableNode.class);
 230         FlowCapableNode readedAugment = readedNode.getAugmentation(FlowCapableNode.class);
 231         assertNotNull(fnu);
 232         assertEquals(fnu.getDescription(), readedAugment.getDescription());
 233         assertEquals(fnu.getSerialNumber(), readedAugment.getSerialNumber());
 234
 235     }
 236
 237     private void assertBindingIndependentVersion(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier nodeId) {
 238         CompositeNode node = biDataService.readOperationalData(nodeId);
 239         assertNotNull(node);
 240     }
 241
 242     private Nodes checkForNodes() {
 243         return (Nodes) baDataService.readOperationalData(NODES_INSTANCE_ID_BA);
 244     }
 245
 246     @Override
 247     public void onDataChanged(DataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 248         lastReceivedChangeEvent = change;
 249     }
 250
 251 }