opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/bugfix/MultipleAugmentationPuts.java

   1 package org.opendaylight.controller.sal.binding.test.bugfix;
   2
   3 import java.math.BigInteger;
   4 import java.util.ArrayList;
   5 import java.util.Collections;
   6 import java.util.List;
   7 import java.util.Map;
   8
   9 import org.junit.Test;
  10 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  11 import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
  12 import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
  13 import org.opendaylight.controller.sal.binding.test.AugmentationVerifier;
  14 import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
  15 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter32;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter64;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatistics;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatisticsBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterStatisticsBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.Duration;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.DurationBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStatsBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStatsKey;
  34 import org.opendaylight.yangtools.yang.binding.Augmentation;
  35 import org.opendaylight.yangtools.yang.binding.DataObject;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37 import org.opendaylight.yangtools.yang.common.QName;
  38 import org.opendaylight.yangtools.yang.common.RpcResult;
  39 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  40
  41 import com.google.common.collect.FluentIterable;
  42
  43 import static org.junit.Assert.*;
  44
  45 public class MultipleAugmentationPuts extends AbstractDataServiceTest implements DataChangeListener {
  46
  47     private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
  48     private static final String NODE_ID = "openflow:1";
  49
  50     private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
  51
  52     private static final Map<QName, Object> NODE_KEY_BI = Collections.<QName, Object> singletonMap(NODE_ID_QNAME,
  53             NODE_ID);
  54
  55     private static final InstanceIdentifier<Nodes> NODES_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
  56             .toInstance();
  57
  58     private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier
  59             .builder(NODES_INSTANCE_ID_BA) //
  60             .child(Node.class, NODE_KEY).toInstance();
  61
  62     private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
  63     org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
  64             .node(Nodes.QNAME) //
  65             .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
  66             .toInstance();
  67     private DataChangeEvent<InstanceIdentifier<?>, DataObject> receivedChangeEvent;
  68
  69     /**
  70      * Test for Bug 148
  71      *
  72      * @throws Exception
  73      */
  74     @Test
  75     public void testAugmentSerialization() throws Exception {
  76
  77         baDataService.registerDataChangeListener(NODES_INSTANCE_ID_BA, this);
  78
  79         Node flowCapableNode = createTestNode(FlowCapableNode.class, flowCapableNodeAugmentation());
  80         commitNodeAndVerifyTransaction(flowCapableNode);
  81
  82         assertNotNull(receivedChangeEvent);
  83         verifyNode((Nodes) receivedChangeEvent.getUpdatedOperationalSubtree(), flowCapableNode);
  84
  85         Nodes nodes = checkForNodes();
  86         verifyNode(nodes, flowCapableNode).assertHasAugmentation(FlowCapableNode.class);
  87         ;
  88         assertBindingIndependentVersion(NODE_INSTANCE_ID_BI);
  89         Node meterStatsNode = createTestNode(NodeMeterStatistics.class, nodeMeterStatistics());
  90         commitNodeAndVerifyTransaction(meterStatsNode);
  91
  92         assertNotNull(receivedChangeEvent);
  93         verifyNode((Nodes) receivedChangeEvent.getUpdatedOperationalSubtree(), meterStatsNode);
  94
  95         assertBindingIndependentVersion(NODE_INSTANCE_ID_BI);
  96
  97         Node mergedNode = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
  98
  99         AugmentationVerifier.from(mergedNode) //
 100                 .assertHasAugmentation(FlowCapableNode.class) //
 101                 .assertHasAugmentation(NodeMeterStatistics.class);
 102
 103         assertBindingIndependentVersion(NODE_INSTANCE_ID_BI);
 104
 105         Node meterStatsNodeWithDuration = createTestNode(NodeMeterStatistics.class, nodeMeterStatistics(5, true));
 106         commitNodeAndVerifyTransaction(meterStatsNodeWithDuration);
 107
 108
 109         Node nodeWithUpdatedList = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
 110         AugmentationVerifier.from(nodeWithUpdatedList) //
 111                 .assertHasAugmentation(FlowCapableNode.class) //
 112                 .assertHasAugmentation(NodeMeterStatistics.class);
 113
 114         List<MeterStats> meterStats = nodeWithUpdatedList.getAugmentation(NodeMeterStatistics.class).getMeterStatistics().getMeterStats();
 115         assertNotNull(meterStats);
 116         assertFalse(meterStats.isEmpty());
 117         assertBindingIndependentVersion(NODE_INSTANCE_ID_BI);
 118         testNodeRemove();
 119     }
 120
 121     private <T extends Augmentation<Node>> Node createTestNode(Class<T> augmentationClass, T augmentation) {
 122         NodeBuilder nodeBuilder = new NodeBuilder();
 123         nodeBuilder.setId(new NodeId(NODE_ID));
 124         nodeBuilder.setKey(NODE_KEY);
 125         nodeBuilder.addAugmentation(augmentationClass, augmentation);
 126         return nodeBuilder.build();
 127     }
 128
 129     private DataModificationTransaction commitNodeAndVerifyTransaction(Node original) throws Exception {
 130         DataModificationTransaction transaction = baDataService.beginTransaction();
 131         transaction.putOperationalData(NODE_INSTANCE_ID_BA, original);
 132         RpcResult<TransactionStatus> result = transaction.commit().get();
 133         assertEquals(TransactionStatus.COMMITED, result.getResult());
 134         return transaction;
 135     }
 136
 137     private void testNodeRemove() throws Exception {
 138         DataModificationTransaction transaction = baDataService.beginTransaction();
 139         transaction.removeOperationalData(NODE_INSTANCE_ID_BA);
 140         RpcResult<TransactionStatus> result = transaction.commit().get();
 141         assertEquals(TransactionStatus.COMMITED, result.getResult());
 142
 143         Node node = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
 144         assertNull(node);
 145     }
 146
 147     private AugmentationVerifier<Node> verifyNode(Nodes nodes, Node original) {
 148         assertNotNull(nodes);
 149         assertNotNull(nodes.getNode());
 150         assertEquals(1, nodes.getNode().size());
 151         Node readedNode = nodes.getNode().get(0);
 152         assertEquals(original.getId(), readedNode.getId());
 153         assertEquals(original.getKey(), readedNode.getKey());
 154         return new AugmentationVerifier<Node>(readedNode);
 155     }
 156
 157     private void assertBindingIndependentVersion(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier nodeId) {
 158         CompositeNode node = biDataService.readOperationalData(nodeId);
 159         assertNotNull(node);
 160     }
 161
 162     private Nodes checkForNodes() {
 163         return (Nodes) baDataService.readOperationalData(NODES_INSTANCE_ID_BA);
 164     }
 165
 166     private NodeMeterStatistics nodeMeterStatistics() {
 167         return nodeMeterStatistics(10, false);
 168     }
 169
 170     private NodeMeterStatistics nodeMeterStatistics(int count, boolean setDuration) {
 171         NodeMeterStatisticsBuilder nmsb = new NodeMeterStatisticsBuilder();
 172         MeterStatisticsBuilder meterStats = new MeterStatisticsBuilder();
 173
 174         List<MeterStats> stats = new ArrayList<>(count);
 175         for (int i = 0; i <= count; i++) {
 176             MeterStatsBuilder statistic = new MeterStatsBuilder();
 177             statistic.setKey(new MeterStatsKey(new MeterId((long) i)));
 178             statistic.setByteInCount(new Counter64(BigInteger.valueOf(34590 + i)));
 179             statistic.setFlowCount(new Counter32(4569L + i));
 180
 181             if (setDuration) {
 182                 DurationBuilder duration = new DurationBuilder();
 183                 duration.setNanosecond(new Counter32(70L));
 184                 statistic.setDuration(duration.build());
 185             }
 186
 187             stats.add(statistic.build());
 188         }
 189         meterStats.setMeterStats(stats);
 190         nmsb.setMeterStatistics(meterStats.build());
 191         return nmsb.build();
 192     }
 193
 194     private FlowCapableNode flowCapableNodeAugmentation() {
 195         FlowCapableNodeBuilder fnub = new FlowCapableNodeBuilder();
 196         fnub.setHardware("Hardware Foo");
 197         fnub.setManufacturer("Manufacturer Foo");
 198         fnub.setSerialNumber("Serial Foo");
 199         fnub.setDescription("Description Foo");
 200         fnub.setSoftware("JUnit emulated");
 201         FlowCapableNode fnu = fnub.build();
 202         return fnu;
 203     }
 204
 205     @Override
 206     public void onDataChanged(DataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 207         receivedChangeEvent = change;
 208     }
 209
 210 }