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