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