mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MappingServiceTest.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 package org.opendaylight.lispflowmapping.implementation.lisp;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12
  13 import java.util.ArrayList;
  14 import java.util.concurrent.ExecutionException;
  15 import java.util.concurrent.Future;
  16 import org.junit.Test;
  17 import org.junit.runner.RunWith;
  18 import org.mockito.InjectMocks;
  19 import org.mockito.Mock;
  20 import org.mockito.Mockito;
  21 import org.mockito.junit.MockitoJUnitRunner;
  22 import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
  23 import org.opendaylight.lispflowmapping.implementation.MappingService;
  24 import org.opendaylight.lispflowmapping.implementation.MappingSystem;
  25 import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener;
  26 import org.opendaylight.lispflowmapping.implementation.mdsal.MappingDataListener;
  27 import org.opendaylight.lispflowmapping.implementation.util.DSBEInputUtil;
  28 import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil;
  29 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  30 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  31 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
  32 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  33 import org.opendaylight.mdsal.binding.api.DataBroker;
  34 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecord;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecordBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInputBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyOutput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyOutputBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeysInput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingOutput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingOutputBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingsInput;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllKeysInput;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllMappingsInput;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInputBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyOutput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyOutputBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeysInput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingInput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingInputBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutput;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutputBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllMappingsInput;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInput;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInputBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyOutput;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyOutputBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeysInput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInput;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInputBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingOutput;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingOutputBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingsInput;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyInput;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyInputBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyOutput;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyOutputBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeysInput;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingInput;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingInputBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingOutput;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingOutputBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingsInput;
  86 import org.opendaylight.yangtools.yang.common.RpcError;
  87 import org.opendaylight.yangtools.yang.common.RpcResult;
  88 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  89 import org.opendaylight.yangtools.yang.common.Uint16;
  90
  91 @RunWith(MockitoJUnitRunner.class)
  92 public class MappingServiceTest {
  93
  94     @Mock(name = "mappingSystem") private static MappingSystem mappingSystem;
  95     @Mock(name = "dsbe") private static DataStoreBackEnd dsbe;
  96     @Mock(name = "keyListener") private static AuthenticationKeyDataListener keyListener;
  97     @Mock(name = "mappingListener") private static MappingDataListener mappingListener;
  98
  99     private final DataBroker dataBroker = Mockito.mock(DataBroker.class);
 100     private final NotificationPublishService notificationPublishService = Mockito
 101             .mock(NotificationPublishService.class);
 102     private final ILispDAO lispDAO = Mockito.mock(ILispDAO.class);
 103
 104     @InjectMocks
 105     MappingService mappingService = new MappingService(dataBroker,
 106             notificationPublishService, lispDAO);
 107
 108     private static final String IPV4_STRING = "1.2.3.0";
 109     private static final Eid IPV4_EID = LispAddressUtil.asIpv4Eid(IPV4_STRING);
 110
 111     private static final RpcResult<Object> RPC_RESULT_SUCCESS = RpcResultBuilder.success().build();
 112     private static final MappingAuthkey MAPPING_AUTHKEY = new MappingAuthkeyBuilder()
 113             .setKeyString("password")
 114             .setKeyType(Uint16.ONE).build();
 115     private static final SiteId SITE_ID = new SiteId(new byte[] {0, 1, 2, 3, 4, 5, 6, 7});
 116     private static final XtrId XTR_ID = new XtrId(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
 117     private static final MappingData DUMMY_MAPPING = new MappingData(null);
 118
 119     /**
 120      * Tests {@link MappingService#addKey} method.
 121      */
 122     @Test
 123     public void addKeyTest() throws ExecutionException, InterruptedException {
 124         final MappingAuthkey mappingAuthkey = new MappingAuthkeyBuilder()
 125                 .setKeyString("dummy-password")
 126                 .setKeyType(Uint16.TWO).build();
 127         final AddKeyInput addKeyInput = new AddKeyInputBuilder()
 128                 .setMappingAuthkey(mappingAuthkey)
 129                 .setEid(IPV4_EID).build();
 130         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(MAPPING_AUTHKEY);
 131
 132         // input
 133         final RpcResult<Object> rpc = RpcResultBuilder.failed().withError(RpcError.ErrorType.PROTOCOL, "data-exists",
 134                 "Key already exists! Please use update-key if you want to change it.").build();
 135         // equals() not implemented int RpcError
 136         final RpcError error = rpc.getErrors().iterator().next();
 137
 138         // result
 139         final Future<RpcResult<AddKeyOutput>> result = mappingService.addKey(addKeyInput);
 140         final RpcError errorResult = result.get().getErrors().iterator().next();
 141
 142         assertEquals(1, result.get().getErrors().size());
 143         assertEquals(error.getMessage(), errorResult.getMessage());
 144         assertEquals(error.getApplicationTag(), errorResult.getApplicationTag());
 145         assertEquals(error.getCause(), errorResult.getCause());
 146         assertEquals(error.getErrorType(), errorResult.getErrorType());
 147         assertEquals(error.getInfo(), errorResult.getInfo());
 148         assertEquals(error.getTag(), errorResult.getTag());
 149         assertEquals(error.getSeverity(), errorResult.getSeverity());
 150         assertEquals(rpc.getResult(), result.get().getResult());
 151         assertEquals(rpc.isSuccessful(), result.get().isSuccessful());
 152     }
 153
 154     /**
 155      * Tests {@link MappingService#addKey} method with null MappingAuthkey.
 156      */
 157     @Test
 158     public void addKeyTest_withNullMapAuthkey() throws ExecutionException, InterruptedException {
 159         final AddKeyInput addKeyInput = new AddKeyInputBuilder().setEid(IPV4_EID).build();
 160         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(null);
 161
 162         final Future<RpcResult<AddKeyOutput>> result = mappingService.addKey(addKeyInput);
 163         Mockito.verify(dsbe).addAuthenticationKey(Mockito.any());
 164
 165         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
 166         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
 167         assertEquals(new AddKeyOutputBuilder().build(), result.get().getResult());
 168     }
 169
 170     /**
 171      * Tests {@link MappingService#addMapping} method.
 172      */
 173     @Test
 174     public void addMappingTest() throws ExecutionException, InterruptedException {
 175         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 176         final AddMappingInput addMappingInput = new AddMappingInputBuilder()
 177                 .setMappingRecord(mappingRecordBuilder.build()).build();
 178
 179         final Future<RpcResult<AddMappingOutput>> result = mappingService.addMapping(addMappingInput);
 180         Mockito.verify(dsbe).addMapping(RPCInputConvertorUtil.toMapping(addMappingInput));
 181
 182         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
 183         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
 184         assertEquals(new AddMappingOutputBuilder().build(), result.get().getResult());
 185     }
 186
 187     /**
 188      * Tests {@link MappingService#getKey} method.
 189      */
 190     @Test
 191     public void getKeyTest() throws ExecutionException, InterruptedException {
 192         final GetKeyInput getKeyInput = new GetKeyInputBuilder().setEid(IPV4_EID).build();
 193         final RpcResult<GetKeyOutput> rpcResult = RpcResultBuilder
 194                 .success(new GetKeyOutputBuilder().setMappingAuthkey(MAPPING_AUTHKEY).build()).build();
 195
 196         Mockito.when(mappingSystem.getAuthenticationKey(getKeyInput.getEid())).thenReturn(MAPPING_AUTHKEY);
 197
 198         final Future<RpcResult<GetKeyOutput>> result = mappingService.getKey(getKeyInput);
 199         assertEquals(rpcResult.getErrors(), result.get().getErrors());
 200         assertEquals(rpcResult.getResult(), result.get().getResult());
 201         assertEquals(rpcResult.isSuccessful(), result.get().isSuccessful());
 202     }
 203
 204     /**
 205      * Tests {@link MappingService#getKey} method with null MappingAuthkey.
 206      */
 207     @Test
 208     public void getKeyTest_withNullMappingAuthkey() throws ExecutionException, InterruptedException {
 209         // input
 210         final GetKeyInput getKeyInput = new GetKeyInputBuilder().setEid(IPV4_EID).build();
 211         Mockito.when(mappingSystem.getAuthenticationKey(getKeyInput.getEid())).thenReturn(null);
 212
 213         final RpcResult<Object> rpc = RpcResultBuilder.failed()
 214                 .withError(RpcError.ErrorType.APPLICATION, "data-missing", "Key was not found in the mapping database")
 215                 .build();
 216         final RpcError error = rpc.getErrors().iterator().next();
 217
 218         // result
 219         final Future<RpcResult<GetKeyOutput>> result = mappingService.getKey(getKeyInput);
 220         final RpcError errorResult = result.get().getErrors().iterator().next();
 221
 222         assertEquals(1, result.get().getErrors().size());
 223         assertEquals(error.getMessage(), errorResult.getMessage());
 224         assertEquals(error.getApplicationTag(), errorResult.getApplicationTag());
 225         assertEquals(error.getCause(), errorResult.getCause());
 226         assertEquals(error.getErrorType(), errorResult.getErrorType());
 227         assertEquals(error.getInfo(), errorResult.getInfo());
 228         assertEquals(error.getTag(), errorResult.getTag());
 229         assertEquals(error.getSeverity(), errorResult.getSeverity());
 230         assertEquals(rpc.getResult(), result.get().getResult());
 231         assertEquals(rpc.isSuccessful(), result.get().isSuccessful());
 232     }
 233
 234     /**
 235      * Tests {@link MappingService#getMapping} method.
 236      */
 237     @Test
 238     public void getMappingTest() throws ExecutionException, InterruptedException {
 239         // input
 240         final GetMappingInput getMappingInput = new GetMappingInputBuilder().setEid(IPV4_EID).build();
 241         final MappingData mappingData = getDefaultMappingData();
 242         final MappingRecord nonBinaryMappingRecord = getDefaultMappingRecordBuilder()
 243                 .setEid(LispAddressUtil.toEid(new Ipv4Address(IPV4_STRING), null)).build();
 244
 245         Mockito.when(mappingSystem.getMapping(getMappingInput.getEid())).thenReturn(mappingData);
 246
 247         final RpcResult<GetMappingOutput> rpc = RpcResultBuilder
 248                 .success(new GetMappingOutputBuilder().setMappingRecord(nonBinaryMappingRecord)).build();
 249
 250         //result
 251         final Future<RpcResult<GetMappingOutput>> result = mappingService.getMapping(getMappingInput);
 252         final RpcResult<GetMappingOutput> rpcResult = result.get();
 253
 254         assertEquals(rpc.getResult(), rpcResult.getResult());
 255         assertEquals(rpc.getErrors(), rpcResult.getErrors());
 256         assertEquals(rpc.isSuccessful(), rpcResult.isSuccessful());
 257     }
 258
 259     /**
 260      * Tests {@link MappingService#getMapping} method with null MappingRecord.
 261      */
 262     @Test
 263     public void getMappingTest_withNullMapRecord() throws ExecutionException, InterruptedException {
 264         // input
 265         final GetMappingInput getMappingInput = new GetMappingInputBuilder().setEid(IPV4_EID).build();
 266         Mockito.when(mappingSystem.getMapping(getMappingInput.getEid())).thenReturn(null);
 267
 268         final RpcResult<Object> rpc = RpcResultBuilder.failed().withError(RpcError.ErrorType.APPLICATION,
 269                 "data-missing", "No mapping was found in the mapping database").build();
 270         final RpcError error = rpc.getErrors().iterator().next();
 271
 272         //result
 273         final Future<RpcResult<GetMappingOutput>> result = mappingService.getMapping(getMappingInput);
 274         final RpcError errorResult = result.get().getErrors().iterator().next();
 275
 276         assertEquals(1, result.get().getErrors().size());
 277         assertEquals(error.getMessage(), errorResult.getMessage());
 278         assertEquals(error.getApplicationTag(), errorResult.getApplicationTag());
 279         assertEquals(error.getCause(), errorResult.getCause());
 280         assertEquals(error.getErrorType(), errorResult.getErrorType());
 281         assertEquals(error.getInfo(), errorResult.getInfo());
 282         assertEquals(error.getTag(), errorResult.getTag());
 283         assertEquals(error.getSeverity(), errorResult.getSeverity());
 284         assertEquals(rpc.getResult(), result.get().getResult());
 285         assertEquals(rpc.isSuccessful(), result.get().isSuccessful());
 286     }
 287
 288     /**
 289      * Tests {@link MappingService#removeKey} method.
 290      */
 291     @Test
 292     public void removeKeyTest() throws ExecutionException, InterruptedException {
 293         final RemoveKeyInput removeKeyInput = new RemoveKeyInputBuilder().setEid(IPV4_EID).build();
 294
 295         final Future<RpcResult<RemoveKeyOutput>> result = mappingService.removeKey(removeKeyInput);
 296         Mockito.verify(dsbe).removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(removeKeyInput));
 297
 298         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
 299         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
 300         assertEquals(new RemoveKeyOutputBuilder().build(), result.get().getResult());
 301     }
 302
 303     /**
 304      * Tests {@link MappingService#removeMapping} method.
 305      */
 306     @Test
 307     public void removeMappingTest() throws ExecutionException, InterruptedException {
 308         final RemoveMappingInput removeMappingInput = new RemoveMappingInputBuilder().setEid(IPV4_EID).build();
 309
 310         final Future<RpcResult<RemoveMappingOutput>> result = mappingService.removeMapping(removeMappingInput);
 311         Mockito.verify(dsbe).removeMapping(RPCInputConvertorUtil.toMapping(removeMappingInput));
 312
 313         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
 314         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
 315         assertEquals(new RemoveMappingOutputBuilder().build(), result.get().getResult());
 316     }
 317
 318     /**
 319      * Tests {@link MappingService#updateKey} method.
 320      */
 321     @Test
 322     public void updateKeyTest() throws ExecutionException, InterruptedException {
 323         final UpdateKeyInput updateKeyInput = new UpdateKeyInputBuilder().setEid(IPV4_EID).build();
 324         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(MAPPING_AUTHKEY);
 325
 326         final Future<RpcResult<UpdateKeyOutput>> result = mappingService.updateKey(updateKeyInput);
 327         Mockito.verify(dsbe).updateAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(updateKeyInput));
 328
 329         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
 330         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
 331         assertEquals(new UpdateKeyOutputBuilder().build(), result.get().getResult());
 332     }
 333
 334     /**
 335      * Tests {@link MappingService#updateKey} method with null MappingAuthkey.
 336      */
 337     @Test
 338     public void updateKeyTest_withNullMapAuthkey() throws ExecutionException, InterruptedException {
 339         final UpdateKeyInput updateKeyInput = new UpdateKeyInputBuilder().setEid(IPV4_EID).build();
 340         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(null);
 341
 342         // input
 343         final RpcResult<Object> rpc = RpcResultBuilder.failed().withError(RpcError.ErrorType.PROTOCOL, "data-missing",
 344                 "Key doesn't exist! Please use add-key if you want to create a new authentication key.").build();
 345         final RpcError error = rpc.getErrors().iterator().next();
 346
 347         // result
 348         final Future<RpcResult<UpdateKeyOutput>> result = mappingService.updateKey(updateKeyInput);
 349         final RpcError errorResult = result.get().getErrors().iterator().next();
 350
 351         assertEquals(1, result.get().getErrors().size());
 352         assertEquals(error.getMessage(), errorResult.getMessage());
 353         assertEquals(error.getApplicationTag(), errorResult.getApplicationTag());
 354         assertEquals(error.getCause(), errorResult.getCause());
 355         assertEquals(error.getErrorType(), errorResult.getErrorType());
 356         assertEquals(error.getInfo(), errorResult.getInfo());
 357         assertEquals(error.getTag(), errorResult.getTag());
 358         assertEquals(error.getSeverity(), errorResult.getSeverity());
 359         assertEquals(rpc.getResult(), result.get().getResult());
 360         assertEquals(rpc.isSuccessful(), result.get().isSuccessful());
 361     }
 362
 363     /**
 364      * Tests {@link MappingService#updateMapping} method.
 365      */
 366     @Test
 367     public void updateMappingTest() throws ExecutionException, InterruptedException {
 368         final MappingRecord mappingRecord = getDefaultMappingRecordBuilder().build();
 369         final UpdateMappingInput updateMappingInput = new UpdateMappingInputBuilder()
 370                 .setMappingRecord(mappingRecord).build();
 371
 372         final Future<RpcResult<UpdateMappingOutput>> result = mappingService.updateMapping(updateMappingInput);
 373         Mockito.verify(dsbe).updateMapping(RPCInputConvertorUtil.toMapping(updateMappingInput));
 374
 375         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
 376         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
 377         assertEquals(new UpdateMappingOutputBuilder().build(), result.get().getResult());
 378     }
 379
 380     /**
 381      * Tests {@link MappingService#addMapping} method from southbound.
 382      */
 383     @Test
 384     public void addMappingTest_fromSouthbound() throws ExecutionException, InterruptedException {
 385         // input
 386         final MappingRecord record = getDefaultMappingRecordBuilder()
 387                 .setXtrId(XTR_ID).build();
 388         final MappingData data = getDefaultMappingData(record);
 389
 390         mappingService.addMapping(MappingOrigin.Southbound, IPV4_EID, SITE_ID, data);
 391
 392         Mockito.verify(mappingSystem).addMapping(MappingOrigin.Southbound, IPV4_EID, data);
 393         Mockito.verify(dsbe).addMapping(DSBEInputUtil.toMapping(MappingOrigin.Southbound, IPV4_EID, SITE_ID, data));
 394     }
 395
 396     /**
 397      * Tests {@link MappingService#addMapping} method from northbound.
 398      */
 399     @Test
 400     public void addMappingTest_fromNorthbound() throws ExecutionException, InterruptedException {
 401         // input
 402         final MappingOrigin origin = MappingOrigin.Northbound;
 403         final MappingRecord record = getDefaultMappingRecordBuilder()
 404                 .setXtrId(XTR_ID).build();
 405         final MappingData data = getDefaultMappingData(record);
 406
 407         mappingService.addMapping(origin, IPV4_EID, SITE_ID, data);
 408         Mockito.verify(dsbe).addMapping(DSBEInputUtil.toMapping(origin, IPV4_EID, SITE_ID, data));
 409         Mockito.verifyZeroInteractions(mappingSystem);
 410         Mockito.verifyNoMoreInteractions(dsbe);
 411     }
 412
 413     /**
 414      * Tests {@link MappingService#getMapping(MappingOrigin, Eid)} method.
 415      */
 416     @Test
 417     public void getMappingTest_withOriginAndEid() {
 418         Mockito.when(mappingSystem.getMapping(Mockito.any(MappingOrigin.class), Mockito.any(Eid.class)))
 419                 .thenReturn(DUMMY_MAPPING);
 420         assertEquals(DUMMY_MAPPING, mappingService.getMapping(MappingOrigin.Northbound, IPV4_EID));
 421     }
 422
 423     /**
 424      * Tests {@link MappingService#getMapping(Eid)} method.
 425      */
 426     @Test
 427     public void getMappingTest_withEid() {
 428         Mockito.when(mappingSystem.getMapping(Mockito.any(Eid.class))).thenReturn(DUMMY_MAPPING);
 429         assertEquals(DUMMY_MAPPING, mappingService.getMapping(IPV4_EID));
 430     }
 431
 432     /**
 433      * Tests {@link MappingService#getMapping(Eid)} method.
 434      */
 435     @Test
 436     public void getMappingTest_withSrcAndDstEid() {
 437         Mockito.when(mappingSystem.getMapping(Mockito.any(Eid.class), Mockito.any(Eid.class)))
 438             .thenReturn(DUMMY_MAPPING);
 439         assertEquals(DUMMY_MAPPING, mappingService.getMapping(IPV4_EID, IPV4_EID));
 440     }
 441
 442     /**
 443      * Tests {@link MappingService#removeMapping} method.
 444      */
 445     @Test
 446     public void removeMappingTest_withMapOrginAndEid() {
 447         mappingService.removeMapping(MappingOrigin.Northbound, IPV4_EID);
 448         Mockito.verify(dsbe).removeMapping(DSBEInputUtil.toMapping(MappingOrigin.Northbound, IPV4_EID));
 449     }
 450
 451     /**
 452      * Tests {@link MappingService#addAuthenticationKey} method.
 453      */
 454     @Test
 455     public void addAuthenticationKeyTest() {
 456         mappingService.addAuthenticationKey(IPV4_EID, MAPPING_AUTHKEY);
 457         Mockito.verify(dsbe).addAuthenticationKey(DSBEInputUtil.toAuthenticationKey(IPV4_EID, MAPPING_AUTHKEY));
 458     }
 459
 460     /**
 461      * Tests {@link MappingService#getAuthenticationKey(Eid)} method.
 462      */
 463     @Test
 464     public void getAuthenticationKeyTest() {
 465         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(MAPPING_AUTHKEY);
 466         assertEquals(MAPPING_AUTHKEY, mappingService.getAuthenticationKey(IPV4_EID));
 467     }
 468
 469     /**
 470      * Tests {@link MappingService#removeAuthenticationKey} method.
 471      */
 472     @Test
 473     public void removeAuthenticationKeyTest() {
 474         mappingService.removeAuthenticationKey(IPV4_EID);
 475         Mockito.verify(dsbe).removeAuthenticationKey(DSBEInputUtil.toAuthenticationKey(IPV4_EID, null));
 476     }
 477
 478     /**
 479      * Tests {@link MappingService#addData} method.
 480      */
 481     @Test
 482     public void addDataTest() {
 483         mappingService.addData(MappingOrigin.Northbound, IPV4_EID, SubKeys.RECORD, DUMMY_MAPPING);
 484         Mockito.verify(mappingSystem).addData(MappingOrigin.Northbound, IPV4_EID, SubKeys.RECORD, DUMMY_MAPPING);
 485     }
 486
 487     /**
 488      * Tests {@link MappingService#getData} method.
 489      */
 490     @Test
 491     public void getDataTest() {
 492         Mockito.when(mappingSystem.getData(MappingOrigin.Northbound, IPV4_EID, SubKeys.RECORD))
 493                 .thenReturn(DUMMY_MAPPING);
 494         assertEquals(DUMMY_MAPPING, mappingService.getData(MappingOrigin.Northbound, IPV4_EID, SubKeys.RECORD));
 495     }
 496
 497     /**
 498      * Tests {@link MappingService#removeData} method.
 499      */
 500     @Test
 501     public void removeDataTest() {
 502         mappingService.removeData(MappingOrigin.Northbound, IPV4_EID, SubKeys.RECORD);
 503         Mockito.verify(mappingSystem).removeData(MappingOrigin.Northbound, IPV4_EID, SubKeys.RECORD);
 504     }
 505
 506     /**
 507      * Tests {@link MappingService#printMappings} method.
 508      */
 509     @Test
 510     public void printMappingsTest() {
 511         mappingService.printMappings();
 512         Mockito.verify(mappingSystem).printMappings();
 513     }
 514
 515     /**
 516      * Tests {@link MappingService#close} method.
 517      */
 518     @Test
 519     public void close() throws Exception {
 520         mappingService.close();
 521         Mockito.verify(keyListener).closeDataChangeListener();
 522         Mockito.verify(mappingListener).closeDataChangeListener();
 523     }
 524
 525     /**
 526      * Tests {@link MappingService#cleanCachedMappings} method.
 527      */
 528     @Test
 529     public void cleanCachedMappingsTest() throws Exception {
 530         mappingService.cleanCachedMappings();
 531         Mockito.verify(mappingSystem).cleanCaches();
 532         Mockito.verify(dsbe).removeAllDatastoreContent();
 533     }
 534
 535     /**
 536      * Tests {@link MappingService} not implemented methods.
 537      */
 538     @Test
 539     public void nullReturnMethodTest() throws ExecutionException, InterruptedException {
 540         assertNull(mappingService.removeKeys(Mockito.mock(RemoveKeysInput.class)));
 541         assertNull(mappingService.removeMappings(Mockito.mock(RemoveMappingsInput.class)));
 542         assertNull(mappingService.getKeys(Mockito.mock(GetKeysInput.class)));
 543         assertNull(mappingService.addMappings(Mockito.mock(AddMappingsInput.class)));
 544         assertNull(mappingService.updateKeys(Mockito.mock(UpdateKeysInput.class)));
 545         assertNull(mappingService.removeAllMappings(Mockito.mock(RemoveAllMappingsInput.class)));
 546         assertNull(mappingService.getAllKeys(Mockito.mock(GetAllKeysInput.class)));
 547         assertNull(mappingService.updateMappings(Mockito.mock(UpdateMappingsInput.class)));
 548         assertNull(mappingService.addKeys(Mockito.mock(AddKeysInput.class)));
 549         assertNull(mappingService.getAllMappings(Mockito.mock(GetAllMappingsInput.class)));
 550     }
 551
 552     private static MappingData getDefaultMappingData() {
 553         return getDefaultMappingData(null);
 554     }
 555
 556     private static MappingData getDefaultMappingData(MappingRecord mappingRecord) {
 557         if (mappingRecord == null) {
 558             mappingRecord = getDefaultMappingRecordBuilder().build();
 559         }
 560         return new MappingData(mappingRecord, System.currentTimeMillis());
 561     }
 562
 563     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 564         return new MappingRecordBuilder()
 565                 .setAction(MappingRecord.Action.NoAction)
 566                 .setAuthoritative(false)
 567                 .setLocatorRecord(new ArrayList<>())
 568                 .setMapVersion((short) 0)
 569                 .setRecordTtl(60)
 570                 .setEid(IPV4_EID);
 571     }
 572 }