neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/test/PolicyAssert.java

   1 package org.opendaylight.groupbasedpolicy.neutron.mapper.test;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertFalse;
   5 import static org.junit.Assert.assertNotNull;
   6 import static org.junit.Assert.assertNull;
   7 import static org.junit.Assert.assertTrue;
   8
   9 import java.util.Collection;
  10 import java.util.List;
  11 import java.util.Set;
  12
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.SecRuleEntityDecoder;
  15 import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.SecRuleNameDecoder;
  16 import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.action.refs.ActionRef;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Policy;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup.IntraGroupPolicy;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Clause;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Subject;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.Rule;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerNamedSelector;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderNamedSelector;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.rules.attributes.security.rules.SecurityRule;
  37
  38 import com.google.common.base.Optional;
  39 import com.google.common.base.Preconditions;
  40
  41 public final class PolicyAssert {
  42
  43     private PolicyAssert() {
  44         throw new UnsupportedOperationException("Cannot create an instance");
  45     }
  46
  47     // asserts for tenant
  48
  49     public static void assertTenantExists(DataBroker dataBroker, String tenantId) throws Exception {
  50         Optional<Tenant> tenant = ConfigDataStoreReader.readTenant(dataBroker, tenantId);
  51         assertTrue(tenant.isPresent());
  52     }
  53
  54     public static void assertTenantNotExists(DataBroker dataBroker, String tenantId) throws Exception {
  55         Optional<Tenant> tenant = ConfigDataStoreReader.readTenant(dataBroker, tenantId);
  56         assertFalse(tenant.isPresent());
  57     }
  58
  59     // asserts for contract
  60
  61     public static void assertContractExists(DataBroker dataBroker, String tenantId, String contractId) throws Exception {
  62         Optional<Contract> contract = ConfigDataStoreReader.readContract(dataBroker, tenantId, contractId);
  63         assertTrue(contract.isPresent());
  64     }
  65
  66     public static void assertContractNotExists(DataBroker dataBroker, String tenantId, String contractId)
  67             throws Exception {
  68         Optional<Contract> contract = ConfigDataStoreReader.readContract(dataBroker, tenantId, contractId);
  69         assertFalse(contract.isPresent());
  70     }
  71
  72     public static void assertContractCount(DataBroker dataBroker, String tenantId, int expectedCount) throws Exception {
  73         Optional<Tenant> tenant = ConfigDataStoreReader.readTenant(dataBroker, tenantId);
  74         assertTrue(tenant.isPresent());
  75         Policy policy = tenant.get().getPolicy();
  76         if (policy == null) {
  77             assertEquals(expectedCount, 0);
  78         } else {
  79             List<Contract> contracts = policy.getContract();
  80             if (contracts != null) {
  81                 assertEquals(expectedCount, policy.getContract().size());
  82             } else {
  83                 assertEquals(expectedCount, 0);
  84             }
  85         }
  86     }
  87
  88     public static void assertContractWithEic(Contract contract, SecurityRule secRule) {
  89         assertEquals(new ContractId(secRule.getUuid().getValue()), contract.getId());
  90         assertNull(contract.getQuality());
  91         assertNull(contract.getTarget());
  92         assertOneClauseWithEicWithOneSubject(contract, secRule);
  93         PolicyAssert.assertOneSubjectWithOneRule(contract, secRule);
  94     }
  95
  96     private static void assertOneClauseWithEicWithOneSubject(Contract contract, SecurityRule secRule) {
  97         Clause clause = assertOneItem(contract.getClause());
  98         assertNull(clause.getAnyMatchers());
  99         IpPrefix expectedIpPrefix = secRule.getRemoteIpPrefix();
 100         assertNotNull(clause.getConsumerMatchers());
 101         IpPrefix ipPrefix = clause.getConsumerMatchers()
 102             .getEndpointIdentificationConstraints()
 103             .getL3EndpointIdentificationConstraints()
 104             .getPrefixConstraint()
 105             .get(0)
 106             .getIpPrefix();
 107         assertEquals(expectedIpPrefix, ipPrefix);
 108         SubjectName subjectRef = assertOneItem(clause.getSubjectRefs());
 109         assertEquals(SecRuleNameDecoder.getSubjectName(secRule), subjectRef);
 110     }
 111
 112     public static void assertContract(Contract contract, SecurityRule secRule) {
 113         assertEquals(new ContractId(secRule.getUuid().getValue()), contract.getId());
 114         assertNull(contract.getQuality());
 115         assertNull(contract.getTarget());
 116         assertOneClauseWithOneSubject(contract, secRule);
 117         assertOneSubjectWithOneRule(contract, secRule);
 118     }
 119
 120     private static void assertOneClauseWithOneSubject(Contract contract, SecurityRule secRule) {
 121         Clause clause = assertOneItem(contract.getClause());
 122         assertClauseWithOneSubject(clause, secRule);
 123     }
 124
 125     private static void assertOneSubjectWithOneRule(Contract contract, SecurityRule secRule) {
 126         Subject subject = assertOneItem(contract.getSubject());
 127         assertSubjectWithOneRule(subject, secRule);
 128     }
 129
 130     public static void assertEndpointGroupExists(DataBroker dataBroker, String tenantId, String endpointGroupId)
 131             throws Exception {
 132         Optional<EndpointGroup> epg = ConfigDataStoreReader.readEndpointGroup(dataBroker, tenantId, endpointGroupId);
 133         assertTrue(epg.isPresent());
 134     }
 135
 136     public static void assertEndpointGroupNotExists(DataBroker dataBroker, String tenantId, String endpointGroupId)
 137             throws Exception {
 138         Optional<EndpointGroup> epg = ConfigDataStoreReader.readEndpointGroup(dataBroker, tenantId, endpointGroupId);
 139         assertFalse(epg.isPresent());
 140     }
 141
 142     public static void assertEndpointGroupCount(DataBroker dataBroker, String tenantId, int expectedCount)
 143             throws Exception {
 144         Optional<Tenant> tenant = ConfigDataStoreReader.readTenant(dataBroker, tenantId);
 145         assertTrue(tenant.isPresent());
 146         Policy policy = tenant.get().getPolicy();
 147         if (policy == null) {
 148             assertEquals(expectedCount, 0);
 149         } else {
 150             List<EndpointGroup> endpointGroups = policy.getEndpointGroup();
 151             if (endpointGroups != null) {
 152                 assertEquals(expectedCount, endpointGroups.size());
 153             } else {
 154                 assertEquals(expectedCount, 0);
 155             }
 156         }
 157     }
 158
 159     public static void assertIntraGroupPolicy(DataBroker dataBroker, String tenantId, String endpointGroupId,
 160             IntraGroupPolicy intraGroupPolicy) throws Exception {
 161         Optional<EndpointGroup> epg = ConfigDataStoreReader.readEndpointGroup(dataBroker, tenantId, endpointGroupId);
 162         assertTrue(epg.isPresent());
 163         assertEquals(intraGroupPolicy, epg.get().getIntraGroupPolicy());
 164     }
 165
 166     // asserts for endpoint group selectors
 167
 168     public static void assertNoProviderNamedSelectors(DataBroker dataBroker, String tenantId, String secGroupId)
 169             throws Exception {
 170         Optional<EndpointGroup> epg = ConfigDataStoreReader.readEndpointGroup(dataBroker, tenantId, secGroupId);
 171         assertTrue(epg.isPresent());
 172         List<ProviderNamedSelector> selectors = epg.get().getProviderNamedSelector();
 173         assertTrue(selectors == null || selectors.isEmpty());
 174     }
 175
 176     public static void assertNoConsumerNamedSelectors(DataBroker dataBroker, String tenantId, String secGroupId)
 177             throws Exception {
 178         Optional<EndpointGroup> epg = ConfigDataStoreReader.readEndpointGroup(dataBroker, tenantId, secGroupId);
 179         assertTrue(epg.isPresent());
 180         List<ConsumerNamedSelector> selectors = epg.get().getConsumerNamedSelector();
 181         assertTrue(selectors == null || selectors.isEmpty());
 182     }
 183
 184     public static void assertProviderNamedSelectors(EndpointGroup epg, Set<ContractId> expectedContracts) {
 185         Preconditions.checkNotNull(expectedContracts);
 186         assertNotNull(epg.getProviderNamedSelector());
 187         int numberOfContracts = 0;
 188         for (ProviderNamedSelector pns : epg.getProviderNamedSelector()) {
 189             assertNotNull(pns.getContract());
 190             numberOfContracts += pns.getContract().size();
 191             for (ContractId contractId : pns.getContract()) {
 192                 assertTrue(expectedContracts.contains(contractId));
 193             }
 194         }
 195         assertEquals(expectedContracts.size(), numberOfContracts);
 196     }
 197
 198     public static void assertConsumerNamedSelectors(EndpointGroup epg, Set<ContractId> expectedContracts) {
 199         Preconditions.checkNotNull(expectedContracts);
 200         assertNotNull(epg.getConsumerNamedSelector());
 201         int numberOfContracts = 0;
 202         for (ConsumerNamedSelector cns : epg.getConsumerNamedSelector()) {
 203             assertNotNull(cns.getContract());
 204             numberOfContracts += cns.getContract().size();
 205             for (ContractId contractId : cns.getContract()) {
 206                 assertTrue(expectedContracts.contains(contractId));
 207             }
 208         }
 209         assertEquals(expectedContracts.size(), numberOfContracts);
 210     }
 211
 212     // asserts for classifier
 213
 214     public static void assertClassifierInstanceExists(DataBroker dataBroker, SecurityRule secRule)
 215             throws Exception {
 216         ClassifierInstance clsfInstance = SecRuleEntityDecoder.getClassifierInstance(secRule);
 217         Optional<ClassifierInstance> readClsfInstance = ConfigDataStoreReader.readClassifierInstance(dataBroker,
 218                 secRule.getTenantId().getValue(), clsfInstance.getName());
 219         assertTrue(readClsfInstance.isPresent());
 220     }
 221
 222     public static void assertClassifierInstanceExists(DataBroker dataBroker, String tenantId, String classifierName)
 223             throws Exception {
 224         Optional<ClassifierInstance> classifierInstance = ConfigDataStoreReader.readClassifierInstance(dataBroker,
 225                 tenantId, new ClassifierName(classifierName));
 226         assertTrue(classifierInstance.isPresent());
 227     }
 228
 229     public static void assertClassifierInstanceNotExists(DataBroker dataBroker, SecurityRule secRule)
 230             throws Exception {
 231         ClassifierInstance clsfInstance = SecRuleEntityDecoder.getClassifierInstance(secRule);
 232         Optional<ClassifierInstance> readClsfInstance = ConfigDataStoreReader.readClassifierInstance(dataBroker,
 233                 secRule.getTenantId().getValue(), clsfInstance.getName());
 234         assertFalse(readClsfInstance.isPresent());
 235     }
 236
 237     // asserts for action
 238
 239     public static void assertActionInstanceExists(DataBroker dataBroker, String tenantId, ActionName actionName)
 240             throws Exception {
 241         Optional<ActionInstance> actionInstance = ConfigDataStoreReader.readActionInstance(dataBroker, tenantId,
 242                 actionName);
 243         assertTrue(actionInstance.isPresent());
 244     }
 245
 246     public static void assertActionInstanceNotExists(DataBroker dataBroker, String tenantId, ActionName actionName)
 247             throws Exception {
 248         Optional<ActionInstance> actionInstance = ConfigDataStoreReader.readActionInstance(dataBroker, tenantId,
 249                 actionName);
 250         assertFalse(actionInstance.isPresent());
 251     }
 252
 253     // asserts for clause
 254
 255     public static void assertClauseWithOneSubject(Clause clause, SecurityRule secRule) {
 256         assertNull(clause.getAnyMatchers());
 257         assertNull(clause.getConsumerMatchers());
 258         assertNull(clause.getProviderMatchers());
 259         SubjectName subjectRef = assertOneItem(clause.getSubjectRefs());
 260         assertEquals(SecRuleNameDecoder.getSubjectName(secRule), subjectRef);
 261     }
 262
 263     public static void assertClauseExists(DataBroker dataBroker, String tenantId, String contractId, String clauseName) {
 264         Optional<Clause> clause = ConfigDataStoreReader.readClause(dataBroker, tenantId, contractId, clauseName);
 265         assertTrue(clause.isPresent());
 266     }
 267
 268     // asserts for subject
 269
 270     public static void assertSubjectWithOneRule(Subject subject, SecurityRule secRule) {
 271         assertEquals(SecRuleNameDecoder.getSubjectName(secRule), subject.getName());
 272         Rule rule = assertOneItem(subject.getRule());
 273         assertRule(rule, secRule);
 274     }
 275
 276     // asserts for rule
 277
 278     public static void assertRule(Rule rule, SecurityRule secRule) {
 279         assertEquals(SecRuleNameDecoder.getRuleName(secRule), rule.getName());
 280         ActionRef actionRef = assertOneItem(rule.getActionRef());
 281         assertEquals(MappingUtils.ACTION_ALLOW.getName(), actionRef.getName());
 282         ClassifierRef classifierRef = assertOneItem(rule.getClassifierRef());
 283         assertEquals(SecRuleNameDecoder.getClassifierRefName(secRule), classifierRef.getName());
 284         assertEquals(SecRuleNameDecoder.getClassifierInstanceName(secRule), classifierRef.getInstanceName());
 285         assertEquals(SecRuleEntityDecoder.getDirection(secRule), classifierRef.getDirection());
 286     }
 287
 288     public static void assertRule(Rule rule, SecurityRule secRule, int order) {
 289         assertRule(rule, secRule);
 290         assertEquals(order, rule.getOrder().intValue());
 291     }
 292
 293     private static <T> T assertOneItem(Collection<T> c) {
 294         assertNotNull(c);
 295         assertTrue(c.size() == 1);
 296         return c.iterator().next();
 297     }
 298
 299     // asserts for selector
 300
 301     public static void assertConsumerNamedSelectorExists(DataBroker dataBroker, String tenantId, String egId,
 302                                                          String selectorName) {
 303         Optional<ConsumerNamedSelector> potentialCns = ConfigDataStoreReader.readConsumerNamedSelector(dataBroker,
 304                 tenantId, egId, selectorName);
 305         assertTrue(potentialCns.isPresent());
 306     }
 307
 308 }