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