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

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