groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/endpoint/EndPointRpcRegistryTest.java

   1 package org.opendaylight.groupbasedpolicy.endpoint;
   2
   3 import com.google.common.util.concurrent.CheckedFuture;
   4 import org.junit.Before;
   5 import org.junit.Test;
   6 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
   7 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
   8 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
   9 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  10 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
  11 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  12 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  13 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.*;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3Address;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.has.endpoint.group.conditions.EndpointGroupCondition;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L2;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L3;
  23 import org.opendaylight.yangtools.yang.binding.DataObject;
  24 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  25 import org.opendaylight.yangtools.yang.binding.RpcService;
  26
  27 import java.lang.reflect.Constructor;
  28 import java.util.ArrayList;
  29 import java.util.List;
  30 import java.util.concurrent.ScheduledExecutorService;
  31
  32 import static org.mockito.Matchers.any;
  33 import static org.mockito.Mockito.*;
  34
  35 public class EndPointRpcRegistryTest {
  36
  37     private DataBroker dataProvider;
  38     private RpcProviderRegistry rpcRegistry;
  39     private RpcRegistration<EndpointService> rpcRegistration;
  40     private WriteTransaction t;
  41     private EpRendererAugmentation epRendererAugmentation;
  42
  43     private EndpointRpcRegistry endpointRpcRegistry;
  44
  45     @SuppressWarnings("unchecked")
  46     @Before
  47     public void initialisation() {
  48         dataProvider = mock(DataBroker.class);
  49         rpcRegistry = mock(RpcProviderRegistry.class);
  50         epRendererAugmentation = mock(EpRendererAugmentation.class);
  51
  52         t = mock(WriteTransaction.class);
  53         when(dataProvider.newWriteOnlyTransaction()).thenReturn(t);
  54         CheckedFuture<Void, TransactionCommitFailedException> f = mock(CheckedFuture.class);
  55         when(t.submit()).thenReturn(f);
  56
  57         rpcRegistration = mock(RpcRegistration.class);
  58         when(rpcRegistry.addRpcImplementation(any(Class.class), any(RpcService.class))).thenReturn(rpcRegistration);
  59     }
  60
  61     @SuppressWarnings("unchecked")
  62     @Test
  63     public void registerTest() throws Exception {
  64         EndpointRpcRegistry.register(dataProvider, rpcRegistry, epRendererAugmentation);
  65         verify(rpcRegistry).addRpcImplementation(any(Class.class), any(RpcService.class));
  66         verify(t).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Endpoints.class));
  67
  68         EndpointRpcRegistry.unregister(epRendererAugmentation);
  69         verify(rpcRegistration).close();
  70     }
  71
  72     @Test
  73     public void registerTestSafelyFail() {
  74         EndpointRpcRegistry.register(null, rpcRegistry, epRendererAugmentation);
  75         EndpointRpcRegistry.register(dataProvider, null, epRendererAugmentation);
  76         EndpointRpcRegistry.register(null, rpcRegistry, null);
  77         EndpointRpcRegistry.register(dataProvider, null, null);
  78         EndpointRpcRegistry.register(dataProvider, rpcRegistry, null);
  79     }
  80
  81     @Test
  82     public void unregisterTestFail() throws Exception {
  83         EndpointRpcRegistry.unregister(null);
  84         verify(rpcRegistration, never()).close();
  85
  86         EpRendererAugmentation epRendererAugmentation = mock(EpRendererAugmentation.class);
  87         EndpointRpcRegistry.unregister(epRendererAugmentation);
  88         verify(rpcRegistration, never()).close();
  89     }
  90
  91     @Test
  92     public void registerEndpointTest()throws Exception{
  93         setPrivateInstanceByReflexion();
  94         endpointRpcRegistry.registerEndpoint(setRegisterEndpointVariablesForTest());
  95         verify(t, times(1)).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(DataObject.class), eq(true));
  96
  97         endpointRpcRegistry.registerEndpoint(setL3AddressVariableForTest());
  98         verify(t, times(2)).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(DataObject.class), eq(true));
  99     }
 100
 101     private RegisterEndpointInput setRegisterEndpointVariablesForTest() throws Exception{
 102         RegisterEndpointInputBuilder registerEndpointInputBuilder = new RegisterEndpointInputBuilder();
 103         L2BridgeDomainId l2BridgeDomainIdMock = mock(L2BridgeDomainId.class);
 104         registerEndpointInputBuilder.setL2Context(l2BridgeDomainIdMock);
 105         MacAddress macAddressMock = mock(MacAddress.class);
 106         registerEndpointInputBuilder.setMacAddress(macAddressMock);
 107         return registerEndpointInputBuilder.build();
 108     }
 109
 110     private RegisterEndpointInput setL3AddressVariableForTest(){
 111         RegisterEndpointInputBuilder registerEndpointInputBuilder = new RegisterEndpointInputBuilder();
 112         L3Address l3AddressMock = mock(L3Address.class);
 113         List<L3Address> l3AddressList = new ArrayList<>();
 114         l3AddressList.add(l3AddressMock);
 115         registerEndpointInputBuilder.setL3Address(l3AddressList);
 116         return registerEndpointInputBuilder.build();
 117     }
 118
 119     private void setPrivateInstanceByReflexion() throws Exception{
 120         ScheduledExecutorService scheduledExecutorServiceMock = mock(ScheduledExecutorService.class);
 121         Constructor[] cons = EndpointRpcRegistry.class.getDeclaredConstructors();
 122         cons[0].setAccessible(true);
 123         endpointRpcRegistry = (EndpointRpcRegistry)cons[0].newInstance(dataProvider, rpcRegistry, scheduledExecutorServiceMock);
 124     }
 125
 126     @Test
 127     public void registerL3PrefixEndpointTest()throws Exception{
 128         setPrivateInstanceByReflexion();
 129         endpointRpcRegistry.registerL3PrefixEndpoint(setL3PrefixTestVariables());
 130         verify(t, atLeast(1)).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(DataObject.class));
 131     }
 132
 133     private RegisterL3PrefixEndpointInput setL3PrefixTestVariables(){
 134         RegisterL3PrefixEndpointInputBuilder registerL3PrefixEndpointInputBuilder = new RegisterL3PrefixEndpointInputBuilder();
 135         L3ContextId l3ContextIdMock = mock(L3ContextId.class);
 136         registerL3PrefixEndpointInputBuilder.setL3Context(l3ContextIdMock);
 137         IpPrefix ipPrefixMock = mock(IpPrefix.class);
 138         registerL3PrefixEndpointInputBuilder.setIpPrefix(ipPrefixMock);
 139         TenantId tenantIdMock = mock(TenantId.class);
 140         registerL3PrefixEndpointInputBuilder.setTenant(tenantIdMock);
 141         return registerL3PrefixEndpointInputBuilder.build();
 142     }
 143
 144     @Test
 145     public void unregisterEndpointTest() throws Exception{
 146         setPrivateInstanceByReflexion();
 147         L2 l2Mock = mock(L2.class);
 148         List<L2> l2List = new ArrayList<>();
 149         l2List.add(l2Mock);
 150         L3 l3Mock = mock(L3.class);
 151         List<L3> l3List = new ArrayList<>();
 152         l3List.add(l3Mock);
 153         UnregisterEndpointInput unregisterEndpointInputMock = mock(UnregisterEndpointInput.class);
 154         doReturn(l2List).when(unregisterEndpointInputMock).getL2();
 155         doReturn(l3List).when(unregisterEndpointInputMock).getL3();
 156         endpointRpcRegistry.unregisterEndpoint(unregisterEndpointInputMock);
 157         verify(t, times(2)).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 158     }
 159
 160     @Test
 161     public void setEndpointGroupConditionsTest()throws Exception{
 162         setPrivateInstanceByReflexion();
 163         EndpointGroupId endpointGroupIdMock = mock(EndpointGroupId.class);
 164
 165         EndpointGroupCondition endpointGroupConditionMock = mock(EndpointGroupCondition.class);
 166         List<EndpointGroupCondition> endpointGroupConditionList = new ArrayList();
 167         endpointGroupConditionList.add(endpointGroupConditionMock);
 168         SetEndpointGroupConditionsInput setEndpointGroupConditionsInputMock = mock(SetEndpointGroupConditionsInput.class);
 169         doReturn(endpointGroupIdMock).when(setEndpointGroupConditionsInputMock).getEndpointGroup();
 170         doReturn(endpointGroupConditionList).when(setEndpointGroupConditionsInputMock).getEndpointGroupCondition();
 171         endpointRpcRegistry.setEndpointGroupConditions(setEndpointGroupConditionsInputMock);
 172         verify(t, atLeast(1)).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(EndpointGroupCondition.class));
 173     }
 174
 175     @Test
 176     public void unsetEndpointGroupConditionsTest()throws Exception{
 177         setPrivateInstanceByReflexion();
 178
 179         UnsetEndpointGroupConditionsInput unsetEndpointGroupConditionsInputMock = mock(UnsetEndpointGroupConditionsInput.class);
 180         EndpointGroupCondition endpointGroupConditionMock = mock(EndpointGroupCondition.class);
 181         List<EndpointGroupCondition> endpointGroupConditionList = new ArrayList();
 182         endpointGroupConditionList.add(endpointGroupConditionMock);
 183         doReturn(mock(EndpointGroupId.class)).when(unsetEndpointGroupConditionsInputMock).getEndpointGroup();
 184         doReturn(endpointGroupConditionList).when(unsetEndpointGroupConditionsInputMock).getEndpointGroupCondition();
 185         endpointRpcRegistry.unsetEndpointGroupConditions(unsetEndpointGroupConditionsInputMock);
 186         verify(t, times(1)).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 187     }
 188 }