git.opendaylight Code Review - controller.git/blob

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