neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/util/MappingUtilsTest.java

   1 package org.opendaylight.groupbasedpolicy.neutron.mapper.util;
   2
   3 import static com.google.common.base.Preconditions.checkNotNull;
   4 import static org.junit.Assert.assertEquals;
   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.ArrayList;
  10 import java.util.List;
  11
  12 import org.junit.Before;
  13 import org.junit.Test;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.groupbasedpolicy.neutron.mapper.test.GbpDataBrokerTest;
  18 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  19 import org.opendaylight.neutron.spi.Neutron_IPs;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2BridgeDomain;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2BridgeDomainBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2BridgeDomainKey;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2FloodDomain;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2FloodDomainBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2FloodDomainKey;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L3Context;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L3ContextBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L3ContextKey;
  34
  35 public class MappingUtilsTest extends GbpDataBrokerTest {
  36
  37     private final TenantId tenantId = new TenantId("00000000-0000-0000-0000-000000000001");
  38     private final L2FloodDomainId l2FloodDomainId = new L2FloodDomainId("00000000-0000-0000-0000-000000000002");
  39     private final L2BridgeDomainId l2BridgeDomainId = new L2BridgeDomainId("00000000-0000-0000-0000-000000000003");
  40     private final L3ContextId l3ContextId = new L3ContextId("00000000-0000-0000-0000-000000000004");
  41     private final String[] ips = {"170.0.0.1", "170.0.0.2", "170.0.0.3"};
  42     private L2FloodDomainBuilder l2FloodDomainBuilder;
  43     private List<Neutron_IPs> emptyList, singleIp, multiIp;
  44     private L2BridgeDomainBuilder l2BridgeDomainBuilder;
  45     private L3ContextBuilder l3ContextBuilder;
  46
  47     @Before
  48     public void init() {
  49         l2FloodDomainBuilder = new L2FloodDomainBuilder();
  50         l2FloodDomainBuilder.setName(new Name("l2fdn"))
  51                 .setKey(new L2FloodDomainKey(l2FloodDomainId));
  52         l2BridgeDomainBuilder = new L2BridgeDomainBuilder();
  53         l2BridgeDomainBuilder.setName(new Name("l2bdn"))
  54                 .setKey(new L2BridgeDomainKey(l2BridgeDomainId));
  55         l3ContextBuilder = new L3ContextBuilder();
  56         l3ContextBuilder.setName(new Name("l3cn"))
  57                 .setKey(new L3ContextKey(l3ContextId));
  58         Neutron_IPs neutronIp1 = new Neutron_IPs();
  59         Neutron_IPs neutronIp2 = new Neutron_IPs();
  60         Neutron_IPs neutronIp3 = new Neutron_IPs();
  61         neutronIp1.setIpAddress(ips[0]);
  62         neutronIp2.setIpAddress(ips[1]);
  63         neutronIp3.setIpAddress(ips[2]);
  64         emptyList = new ArrayList<>();
  65         singleIp = new ArrayList<>();
  66         singleIp.add(neutronIp1);
  67         multiIp = new ArrayList<>();
  68         multiIp.add(neutronIp1);
  69         multiIp.add(neutronIp2);
  70         multiIp.add(neutronIp3);
  71     }
  72
  73     @Test
  74     public void testCreateForwardingContext1() {
  75         //case #1 - L2FloodDomain is not present in DS
  76         DataBroker dataBroker = getDataBroker();
  77         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
  78         MappingUtils.ForwardingCtx
  79                 forwardingCtx =
  80                 MappingUtils.createForwardingContext(tenantId, l2FloodDomainBuilder.build().getId(), rwTx);
  81         assertNotNull(forwardingCtx);
  82         assertNull(forwardingCtx.getL2FloodDomain());
  83         assertNull(forwardingCtx.getL2BridgeDomain());
  84         assertNull(forwardingCtx.getL3Context());
  85     }
  86
  87     @Test
  88     public void testCreateForwardingContext2() {
  89         //case #2 - L2FloodDomain is present in DS, but its parent is null
  90         DataBroker dataBroker = getDataBroker();
  91         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
  92         l2FloodDomainBuilder.setParent(null);
  93         L2FloodDomain l2FloodDomain = l2FloodDomainBuilder.build();
  94         writeL2FloodDomain(tenantId, l2FloodDomain, rwTx);
  95         MappingUtils.ForwardingCtx
  96                 forwardingCtx =
  97                 MappingUtils.createForwardingContext(tenantId, l2FloodDomainBuilder.build().getId(), rwTx);
  98         assertNotNull(forwardingCtx);
  99         assertTrue(forwardingCtx.getL2FloodDomain().equals(l2FloodDomain));
 100         assertNull(forwardingCtx.getL2BridgeDomain());
 101         assertNull(forwardingCtx.getL3Context());
 102     }
 103
 104     @Test
 105     public void testCreateForwardingContext3() {
 106         //case #3 - L2FloodDomain is present in DS with not-null parent, but L2BridgeDomain is not present in DS
 107         DataBroker dataBroker = getDataBroker();
 108         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 109         l2FloodDomainBuilder.setParent(l2BridgeDomainBuilder.build().getId());
 110         L2FloodDomain l2FloodDomain = l2FloodDomainBuilder.build();
 111         writeL2FloodDomain(tenantId, l2FloodDomain, rwTx);
 112         MappingUtils.ForwardingCtx
 113                 forwardingCtx =
 114                 MappingUtils.createForwardingContext(tenantId, l2FloodDomainBuilder.build().getId(), rwTx);
 115         assertNotNull(forwardingCtx);
 116         assertTrue(forwardingCtx.getL2FloodDomain().equals(l2FloodDomain));
 117         assertNull(forwardingCtx.getL2BridgeDomain());
 118         assertNull(forwardingCtx.getL3Context());
 119     }
 120
 121     @Test
 122     public void testCreateForwardingContext4() {
 123         //case #4 - L2BridgeDomain is also present in DS but with null parent
 124         DataBroker dataBroker = getDataBroker();
 125         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 126         l2BridgeDomainBuilder.setParent(null);
 127         l2FloodDomainBuilder.setParent(l2BridgeDomainBuilder.build().getId());
 128         L2FloodDomain l2FloodDomain = l2FloodDomainBuilder.build();
 129         L2BridgeDomain l2BridgeDomain = l2BridgeDomainBuilder.build();
 130         writeL2FloodDomain(tenantId, l2FloodDomain, rwTx);
 131         writeL2BridgeDomain(tenantId, l2BridgeDomain, rwTx);
 132         MappingUtils.ForwardingCtx
 133                 forwardingCtx =
 134                 MappingUtils.createForwardingContext(tenantId, l2FloodDomainBuilder.build().getId(), rwTx);
 135         assertNotNull(forwardingCtx);
 136         assertTrue(forwardingCtx.getL2FloodDomain().equals(l2FloodDomain));
 137         assertTrue(forwardingCtx.getL2BridgeDomain().equals(l2BridgeDomain));
 138         assertNull(forwardingCtx.getL3Context());
 139     }
 140
 141     @Test
 142     public void testCreateForwardingContext5() {
 143         //case #5 - L2BridgeDomain is also present in DS with not-null parent, but L3Context is not present in DS
 144         DataBroker dataBroker = getDataBroker();
 145         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 146         l2BridgeDomainBuilder.setParent(l3ContextBuilder.build().getId());
 147         l2FloodDomainBuilder.setParent(l2BridgeDomainBuilder.build().getId());
 148         L2FloodDomain l2FloodDomain = l2FloodDomainBuilder.build();
 149         L2BridgeDomain l2BridgeDomain = l2BridgeDomainBuilder.build();
 150         writeL2FloodDomain(tenantId, l2FloodDomain, rwTx);
 151         writeL2BridgeDomain(tenantId, l2BridgeDomain, rwTx);
 152         MappingUtils.ForwardingCtx
 153                 forwardingCtx =
 154                 MappingUtils.createForwardingContext(tenantId, l2FloodDomainBuilder.build().getId(), rwTx);
 155         assertNotNull(forwardingCtx);
 156         assertTrue(forwardingCtx.getL2FloodDomain().equals(l2FloodDomain));
 157         assertTrue(forwardingCtx.getL2BridgeDomain().equals(l2BridgeDomain));
 158         assertNull(forwardingCtx.getL3Context());
 159     }
 160
 161     @Test
 162     public void testCreateForwardingContext6() {
 163         //case #6 - L3Context present in DS
 164         DataBroker dataBroker = getDataBroker();
 165         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 166         l2BridgeDomainBuilder.setParent(l3ContextBuilder.build().getId());
 167         l2FloodDomainBuilder.setParent(l2BridgeDomainBuilder.build().getId());
 168         L2FloodDomain l2FloodDomain = l2FloodDomainBuilder.build();
 169         L2BridgeDomain l2BridgeDomain = l2BridgeDomainBuilder.build();
 170         L3Context l3Context = l3ContextBuilder.build();
 171         writeL2FloodDomain(tenantId, l2FloodDomain, rwTx);
 172         writeL2BridgeDomain(tenantId, l2BridgeDomain, rwTx);
 173         writeL3Context(tenantId, l3Context, rwTx);
 174         MappingUtils.ForwardingCtx
 175                 forwardingCtx =
 176                 MappingUtils.createForwardingContext(tenantId, l2FloodDomainBuilder.build().getId(), rwTx);
 177         assertNotNull(forwardingCtx);
 178         assertTrue(forwardingCtx.getL2FloodDomain().equals(l2FloodDomain));
 179         assertTrue(forwardingCtx.getL2BridgeDomain().equals(l2BridgeDomain));
 180         assertTrue(forwardingCtx.getL3Context().equals(l3Context));
 181     }
 182
 183     @Test
 184     public void testGetFirstIpNullIp() {
 185         Neutron_IPs result = MappingUtils.getFirstIp(emptyList);
 186         assertNull(result);
 187     }
 188
 189     @Test
 190     public void testGetFirstIpOneIp() {
 191         Neutron_IPs result = MappingUtils.getFirstIp(singleIp);
 192         assertNotNull(result);
 193         assertEquals(result.getIpAddress(), ips[0]);
 194     }
 195
 196     @Test
 197     public void testGetFirstIpMoreIps() {
 198         Neutron_IPs result = MappingUtils.getFirstIp(multiIp);
 199         assertNotNull(result);
 200         assertEquals(result.getIpAddress(), ips[0]);
 201     }
 202
 203     private void writeL2FloodDomain(TenantId tenantId, L2FloodDomain l2Fd, ReadWriteTransaction rwTx) {
 204         checkNotNull(l2Fd);
 205         L2FloodDomainId l2FdId = l2Fd.getId();
 206         rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2FloodDomainIid(tenantId, l2FdId), l2Fd);
 207     }
 208
 209     private void writeL2BridgeDomain(TenantId tenantId, L2BridgeDomain l2Bd, ReadWriteTransaction rwTx) {
 210         checkNotNull(l2Bd);
 211         L2BridgeDomainId l2BdId = l2Bd.getId();
 212         rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BdId), l2Bd);
 213     }
 214
 215     private void writeL3Context(TenantId tenantId, L3Context l3Ct, ReadWriteTransaction rwTx) {
 216         checkNotNull(l3Ct);
 217         L3ContextId l3CtId = l3Ct.getId();
 218         rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l3ContextIid(tenantId, l3CtId), l3Ct);
 219     }
 220
 221 }