renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/commands/DhcpRelayTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems. 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
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;
  10
  11 import java.util.Collections;
  12 import java.util.List;
  13 import java.util.concurrent.ExecutionException;
  14
  15 import org.junit.Assert;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  19 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.groupbasedpolicy.renderer.vpp.VppRendererDataBrokerTest;
  23 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
  25 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.dhcp.rev170315.Ipv4;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.dhcp.rev170315.dhcp.attributes.relays.Relay;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.dhcp.rev170315.dhcp.attributes.relays.RelayBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.dhcp.rev170315.dhcp.attributes.relays.RelayKey;
  32
  33 import com.google.common.base.Optional;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.dhcp.rev170315.relay.attributes.Server;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.dhcp.rev170315.relay.attributes.ServerBuilder;
  36
  37 public class DhcpRelayTest extends VppRendererDataBrokerTest {
  38
  39     private static final IpAddress GATEWAY_IP_ADDRESS = new IpAddress(new Ipv4Address("10.0.0.1"));
  40     private static final IpAddress GATEWAY_IP_ADDRESS_2 = new IpAddress(new Ipv4Address("20.0.0.1"));
  41     private static final IpAddress SERVER_IP_ADDRESS = new IpAddress(new Ipv4Address("10.0.0.2"));
  42     private static final IpAddress SERVER_IP_ADDRESS_2 = new IpAddress(new Ipv4Address("20.0.0.2"));
  43     private static final long RX_VRF_ID = 0L;
  44     private static final long RX_VRF_ID_2 = 2L;
  45     private static final long SERVER_VRF_ID = 1L;
  46     private static final long SERVER_VRF_ID_2 = 3L;
  47     private DataBroker dataBroker;
  48
  49     public static final List<Server> SERVER_LIST_1 =
  50         Collections.singletonList(new ServerBuilder().setVrfId(SERVER_VRF_ID).setAddress(SERVER_IP_ADDRESS).build());
  51     public static final List<Server> SERVER_LIST_2 =
  52         Collections.singletonList(new ServerBuilder().setVrfId(SERVER_VRF_ID).setAddress(SERVER_IP_ADDRESS).build());
  53
  54     private static final Relay RELAY = new RelayBuilder()
  55         .setAddressType(Ipv4.class)
  56         .setGatewayAddress(GATEWAY_IP_ADDRESS)
  57         .setServer(SERVER_LIST_1)
  58         .setRxVrfId(RX_VRF_ID)
  59         .build();
  60
  61     @Before
  62     public void init() {
  63         dataBroker = getDataBroker();
  64     }
  65
  66     @Test
  67     public void addDhcpRelayCommandTest() throws ExecutionException, InterruptedException {
  68         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
  69
  70         DhcpRelayCommand dhcpRelayCommand =
  71             DhcpRelayCommand.builder()
  72                 .setAddressType(Ipv4.class)
  73                 .setGatewayIpAddress(GATEWAY_IP_ADDRESS)
  74                 .setServerIpAddresses(SERVER_LIST_1)
  75                 .setOperation(General.Operations.PUT)
  76                 .setRxVrfId(RX_VRF_ID)
  77                 .build();
  78
  79         Assert.assertEquals(Ipv4.class, dhcpRelayCommand.getAddressType());
  80         Assert.assertEquals(General.Operations.PUT, dhcpRelayCommand.getOperation());
  81         Assert.assertEquals(GATEWAY_IP_ADDRESS, dhcpRelayCommand.getGatewayIpAddress());
  82         Assert.assertEquals(SERVER_LIST_1, dhcpRelayCommand.getServerIpAddresses());
  83         Assert.assertEquals(RX_VRF_ID, dhcpRelayCommand.getRxVrfId().longValue());
  84
  85         Optional<Relay> relayOptional = executeCommand(rwTx, dhcpRelayCommand);
  86
  87         Assert.assertTrue(relayOptional.isPresent());
  88         Assert.assertEquals(RELAY, relayOptional.get());
  89     }
  90
  91     @Test
  92     public void removeDhcpRelayCommandTest() throws ExecutionException, InterruptedException {
  93         Optional<Relay> optional = writeBasicRelay();
  94         ReadWriteTransaction rwTx;
  95
  96         Assert.assertTrue(optional.isPresent());
  97
  98         rwTx = dataBroker.newReadWriteTransaction();
  99         DhcpRelayCommand dhcpRelayCommand =
 100             DhcpRelayCommand.builder()
 101                 .setOperation(General.Operations.DELETE)
 102                 .setAddressType(Ipv4.class)
 103                 .setRxVrfId(RX_VRF_ID)
 104                 .build();
 105         dhcpRelayCommand.execute(rwTx);
 106         rwTx.submit();
 107
 108         optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 109             VppIidFactory.getDhcpRelayIid(dhcpRelayCommand.getDhcpBuilder().getKey()),
 110             dataBroker.newReadOnlyTransaction());
 111
 112         Assert.assertFalse(optional.isPresent());
 113     }
 114
 115     @Test
 116     public void mergeDhcpRelayCommandTest() throws ExecutionException, InterruptedException {
 117         Optional<Relay> optional = writeBasicRelay();
 118         ReadWriteTransaction rwTx;
 119
 120         Assert.assertTrue(optional.isPresent());
 121
 122         rwTx = dataBroker.newReadWriteTransaction();
 123
 124         DhcpRelayCommand dhcpRelayCommand =
 125             DhcpRelayCommand.builder()
 126                 .setAddressType(Ipv4.class)
 127                 .setGatewayIpAddress(GATEWAY_IP_ADDRESS_2)
 128                 .setServerIpAddresses(SERVER_LIST_2)
 129                 .setOperation(General.Operations.MERGE)
 130                 .setRxVrfId(RX_VRF_ID_2)
 131                 .build();
 132
 133         dhcpRelayCommand.execute(rwTx);
 134         rwTx.submit();
 135
 136         optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 137             VppIidFactory.getDhcpRelayIid(dhcpRelayCommand.getDhcpBuilder().getKey()),
 138             dataBroker.newReadOnlyTransaction());
 139
 140         Assert.assertTrue(optional.isPresent());
 141         Relay relay = optional.get();
 142
 143         Assert.assertEquals(Ipv4.class, relay.getAddressType());
 144         Assert.assertEquals(GATEWAY_IP_ADDRESS_2, relay.getGatewayAddress());
 145         Assert.assertEquals(SERVER_LIST_2, relay.getServer());
 146         Assert.assertEquals(RX_VRF_ID_2, relay.getRxVrfId().longValue());
 147     }
 148
 149     private Optional<Relay> executeCommand(ReadWriteTransaction rwTx, DhcpRelayCommand dhcpRelayCommand)
 150         throws ExecutionException, InterruptedException {
 151         dhcpRelayCommand.execute(rwTx);
 152
 153         rwTx.submit().get();
 154
 155         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 156
 157         return DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 158             VppIidFactory.getDhcpRelayIid(dhcpRelayCommand.getDhcpBuilder().getKey()), rTx);
 159     }
 160
 161     private Optional<Relay> writeBasicRelay() throws InterruptedException, ExecutionException {
 162         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 163         rwTx.put(LogicalDatastoreType.CONFIGURATION,
 164             VppIidFactory.getDhcpRelayIid(new RelayKey(Ipv4.class, RX_VRF_ID)), RELAY, true);
 165         rwTx.submit().get();
 166
 167         return DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 168             VppIidFactory.getDhcpRelayIid(new RelayKey(Ipv4.class, RX_VRF_ID)),
 169             dataBroker.newReadOnlyTransaction());
 170     }
 171 }