opendaylight/md-sal/statistics-manager/src/test/java/test/mock/GroupStatisticsTest.java

   1 package test.mock;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertFalse;
   5 import static org.junit.Assert.assertTrue;
   6
   7 import java.util.concurrent.ExecutionException;
   8
   9 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  10 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  11 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  12 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
  13 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  14 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  15 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  16 import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityGroupStats;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStats;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeatures;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeatures;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  26 import org.opendaylight.yangtools.yang.binding.DataObject;
  27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  28
  29 import test.mock.util.StatisticsManagerTest;
  30
  31 import com.google.common.base.Optional;
  32
  33 public class GroupStatisticsTest extends StatisticsManagerTest {
  34     private final Object waitObject = new Object();
  35
  36 //    @Test(timeout = 5000)
  37     public void addedGroupOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
  38         final StatisticsManagerActivator activator = new StatisticsManagerActivator();
  39         activator.onSessionInitiated(providerContext);
  40
  41         addFlowCapableNode(s1Key);
  42
  43         final Group group = getGroup();
  44
  45         final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
  46                 .augmentation(FlowCapableNode.class).child(Group.class, group.getKey());
  47
  48         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
  49         writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
  50         writeTx.put(LogicalDatastoreType.OPERATIONAL, groupII, group);
  51         assertCommit(writeTx.submit());
  52
  53         getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
  54                 groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
  55
  56         synchronized (waitObject) {
  57             waitObject.wait();
  58         }
  59
  60         final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
  61         final Optional<NodeGroupStatistics> groupOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, groupII.augmentation(NodeGroupStatistics.class)).checkedGet();
  62         assertTrue(groupOptional.isPresent());
  63         assertEquals(COUNTER_64_TEST_VALUE, groupOptional.get().getGroupStatistics().getByteCount());
  64     }
  65
  66 //    @Test(timeout = 5000)
  67     public void deletedGroupStasRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
  68         final StatisticsManagerActivator activator = new StatisticsManagerActivator();
  69         activator.onSessionInitiated(providerContext);
  70
  71         addFlowCapableNode(s1Key);
  72
  73         final Group group = getGroup();
  74         final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
  75                 .augmentation(FlowCapableNode.class).child(Group.class, group.getKey());
  76
  77         WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
  78         writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
  79         writeTx.put(LogicalDatastoreType.OPERATIONAL, groupII, group);
  80         assertCommit(writeTx.submit());
  81
  82         getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
  83                 groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
  84
  85         synchronized (waitObject) {
  86             waitObject.wait();
  87         }
  88
  89         ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
  90         Optional<NodeGroupStatistics> groupOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
  91                 groupII.augmentation(NodeGroupStatistics.class)).checkedGet();
  92         assertTrue(groupOptional.isPresent());
  93         assertEquals(COUNTER_64_TEST_VALUE, groupOptional.get().getGroupStatistics().getByteCount());
  94
  95         writeTx = getDataBroker().newWriteOnlyTransaction();
  96         writeTx.delete(LogicalDatastoreType.CONFIGURATION, groupII);
  97         assertCommit(writeTx.submit());
  98
  99         readTx = getDataBroker().newReadOnlyTransaction();
 100         groupOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
 101                 groupII.augmentation(NodeGroupStatistics.class)).checkedGet();
 102         assertFalse(groupOptional.isPresent());
 103
 104     }
 105
 106 //    @Test(timeout = 23000)
 107     public void getAllStatsFromConnectedNodeTest() throws ExecutionException, InterruptedException {
 108         final StatisticsManagerActivator activator = new StatisticsManagerActivator();
 109         activator.onSessionInitiated(providerContext);
 110
 111         addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityGroupStats.class);
 112
 113         final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
 114                 .augmentation(FlowCapableNode.class).child(Group.class, getGroup().getKey());
 115         getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
 116                 groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
 117
 118         synchronized (waitObject) {
 119             waitObject.wait();
 120         }
 121
 122         ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
 123         final Optional<Group> optionalGroup = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
 124                 .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
 125                 .child(Group.class, getGroup().getKey())).get();
 126
 127         assertTrue(optionalGroup.isPresent());
 128         assertTrue(optionalGroup.get().getAugmentation(NodeGroupDescStats.class) != null);
 129         final NodeGroupStatistics groupStats = optionalGroup.get().getAugmentation(NodeGroupStatistics.class);
 130         assertTrue(groupStats != null);
 131         assertEquals(COUNTER_64_TEST_VALUE, groupStats.getGroupStatistics().getByteCount());
 132
 133         readTx = getDataBroker().newReadOnlyTransaction();
 134         final Optional<GroupFeatures> optionalGroupFeatures = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
 135                 .child(Node.class, s1Key).augmentation(NodeGroupFeatures.class).child(GroupFeatures.class)).get();
 136         assertTrue(optionalGroupFeatures.isPresent());
 137         assertEquals(1, optionalGroupFeatures.get().getMaxGroups().size());
 138         assertEquals(MAX_GROUPS_TEST_VALUE, optionalGroupFeatures.get().getMaxGroups().get(0));
 139     }
 140
 141     private class ChangeListener implements DataChangeListener {
 142
 143         @Override
 144         public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 145             synchronized (waitObject) {
 146                 waitObject.notify();
 147             }
 148         }
 149     }
 150 }
 151