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