groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImplTest.java

   1 /*
   2  * Copyright (c) 2016 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
   9 package org.opendaylight.groupbasedpolicy.base_endpoint;
  10
  11 import static org.mockito.Mockito.mock;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.Collection;
  16 import java.util.List;
  17
  18 import org.junit.Assert;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  23 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  24 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  25 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  26 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
  27 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  28 import org.opendaylight.groupbasedpolicy.util.EndpointUtils;
  29 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInputBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInputBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpoints;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCaseBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCaseBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnreg;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnregBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnregBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet;
  66 import org.opendaylight.yangtools.yang.common.RpcResult;
  67
  68 import com.google.common.base.Optional;
  69 import com.google.common.collect.ImmutableList;
  70
  71 public class BaseEndpointServiceImplTest extends CustomDataBrokerTest {
  72
  73     private static final String MAC_ADDRESS = "01:23:45:67:89:AB";
  74     private static final String IP_ADDRESS = "192.168.100.1/24";
  75     private static final String TENANT = "admin";
  76     private static final String DOMAIN = "test.domain";
  77     private static final String CONTEXT_ID = "testContext";
  78     private static final long timestamp = 1234567890L;
  79     private static final NetworkDomainContainment networkDomainContainment = new NetworkDomainContainmentBuilder()
  80         .setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(Subnet.class).build();
  81     private static final ParentEndpoint BASE_L3_PARENT = new ParentEndpointBuilder().setAddress(IP_ADDRESS)
  82         .setAddressType(IpPrefixType.class)
  83         .setContextId(new ContextId(CONTEXT_ID))
  84         .setContextType(L3Context.class)
  85         .build();
  86     private static final ChildEndpoint BASE_L2_CHILD = new ChildEndpointBuilder().setAddress(MAC_ADDRESS)
  87         .setAddressType(MacAddressType.class)
  88         .setContextId(new ContextId(CONTEXT_ID))
  89         .setContextType(L2FloodDomain.class)
  90         .build();
  91     private static final ParentContainmentEndpoint BASE_CONT_PARENT = new ParentContainmentEndpointBuilder()
  92         .setContextId(new ContextId(CONTEXT_ID)).setContextType(L2FloodDomain.class).build();
  93
  94     private DataBroker dataProvider;
  95     private BaseEndpointServiceImpl baseEndpointRpcRegistry;
  96
  97     @Override
  98     public Collection<Class<?>> getClassesFromModules() {
  99         return ImmutableList.of(Endpoints.class, AddressEndpoints.class, ContainmentEndpoints.class,
 100                 MacAddressType.class, IpPrefixType.class);
 101     }
 102
 103     @Before
 104     public void init() {
 105         dataProvider = getDataBroker();
 106         RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class);
 107
 108         baseEndpointRpcRegistry =
 109                 new BaseEndpointServiceImpl(dataProvider, rpcRegistry, new EndpointAugmentorRegistryImpl());
 110     }
 111
 112     @Test
 113     public void testConstructor() throws Exception {
 114         RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class);
 115         BaseEndpointServiceImpl registry =
 116                 new BaseEndpointServiceImpl(dataProvider, rpcRegistry, new EndpointAugmentorRegistryImpl());
 117         registry.close();
 118     }
 119
 120     @Test
 121     public void testRegisterEndpoint() throws Exception {
 122         AddressEndpoint l2EpWithL3Parent =
 123                 createBaseL2EpBuilder()
 124                     .setParentEndpointChoice(
 125                             new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build())
 126                     .build();
 127         AddressEndpoint l3EpWithL2Child =
 128                 createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 129         ContainmentEndpoint contEp = createBaseContEpBuilder().build();
 130         RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder();
 131         setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent, l3EpWithL2Child);
 132         setContEpsToBuilder(inputBuilder, contEp);
 133
 134         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get();
 135         Assert.assertTrue(rpcResult.isSuccessful());
 136
 137         ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
 138         Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 139                 IidFactory.addressEndpointIid(l2EpWithL3Parent.getKey()), rTx);
 140         Assert.assertTrue(addressEndpointL2.isPresent());
 141         Assert.assertEquals(l2EpWithL3Parent, addressEndpointL2.get());
 142
 143         Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 144                 IidFactory.addressEndpointIid(l3EpWithL2Child.getKey()), rTx);
 145         Assert.assertTrue(addressEndpointL3.isPresent());
 146         Assert.assertEquals(l3EpWithL2Child, addressEndpointL3.get());
 147
 148         Optional<ContainmentEndpoint> ContainmentEndpoint = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 149                 IidFactory.containmentEndpointIid(contEp.getKey()), rTx);
 150         Assert.assertTrue(ContainmentEndpoint.isPresent());
 151         Assert.assertEquals(contEp, ContainmentEndpoint.get());
 152     }
 153
 154     @Test
 155     public void testRegisterEndpoint_withParentUpdate() throws Exception {
 156         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 157         AddressEndpoint baseL3Ep = createBaseL3EpBuilder().build();
 158         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(baseL3Ep.getKey()), baseL3Ep);
 159         wTx.submit().get();
 160         AddressEndpoint l2EpWithL3Parent =
 161                 createBaseL2EpBuilder()
 162                     .setParentEndpointChoice(
 163                             new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build())
 164                     .build();
 165         RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder();
 166         setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent);
 167
 168         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get();
 169         Assert.assertTrue(rpcResult.isSuccessful());
 170
 171         ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
 172         Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 173                 IidFactory.addressEndpointIid(l2EpWithL3Parent.getKey()), rTx);
 174         Assert.assertTrue(addressEndpointL2.isPresent());
 175         List<ParentEndpoint> parentEndpoints =
 176                 EndpointUtils.getParentEndpoints(addressEndpointL2.get().getParentEndpointChoice());
 177         Assert.assertEquals(1, parentEndpoints.size());
 178
 179         Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 180                 IidFactory.addressEndpointIid(baseL3Ep.getKey()), rTx);
 181         Assert.assertTrue(addressEndpointL3.isPresent());
 182         Assert.assertEquals(1, addressEndpointL3.get().getChildEndpoint().size());
 183     }
 184
 185     @Test
 186     public void testRegisterEndpoint_withChildUpdate() throws Exception {
 187         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 188         AddressEndpoint baseL2Ep = createBaseL2EpBuilder().build();
 189         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(baseL2Ep.getKey()), baseL2Ep);
 190         wTx.submit().get();
 191         AddressEndpoint l3EpWithL2Child =
 192                 createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 193         RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder();
 194         setAddrEpsToBuilder(inputBuilder, l3EpWithL2Child);
 195
 196         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get();
 197         Assert.assertTrue(rpcResult.isSuccessful());
 198
 199         ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
 200         Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 201                 IidFactory.addressEndpointIid(baseL2Ep.getKey()), rTx);
 202         Assert.assertTrue(addressEndpointL2.isPresent());
 203         List<ParentEndpoint> parentEndpoints =
 204                 EndpointUtils.getParentEndpoints(addressEndpointL2.get().getParentEndpointChoice());
 205         Assert.assertEquals(1, parentEndpoints.size());
 206
 207         Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
 208                 IidFactory.addressEndpointIid(l3EpWithL2Child.getKey()), rTx);
 209         Assert.assertTrue(addressEndpointL3.isPresent());
 210         Assert.assertEquals(1, addressEndpointL3.get().getChildEndpoint().size());
 211     }
 212
 213     @Test
 214     public void testRegisterEndpoint_rpcInput_missing_child() throws Exception {
 215         AddressEndpoint l2EpWithL3Parent =
 216                 createBaseL2EpBuilder()
 217                     .setParentEndpointChoice(
 218                             new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build())
 219                     .build();
 220         AddressEndpoint l3EpWithL2Child = createBaseL3EpBuilder().setChildEndpoint(Arrays.asList()).build();
 221         ContainmentEndpoint contEp = createBaseContEpBuilder().build();
 222         RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder();
 223         setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent, l3EpWithL2Child);
 224         setContEpsToBuilder(inputBuilder, contEp);
 225
 226         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get();
 227         Assert.assertFalse(rpcResult.isSuccessful());
 228         Assert.assertNotNull(rpcResult.getErrors());
 229         Assert.assertEquals(1, rpcResult.getErrors().size());
 230     }
 231
 232     @Test
 233     public void testRegisterEndpoint_rpcInput_missingParent() throws Exception {
 234         AddressEndpoint l2EpWithL3Parent = createBaseL2EpBuilder().build();
 235         AddressEndpoint l3EpWithL2Child =
 236                 createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 237         ContainmentEndpoint contEp = createBaseContEpBuilder().build();
 238         RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder();
 239         setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent, l3EpWithL2Child);
 240         setContEpsToBuilder(inputBuilder, contEp);
 241
 242         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get();
 243         Assert.assertFalse(rpcResult.isSuccessful());
 244         Assert.assertNotNull(rpcResult.getErrors());
 245         Assert.assertEquals(1, rpcResult.getErrors().size());
 246     }
 247
 248     @Test
 249     public void testUnregisterEndpoint_withParent() throws Exception {
 250         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 251         AddressEndpoint l2EpWithL3EpParent =
 252                 createBaseL2EpBuilder()
 253                     .setParentEndpointChoice(
 254                             new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build())
 255                     .build();
 256         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()),
 257                 l2EpWithL3EpParent);
 258         AddressEndpoint l3EpWithL2EpChild =
 259                 createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 260         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()),
 261                 l3EpWithL2EpChild);
 262         wTx.submit().get();
 263
 264         UnregisterEndpointInputBuilder inputBuilder = new UnregisterEndpointInputBuilder();
 265         setAddrEpsToBuilder(inputBuilder, l2EpWithL3EpParent);
 266         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.unregisterEndpoint(inputBuilder.build()).get();
 267         Assert.assertTrue(rpcResult.isSuccessful());
 268
 269         ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
 270         Optional<AddressEndpoint> l2EpWithL3EpParentFromDsOptional = DataStoreHelper.readFromDs(
 271                 LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()), rTx);
 272         Assert.assertFalse(l2EpWithL3EpParentFromDsOptional.isPresent());
 273
 274         Optional<AddressEndpoint> l3EpWithL2EpChildFromDsOptional = DataStoreHelper.readFromDs(
 275                 LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()), rTx);
 276         Assert.assertTrue(l3EpWithL2EpChildFromDsOptional.isPresent());
 277         Assert.assertEquals(0, l3EpWithL2EpChildFromDsOptional.get().getChildEndpoint().size());
 278     }
 279
 280     @Test
 281     public void testUnregisterEndpoint_withChild() throws Exception {
 282         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 283         AddressEndpoint l2EpWithL3EpParent =
 284                 createBaseL2EpBuilder()
 285                     .setParentEndpointChoice(
 286                             new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build())
 287                     .build();
 288         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()),
 289                 l2EpWithL3EpParent);
 290         AddressEndpoint l3EpWithL2EpChild =
 291                 createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 292         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()),
 293                 l3EpWithL2EpChild);
 294         wTx.submit().get();
 295
 296         UnregisterEndpointInputBuilder inputBuilder = new UnregisterEndpointInputBuilder();
 297         setAddrEpsToBuilder(inputBuilder, l3EpWithL2EpChild);
 298         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.unregisterEndpoint(inputBuilder.build()).get();
 299         Assert.assertTrue(rpcResult.isSuccessful());
 300
 301         ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
 302         Optional<AddressEndpoint> l3EpWithL2EpChildFromDsOptional = DataStoreHelper.readFromDs(
 303                 LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()), rTx);
 304         Assert.assertFalse(l3EpWithL2EpChildFromDsOptional.isPresent());
 305
 306         Optional<AddressEndpoint> l2EpWithL3EpParentFromDsOptional = DataStoreHelper.readFromDs(
 307                 LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()), rTx);
 308         Assert.assertTrue(l2EpWithL3EpParentFromDsOptional.isPresent());
 309         Assert.assertEquals(0, EndpointUtils
 310             .getParentEndpoints(l2EpWithL3EpParentFromDsOptional.get().getParentEndpointChoice()).size());
 311     }
 312
 313     @Test
 314     public void testRegisterEndpoint_containmentEndpointWithChildFail() throws Exception {
 315         ContainmentEndpoint contEpWithChild =
 316                 createBaseContEpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 317         RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder();
 318         setContEpsToBuilder(inputBuilder, contEpWithChild);
 319         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get();
 320         Assert.assertFalse(rpcResult.isSuccessful());
 321         Assert.assertNull(rpcResult.getResult());
 322         Assert.assertEquals(1, rpcResult.getErrors().size());
 323     }
 324
 325     @Test
 326     public void testUnregisterEndpoint_containmentEndpointWithChild() throws Exception {
 327         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 328         ContainmentEndpoint contEpWithL2EpChild =
 329                 createBaseContEpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build();
 330         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(contEpWithL2EpChild.getKey()),
 331                 contEpWithL2EpChild);
 332         AddressEndpoint l2EpWithContEpParent =
 333                 createBaseL2EpBuilder().setParentEndpointChoice(new ParentContainmentEndpointCaseBuilder()
 334                     .setParentContainmentEndpoint(Arrays.asList(BASE_CONT_PARENT)).build()).build();
 335         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithContEpParent.getKey()),
 336                 l2EpWithContEpParent);
 337         wTx.submit().get();
 338
 339         UnregisterEndpointInputBuilder inputBuilder = new UnregisterEndpointInputBuilder();
 340         setContEpsToBuilder(inputBuilder, contEpWithL2EpChild);
 341         RpcResult<Void> rpcResult = baseEndpointRpcRegistry.unregisterEndpoint(inputBuilder.build()).get();
 342         Assert.assertTrue(rpcResult.isSuccessful());
 343
 344         ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
 345         Optional<ContainmentEndpoint> contEpWithL2EpChildFromDsOptional = DataStoreHelper.readFromDs(
 346                 LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(contEpWithL2EpChild.getKey()), rTx);
 347         Assert.assertFalse(contEpWithL2EpChildFromDsOptional.isPresent());
 348
 349         Optional<AddressEndpoint> l2EpWithContEpParentFromDsOptional = DataStoreHelper.readFromDs(
 350                 LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithContEpParent.getKey()), rTx);
 351         Assert.assertTrue(l2EpWithContEpParentFromDsOptional.isPresent());
 352         Assert.assertEquals(0, EndpointUtils
 353             .getParentEndpoints(l2EpWithContEpParentFromDsOptional.get().getParentEndpointChoice()).size());
 354     }
 355
 356     private void setAddrEpsToBuilder(RegisterEndpointInputBuilder builder, AddressEndpoint... addrEndpoints) {
 357         List<AddressEndpointReg> addrEpRegs = new ArrayList<>();
 358         for (AddressEndpoint addrEp : addrEndpoints) {
 359             addrEpRegs.add(new AddressEndpointRegBuilder().setTimestamp(timestamp)
 360                 .setContextId(addrEp.getContextId())
 361                 .setContextType(addrEp.getContextType())
 362                 .setTenant(addrEp.getTenant())
 363                 .setAddress(addrEp.getAddress())
 364                 .setAddressType(addrEp.getAddressType())
 365                 .setNetworkContainment(addrEp.getNetworkContainment())
 366                 .setTimestamp(addrEp.getTimestamp())
 367                 .setParentEndpointChoice(addrEp.getParentEndpointChoice())
 368                 .setChildEndpoint(addrEp.getChildEndpoint())
 369                 .build());
 370         }
 371         builder.setAddressEndpointReg(addrEpRegs);
 372     }
 373
 374     private void setContEpsToBuilder(RegisterEndpointInputBuilder builder, ContainmentEndpoint... contEndpoints) {
 375         List<ContainmentEndpointReg> contEpRegs = new ArrayList<>();
 376         for (ContainmentEndpoint contEp : contEndpoints) {
 377             contEpRegs.add(new ContainmentEndpointRegBuilder().setTimestamp(contEp.getTimestamp())
 378                 .setContextId(contEp.getContextId())
 379                 .setContextType(contEp.getContextType())
 380                 .setTenant(contEp.getTenant())
 381                 .setNetworkContainment(contEp.getNetworkContainment())
 382                 .setChildEndpoint(contEp.getChildEndpoint())
 383                 .build());
 384         }
 385         builder.setContainmentEndpointReg(contEpRegs);
 386     }
 387
 388     private void setAddrEpsToBuilder(UnregisterEndpointInputBuilder builder, AddressEndpoint... addrEndpoints) {
 389         List<AddressEndpointUnreg> addrEpUnregs = new ArrayList<>();
 390         for (AddressEndpoint addrEp : addrEndpoints) {
 391             addrEpUnregs.add(new AddressEndpointUnregBuilder().setContextId(addrEp.getContextId())
 392                 .setContextType(addrEp.getContextType())
 393                 .setAddress(addrEp.getAddress())
 394                 .setAddressType(addrEp.getAddressType())
 395                 .build());
 396         }
 397         builder.setAddressEndpointUnreg(addrEpUnregs);
 398     }
 399
 400     private void setContEpsToBuilder(UnregisterEndpointInputBuilder builder, ContainmentEndpoint... contEndpoints) {
 401         List<ContainmentEndpointUnreg> contEpUnregs = new ArrayList<>();
 402         for (ContainmentEndpoint contEp : contEndpoints) {
 403             contEpUnregs.add(new ContainmentEndpointUnregBuilder().setContextId(contEp.getContextId())
 404                 .setContextType(contEp.getContextType())
 405                 .build());
 406         }
 407         builder.setContainmentEndpointUnreg(contEpUnregs);
 408     }
 409
 410     private AddressEndpointBuilder createBaseL2EpBuilder() {
 411         return new AddressEndpointBuilder().setTimestamp(timestamp)
 412             .setContextId(new ContextId(CONTEXT_ID))
 413             .setContextType(L2FloodDomain.class)
 414             .setTenant(new TenantId(TENANT))
 415             .setAddress(MAC_ADDRESS)
 416             .setAddressType(MacAddressType.class)
 417             .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
 418             .setTimestamp(timestamp);
 419     }
 420
 421     private AddressEndpointBuilder createBaseL3EpBuilder() {
 422         return new AddressEndpointBuilder().setTimestamp(timestamp)
 423             .setContextId(new ContextId(CONTEXT_ID))
 424             .setContextType(L3Context.class)
 425             .setTenant(new TenantId(TENANT))
 426             .setAddress(IP_ADDRESS)
 427             .setAddressType(IpPrefixType.class)
 428             .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
 429             .setTimestamp(timestamp);
 430     }
 431
 432     private ContainmentEndpointBuilder createBaseContEpBuilder() {
 433         return new ContainmentEndpointBuilder().setTimestamp(timestamp)
 434             .setContextId(new ContextId(CONTEXT_ID))
 435             .setContextType(L2FloodDomain.class)
 436             .setTenant(new TenantId(TENANT))
 437             .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build());
 438     }
 439 }