groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/resolver/ForwardingResolverTest.java

   1 package org.opendaylight.groupbasedpolicy.resolver;
   2
   3 import java.util.Arrays;
   4 import java.util.Collection;
   5
   6 import org.junit.Assert;
   7 import org.junit.Before;
   8 import org.junit.Test;
   9 import org.mockito.Mockito;
  10 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  11 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  12 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  14 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
  15 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenantBuilder;
  20 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  21
  22 import com.google.common.base.Optional;
  23
  24 public class ForwardingResolverTest extends CustomDataBrokerTest {
  25
  26     private static final TenantId TENANT_ID_1 = new TenantId("tenant_1");
  27
  28     private ForwardingResolver fwdResolver;
  29
  30     @Before
  31     public void init() {
  32         fwdResolver = new ForwardingResolver(getDataBroker());
  33     }
  34
  35     @Override
  36     public Collection<Class<?>> getClassesFromModules() {
  37         return Arrays.asList(Forwarding.class);
  38     }
  39
  40     @Test
  41     public void testOnWrite() throws Exception {
  42         ForwardingByTenant forwardingByTenant = new ForwardingByTenantBuilder().setTenantId(TENANT_ID_1).build();
  43         DataObjectModification<ForwardingByTenant> domMock = Mockito.mock(DataObjectModification.class);
  44         Mockito.when(domMock.getDataAfter()).thenReturn(forwardingByTenant);
  45         InstanceIdentifier<ForwardingByTenant> forwardingByTenantIid = IidFactory.forwardingByTenantIid(TENANT_ID_1);
  46         fwdResolver.onWrite(domMock, forwardingByTenantIid);
  47
  48         ReadOnlyTransaction rTx = getDataBroker().newReadOnlyTransaction();
  49         Optional<ForwardingByTenant> potenatialFwdByTenant =
  50                 rTx.read(LogicalDatastoreType.OPERATIONAL, forwardingByTenantIid).get();
  51         Assert.assertTrue(potenatialFwdByTenant.isPresent());
  52         Assert.assertEquals(forwardingByTenant, potenatialFwdByTenant.get());
  53     }
  54
  55     @Test
  56     public void testOnSubtreeModified() throws Exception {
  57         ForwardingByTenant forwardingByTenant = new ForwardingByTenantBuilder().setTenantId(TENANT_ID_1).build();
  58         DataObjectModification<ForwardingByTenant> domMock = Mockito.mock(DataObjectModification.class);
  59         Mockito.when(domMock.getDataAfter()).thenReturn(forwardingByTenant);
  60         InstanceIdentifier<ForwardingByTenant> forwardingByTenantIid = IidFactory.forwardingByTenantIid(TENANT_ID_1);
  61         fwdResolver.onSubtreeModified(domMock, forwardingByTenantIid);
  62
  63         ReadOnlyTransaction rTx = getDataBroker().newReadOnlyTransaction();
  64         Optional<ForwardingByTenant> potenatialFwdByTenant =
  65                 rTx.read(LogicalDatastoreType.OPERATIONAL, forwardingByTenantIid).get();
  66         Assert.assertTrue(potenatialFwdByTenant.isPresent());
  67         Assert.assertEquals(forwardingByTenant, potenatialFwdByTenant.get());
  68     }
  69
  70     @Test
  71     public void testOnDelete() throws Exception {
  72         ForwardingByTenant forwardingByTenant = new ForwardingByTenantBuilder().setTenantId(TENANT_ID_1).build();
  73         InstanceIdentifier<ForwardingByTenant> forwardingByTenantIid = IidFactory.forwardingByTenantIid(TENANT_ID_1);
  74         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
  75         wTx.put(LogicalDatastoreType.OPERATIONAL, forwardingByTenantIid, forwardingByTenant);
  76         wTx.submit().get();
  77         ReadOnlyTransaction rTx = getDataBroker().newReadOnlyTransaction();
  78         Optional<ForwardingByTenant> potenatialFwdByTenant =
  79                 rTx.read(LogicalDatastoreType.OPERATIONAL, forwardingByTenantIid).get();
  80         Assert.assertTrue(potenatialFwdByTenant.isPresent());
  81         fwdResolver.onDelete(null, forwardingByTenantIid);
  82
  83         rTx = getDataBroker().newReadOnlyTransaction();
  84         potenatialFwdByTenant = rTx.read(LogicalDatastoreType.OPERATIONAL, forwardingByTenantIid).get();
  85         Assert.assertFalse(potenatialFwdByTenant.isPresent());
  86     }
  87
  88     @Test
  89     public void testUpdateForwarding() throws Exception {
  90         ForwardingByTenant forwardingByTenant = new ForwardingByTenantBuilder().setTenantId(TENANT_ID_1).build();
  91         InstanceIdentifier<ForwardingByTenant> forwardingByTenantIid = IidFactory.forwardingByTenantIid(TENANT_ID_1);
  92         fwdResolver.updateForwarding(forwardingByTenantIid, forwardingByTenant);
  93
  94         ReadOnlyTransaction rTx = getDataBroker().newReadOnlyTransaction();
  95         Optional<ForwardingByTenant> potenatialFwdByTenant =
  96                 rTx.read(LogicalDatastoreType.OPERATIONAL, forwardingByTenantIid).get();
  97         Assert.assertTrue(potenatialFwdByTenant.isPresent());
  98         Assert.assertEquals(forwardingByTenant, potenatialFwdByTenant.get());
  99     }
 100
 101 }