renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/statistics/flowcache/FlowCacheFactoryTest.java

   1 package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
   2 \r
   3 import static org.junit.Assert.assertEquals;\r
   4 import static org.junit.Assert.assertNotNull;\r
   5 import static org.junit.Assert.assertTrue;\r
   6 \r
   7 import java.util.Arrays;\r
   8 import java.util.List;\r
   9 \r
  10 import com.google.common.collect.ImmutableList;\r
  11 import org.junit.Before;\r
  12 import org.junit.Test;\r
  13 import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
  14 import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
  15 import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;\r
  16 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.ResolvedPolicyClassifierListener;\r
  17 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.FlowCacheCons;\r
  18 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.IidSflowNameUtil;\r
  19 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.ParameterValueList;\r
  20 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
  31 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
  32 \r
  33 public class FlowCacheFactoryTest {\r
  34 \r
  35     private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
  36     private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
  37     private final ContractId contractId = new ContractId("contract1");\r
  38     private final TenantId tenantId = new TenantId("tenant1");\r
  39     private final ClassifierName classifierName = ClassifierName.getDefaultInstance("classifier1");\r
  40     private final SubjectName subjectName = SubjectName.getDefaultInstance("subject1");\r
  41     private final RuleName ruleName = new RuleName("rule1");\r
  42 \r
  43     private InstanceIdentifier<ResolvedPolicy> rpIid;\r
  44     private String expectedName;\r
  45 \r
  46     @Before\r
  47     public void init() {\r
  48         rpIid = InstanceIdentifier.create(ResolvedPolicy.class);\r
  49         expectedName = tenantId.getValue() + IidSflowNameUtil.KEY_DELIMETER + contractId.getValue()\r
  50                 + IidSflowNameUtil.KEY_DELIMETER + subjectName.getValue() + IidSflowNameUtil.DELIMETER\r
  51                 + ruleName.getValue() + IidSflowNameUtil.DELIMETER + classifierName.getValue()\r
  52                 + IidSflowNameUtil.DELIMETER + FlowCacheCons.Value.BYTES.get();\r
  53     }\r
  54 \r
  55     @Test\r
  56     public void testCreateFlowCache_EtherTypeClassifier_IPv4() {\r
  57         ParameterValueList parameterValues = new ParameterValueList();\r
  58         parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE);\r
  59 \r
  60         Classifier classifier = newEtherTypeClassifier(parameterValues);\r
  61         ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
  62                 providerEpgId, classifier);\r
  63 \r
  64         FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
  65 \r
  66         assertNotNull(flowCache);\r
  67 \r
  68         List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
  69         List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
  70                 FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
  71 \r
  72         assertEquals(expectedName, flowCache.getName());\r
  73         assertEquals(expectedKeys.size(), keys.size());\r
  74         assertTrue(keys.containsAll(expectedKeys));\r
  75     }\r
  76 \r
  77     @Test\r
  78     public void testCreateFlowCache_IpProtoClassifier_TCP_IPv4() {\r
  79 \r
  80         ParameterValueList parameterValues = new ParameterValueList();\r
  81         parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
  82             .addProto(IpProtoClassifierDefinition.TCP_VALUE);\r
  83 \r
  84         Classifier classifier = newIpProtoClassifier(parameterValues);\r
  85         ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
  86                 providerEpgId, classifier);\r
  87 \r
  88         FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
  89 \r
  90         assertNotNull(flowCache);\r
  91 \r
  92         List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
  93         List<String> expectedKeys =\r
  94                 ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(), FlowCacheCons.Key.IP_PROTOCOL.get(),\r
  95                         FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
  96 \r
  97         assertEquals(expectedName, flowCache.getName());\r
  98         assertEquals(expectedKeys.size(), keys.size());\r
  99         assertTrue(keys.containsAll(expectedKeys));\r
 100     }\r
 101 \r
 102     @Test\r
 103     public void testCreateFlowCache_IpProtoClassifier_UDP_noEthertype() {\r
 104         ParameterValueList parameterValues = new ParameterValueList();\r
 105         parameterValues.addProto(IpProtoClassifierDefinition.UDP_VALUE);\r
 106 \r
 107         Classifier classifier = newIpProtoClassifier(parameterValues);\r
 108         ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
 109                 providerEpgId, classifier);\r
 110 \r
 111         FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
 112 \r
 113         assertNotNull(flowCache);\r
 114 \r
 115         List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
 116         List<String> expectedKeys =\r
 117                 ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(), FlowCacheCons.Key.IP_PROTOCOL.get(),\r
 118                         FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
 119 \r
 120         assertEquals(expectedName, flowCache.getName());\r
 121         assertEquals(expectedKeys.size(), keys.size());\r
 122         assertTrue(keys.containsAll(expectedKeys));\r
 123     }\r
 124 \r
 125     @Test\r
 126     public void testCreateFlowCache_L4Classifier_dstPort() {\r
 127         ParameterValueList parameterValues = new ParameterValueList();\r
 128         parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
 129             .addProto(IpProtoClassifierDefinition.TCP_VALUE)\r
 130             .addDstPort((long) 80);\r
 131         Classifier classifier = newL4Classifier(parameterValues);\r
 132         ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
 133                 providerEpgId, classifier);\r
 134 \r
 135         FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
 136 \r
 137         assertNotNull(flowCache);\r
 138 \r
 139         List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
 140         List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
 141                 FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.TCP_DST_PORT.get(),\r
 142                 FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
 143 \r
 144         assertEquals(expectedName, flowCache.getName());\r
 145         assertEquals(expectedKeys.size(), keys.size());\r
 146         assertTrue(keys.containsAll(expectedKeys));\r
 147 \r
 148         ParameterValueList parameterValuesUDP = new ParameterValueList();\r
 149         parameterValuesUDP.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
 150             .addProto(IpProtoClassifierDefinition.UDP_VALUE)\r
 151             .addDstPort((long) 80);\r
 152         Classifier classifierUDP = newL4Classifier(parameterValuesUDP);\r
 153         ResolvedPolicy rpUDP = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
 154                 providerEpgId, classifierUDP);\r
 155 \r
 156         FlowCache flowCacheUDP = callCreateFlowCache(rpUDP, classifierUDP);\r
 157 \r
 158         assertNotNull(flowCacheUDP);\r
 159 \r
 160         List<String> keysUDP = Arrays.asList(flowCacheUDP.getKeyNames());\r
 161         List<String> expectedKeysUDP = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
 162                 FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.UDP_DST_PORT.get(),\r
 163                 FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
 164 \r
 165         assertEquals(expectedName, flowCacheUDP.getName());\r
 166         assertEquals(expectedKeysUDP.size(), keysUDP.size());\r
 167         assertTrue(keysUDP.containsAll(expectedKeysUDP));\r
 168     }\r
 169 \r
 170     @Test\r
 171     public void testCreateFlowCache_L4Classifier_srcPort() {\r
 172         ParameterValueList parameterValues = new ParameterValueList();\r
 173         parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
 174             .addProto(IpProtoClassifierDefinition.TCP_VALUE)\r
 175             .addSrcPort((long) 80);\r
 176         Classifier classifier = newL4Classifier(parameterValues);\r
 177         ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
 178                 providerEpgId, classifier);\r
 179 \r
 180         FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
 181 \r
 182         assertNotNull(flowCache);\r
 183 \r
 184         List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
 185         List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
 186                 FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.TCP_SRC_PORT.get(),\r
 187                 FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
 188 \r
 189         assertEquals(expectedName, flowCache.getName());\r
 190         assertEquals(expectedKeys.size(), keys.size());\r
 191         assertTrue(keys.containsAll(expectedKeys));\r
 192 \r
 193         ParameterValueList parameterValuesUDP = new ParameterValueList();\r
 194         parameterValuesUDP.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
 195             .addProto(IpProtoClassifierDefinition.UDP_VALUE)\r
 196             .addSrcPort((long) 80);\r
 197         Classifier classifierUDP = newL4Classifier(parameterValuesUDP);\r
 198         ResolvedPolicy rpUDP = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
 199                 providerEpgId, classifierUDP);\r
 200 \r
 201         FlowCache flowCacheUDP = callCreateFlowCache(rpUDP, classifierUDP);\r
 202 \r
 203         assertNotNull(flowCacheUDP);\r
 204 \r
 205         List<String> keysUDP = Arrays.asList(flowCacheUDP.getKeyNames());\r
 206         List<String> expectedKeysUDP = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
 207                 FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.UDP_SRC_PORT.get(),\r
 208                 FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
 209 \r
 210         assertEquals(expectedName, flowCacheUDP.getName());\r
 211         assertEquals(expectedKeysUDP.size(), keysUDP.size());\r
 212         assertTrue(keysUDP.containsAll(expectedKeysUDP));\r
 213     }\r
 214 \r
 215     private Classifier newClassifier(ClassifierDefinitionId classifierDefinitionId,\r
 216             ParameterValueList parameterValues) {\r
 217         return new ClassifierBuilder().setName(classifierName)\r
 218             .setClassifierDefinitionId(classifierDefinitionId)\r
 219             .setParameterValue(parameterValues)\r
 220             .build();\r
 221     }\r
 222 \r
 223     private Classifier newEtherTypeClassifier(ParameterValueList parameterValues) {\r
 224         return newClassifier(EtherTypeClassifierDefinition.ID, parameterValues);\r
 225     }\r
 226 \r
 227     private Classifier newIpProtoClassifier(ParameterValueList parameterValues) {\r
 228         return newClassifier(IpProtoClassifierDefinition.ID, parameterValues);\r
 229     }\r
 230 \r
 231     private Classifier newL4Classifier(ParameterValueList parameterValues) {\r
 232         return newClassifier(L4ClassifierDefinition.ID, parameterValues);\r
 233     }\r
 234 \r
 235     private FlowCache callCreateFlowCache(ResolvedPolicy rp, Classifier classifier) {\r
 236         return FlowCacheFactory.createFlowCache(\r
 237                 TestUtils.getClassifierIid(ResolvedPolicyClassifierListener.resolveClassifiers(rp, rpIid)), classifier,\r
 238                 FlowCacheCons.Value.BYTES);\r
 239     }\r
 240 \r
 241 }\r