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