import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
-import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
private NamingContext namingContext;
private InstanceIdentifier<Interface> id;
- private CompletableFuture<LispAddDelLocatorReply> completeFuture;
- private LispAddDelLocatorReply fakeReply;
private Interface intf;
private InterfaceCustomizer customizer;
customizer = new InterfaceCustomizer(api, namingContext);
- fakeReply = new LispAddDelLocatorReply();
-
- completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
-
when(mappingContext.read(Mockito.any()))
.thenReturn(Optional.of((DataObject) new MappingBuilder().setIndex(5).setName("interface").build()));
- when(api.lispAddDelLocator(any(LispAddDelLocator.class))).thenReturn(completeFuture);
+ when(api.lispAddDelLocator(any(LispAddDelLocator.class))).thenReturn(future(new LispAddDelLocatorReply()));
}
@Test(expected = NullPointerException.class)
import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class LispCustomizerTest {
+public class LispCustomizerTest extends WriterCustomizerTest {
+
+ private LispCustomizer customizer;
+
+ @Override
+ public void setUp() {
+ customizer = new LispCustomizer(api);
+ }
+
+ private void whenlispEnableDisableThenSuccess() {
+ when(api.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(future(new LispEnableDisableReply()));
+ }
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesNullData() throws WriteFailedException {
}
@Test
- public void testWriteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+ public void testWriteCurrentAttributes() throws WriteFailedException {
Lisp intf = new LispBuilder().setEnable(true).build();
- ArgumentCaptor<LispEnableDisable> mappingCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
-
- LispEnableDisableReply fakeReply = new LispEnableDisableReply();
-
- CompletableFuture<LispEnableDisableReply> completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
-
- when(fakeJvpp.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(completeFuture);
+ whenlispEnableDisableThenSuccess();
+ customizer.writeCurrentAttributes(null, intf, null);
- new LispCustomizer(fakeJvpp).writeCurrentAttributes(null, intf, null);
-
- verify(fakeJvpp, times(1)).lispEnableDisable(mappingCaptor.capture());
+ ArgumentCaptor<LispEnableDisable> mappingCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
+ verify(api, times(1)).lispEnableDisable(mappingCaptor.capture());
LispEnableDisable request = mappingCaptor.getValue();
@Test(expected = NullPointerException.class)
public void testUpdateCurrentAttributesNullData() throws WriteFailedException {
- new LispCustomizer(mock(FutureJVppCore.class)).updateCurrentAttributes(null, null, null, null);
+ customizer.updateCurrentAttributes(null, null, null, null);
}
@Test
- public void testUpdateCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+ public void testUpdateCurrentAttributes() throws WriteFailedException {
Lisp lisp = new LispBuilder().setEnable(true).build();
- ArgumentCaptor<LispEnableDisable> lispCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
-
- LispEnableDisableReply fakeReply = new LispEnableDisableReply();
-
- CompletableFuture<LispEnableDisableReply> completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
-
- when(fakeJvpp.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(completeFuture);
+ whenlispEnableDisableThenSuccess();
+ customizer.updateCurrentAttributes(null, null, lisp, null);
- new LispCustomizer(fakeJvpp).updateCurrentAttributes(null, null, lisp, null);
-
- verify(fakeJvpp, times(1)).lispEnableDisable(lispCaptor.capture());
+ ArgumentCaptor<LispEnableDisable> lispCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
+ verify(api, times(1)).lispEnableDisable(lispCaptor.capture());
LispEnableDisable request = lispCaptor.getValue();
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
- new LispCustomizer(mock(FutureJVppCore.class)).deleteCurrentAttributes(null, null, null);
+ customizer.deleteCurrentAttributes(null, null, null);
}
@Test
- public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+ public void testDeleteCurrentAttributes() throws WriteFailedException {
Lisp lisp = new LispBuilder().setEnable(true).build();
- ArgumentCaptor<LispEnableDisable> lispCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
-
- LispEnableDisableReply fakeReply = new LispEnableDisableReply();
-
- CompletableFuture<LispEnableDisableReply> completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
-
- when(fakeJvpp.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(completeFuture);
+ whenlispEnableDisableThenSuccess();
+ customizer.deleteCurrentAttributes(null, lisp, null);
- new LispCustomizer(fakeJvpp).deleteCurrentAttributes(null, lisp, null);
-
- verify(fakeJvpp, times(1)).lispEnableDisable(lispCaptor.capture());
+ ArgumentCaptor<LispEnableDisable> lispCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
+ verify(api, times(1)).lispEnableDisable(lispCaptor.capture());
LispEnableDisable request = lispCaptor.getValue();
assertNotNull(request);
assertEquals(0, request.isEn);
}
-
}
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
-import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
private MappingId mappingId;
private InstanceIdentifier<LocalMapping> id;
private LocalMapping mapping;
- private LispAddDelLocalEidReply fakeReply;
- private CompletableFuture<LispAddDelLocalEidReply> completeFuture;
private LocalMappingCustomizer customizer;
private EidMappingContext localMappingContext;
.child(LocalMapping.class, new LocalMappingKey(new MappingId("local")))
.build();
- fakeReply = new LispAddDelLocalEidReply();
- completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
customizer = new LocalMappingCustomizer(api, localMappingContext);
- when(api.lispAddDelLocalEid(any(LispAddDelLocalEid.class))).thenReturn(completeFuture);
+ when(api.lispAddDelLocalEid(any(LispAddDelLocalEid.class))).thenReturn(future(new LispAddDelLocalEidReply()));
when(mappingContext.read(Mockito.any())).thenReturn(com.google.common.base.Optional
.of(new LocalMappingBuilder().setKey(key).setId(mappingId).setEid(eid).build()));
}
import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
public class LocatorSetCustomizerTest extends WriterCustomizerTest {
- private NamingContext locatorSetContext;
+ private LocatorSetCustomizer customizer;
@Override
public void setUp() {
- locatorSetContext = new NamingContext("locator-set", "instance");
+ customizer = new LocatorSetCustomizer(api, new NamingContext("locator-set", "instance"));
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesNullData() throws WriteFailedException {
- new LocatorSetCustomizer(api, locatorSetContext).writeCurrentAttributes(null, null, null);
+ customizer.writeCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesBadData() throws WriteFailedException {
- new LocatorSetCustomizer(api, locatorSetContext)
+ customizer
.writeCurrentAttributes(null, mock(LocatorSet.class), null);
}
@Test
public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
-
LocatorSet locatorSet = new LocatorSetBuilder()
.setName("Locator")
.setInterface(Arrays.asList(new InterfaceBuilder().build()))
ArgumentCaptor<LispAddDelLocatorSet> locatorSetCaptor = ArgumentCaptor.forClass(LispAddDelLocatorSet.class);
- LispAddDelLocatorSetReply fakeReply = new LispAddDelLocatorSetReply();
-
- CompletableFuture<LispAddDelLocatorSetReply> completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
-
- when(api.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
+ when(api.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(future(new LispAddDelLocatorSetReply()));
when(writeContext.readAfter(validId)).thenReturn(Optional.of(locatorSet));
final LispLocatorSetDetailsReplyDump reply = new LispLocatorSetDetailsReplyDump();
cache.put(io.fd.honeycomb.lisp.translate.read.LocatorSetCustomizer.LOCATOR_SETS_CACHE_ID, reply);
- new LocatorSetCustomizer(api, locatorSetContext).writeCurrentAttributes(validId, locatorSet, writeContext);
+ customizer.writeCurrentAttributes(validId, locatorSet, writeContext);
verify(api, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
@Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws WriteFailedException {
- new LocatorSetCustomizer(api, locatorSetContext).updateCurrentAttributes(null, null, null, null);
+ customizer.updateCurrentAttributes(null, null, null, null);
}
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
- new LocatorSetCustomizer(api, locatorSetContext).deleteCurrentAttributes(null, null, null);
+ customizer.deleteCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesBadData() throws WriteFailedException {
- new LocatorSetCustomizer(api, locatorSetContext)
- .deleteCurrentAttributes(null, mock(LocatorSet.class), null);
+ customizer.deleteCurrentAttributes(null, mock(LocatorSet.class), null);
}
@Test
public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
-
LocatorSet locatorSet = new LocatorSetBuilder()
.setName("Locator")
.build();
ArgumentCaptor<LispAddDelLocatorSet> locatorSetCaptor = ArgumentCaptor.forClass(LispAddDelLocatorSet.class);
- LispAddDelLocatorSetReply fakeReply = new LispAddDelLocatorSetReply();
-
- CompletableFuture<LispAddDelLocatorSetReply> completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
-
- when(api.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
+ when(api.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(future(new LispAddDelLocatorSetReply()));
- new LocatorSetCustomizer(api, locatorSetContext).deleteCurrentAttributes(null, locatorSet, writeContext);
+ customizer.deleteCurrentAttributes(null, locatorSet, writeContext);
verify(api, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolverBuilder;
import org.openvpp.jvpp.core.dto.LispAddDelMapResolver;
import org.openvpp.jvpp.core.dto.LispAddDelMapResolverReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class MapResolverCustomizerTest {
+public class MapResolverCustomizerTest extends WriterCustomizerTest {
+
+ private MapResolverCustomizer customizer;
+
+ @Override
+ public void setUp() {
+ customizer = new MapResolverCustomizer(api);
+ }
+
+ private void whenLispAddDelMapResolverThenSuccess() {
+ when(api.lispAddDelMapResolver(any(LispAddDelMapResolver.class)))
+ .thenReturn(future(new LispAddDelMapResolverReply()));
+ }
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesNullData() throws WriteFailedException {
- new MapResolverCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, null, null);
+ customizer.writeCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesBadData() throws WriteFailedException {
- new MapResolverCustomizer(mock(FutureJVppCore.class))
- .writeCurrentAttributes(null, new MapResolverBuilder().build(), null);
+ customizer.writeCurrentAttributes(null, new MapResolverBuilder().build(), null);
}
@Test
- public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
-
- MapResolverCustomizer customizer = new MapResolverCustomizer(fakeJvpp);
+ public void testWriteCurrentAttributes() throws WriteFailedException {
Ipv4Address address = new Ipv4Address("192.168.2.1");
MapResolver resolver = new MapResolverBuilder().setIpAddress(new IpAddress(address)).build();
- ArgumentCaptor<LispAddDelMapResolver> resolverCaptor = ArgumentCaptor.forClass(LispAddDelMapResolver.class);
-
- LispAddDelMapResolverReply fakeReply = new LispAddDelMapResolverReply();
-
- CompletableFuture<LispAddDelMapResolverReply> finalStage = new CompletableFuture<>();
- finalStage.complete(fakeReply);
-
- when(fakeJvpp.lispAddDelMapResolver(any(LispAddDelMapResolver.class))).thenReturn(finalStage);
+ whenLispAddDelMapResolverThenSuccess();
customizer.writeCurrentAttributes(null, resolver, null);
- verify(fakeJvpp, times(1)).lispAddDelMapResolver(resolverCaptor.capture());
+
+ ArgumentCaptor<LispAddDelMapResolver> resolverCaptor = ArgumentCaptor.forClass(LispAddDelMapResolver.class);
+ verify(api, times(1)).lispAddDelMapResolver(resolverCaptor.capture());
LispAddDelMapResolver request = resolverCaptor.getValue();
assertEquals(1, request.isAdd);
@Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws WriteFailedException {
- new MapResolverCustomizer(mock(FutureJVppCore.class)).updateCurrentAttributes(null, null, null, null);
+ customizer.updateCurrentAttributes(null, null, null, null);
}
@Test
public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
-
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
-
- MapResolverCustomizer customizer = new MapResolverCustomizer(fakeJvpp);
Ipv4Address address = new Ipv4Address("192.168.2.1");
MapResolver resolver = new MapResolverBuilder().setIpAddress(new IpAddress(address)).build();
- ArgumentCaptor<LispAddDelMapResolver> resolverCaptor = ArgumentCaptor.forClass(LispAddDelMapResolver.class);
-
- LispAddDelMapResolverReply fakeReply = new LispAddDelMapResolverReply();
-
- CompletableFuture<LispAddDelMapResolverReply> finalStage = new CompletableFuture<>();
- finalStage.complete(fakeReply);
-
- when(fakeJvpp.lispAddDelMapResolver(any(LispAddDelMapResolver.class))).thenReturn(finalStage);
+ whenLispAddDelMapResolverThenSuccess();
customizer.deleteCurrentAttributes(null, resolver, null);
- verify(fakeJvpp, times(1)).lispAddDelMapResolver(resolverCaptor.capture());
+
+ ArgumentCaptor<LispAddDelMapResolver> resolverCaptor = ArgumentCaptor.forClass(LispAddDelMapResolver.class);
+ verify(api, times(1)).lispAddDelMapResolver(resolverCaptor.capture());
LispAddDelMapResolver request = resolverCaptor.getValue();
assertEquals(0, request.isAdd);
import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.pitr.cfg.grouping.PitrCfgBuilder;
import org.openvpp.jvpp.core.dto.LispPitrSetLocatorSet;
import org.openvpp.jvpp.core.dto.LispPitrSetLocatorSetReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class PitrCfgCustomizerTest {
+public class PitrCfgCustomizerTest extends WriterCustomizerTest {
+
+ private PitrCfgCustomizer customizer;
+
+ @Override
+ public void setUp() {
+ customizer = new PitrCfgCustomizer(api);
+ }
+
+ private void whenLispPitrSetLocatorSetThenSuccess() {
+ when(api.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(future(new LispPitrSetLocatorSetReply()));
+ }
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesNullData() throws WriteFailedException {
- new PitrCfgCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, null, null);
+ customizer.writeCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesBadData() throws WriteFailedException {
- new PitrCfgCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, mock(PitrCfg.class), null);
+ customizer.writeCurrentAttributes(null, mock(PitrCfg.class), null);
}
@Test
- public void testWriteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
-
- PitrCfgCustomizer customizer = new PitrCfgCustomizer(fakeJvpp);
+ public void testWriteCurrentAttributes() throws WriteFailedException {
PitrCfg cfg = new PitrCfgBuilder().setLocatorSet("Locator").build();
- ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
-
- LispPitrSetLocatorSetReply fakeReply = new LispPitrSetLocatorSetReply();
-
- CompletableFuture<LispPitrSetLocatorSetReply> finalStage = new CompletableFuture<>();
- finalStage.complete(fakeReply);
-
- when(fakeJvpp.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(finalStage);
-
+ whenLispPitrSetLocatorSetThenSuccess();
customizer.writeCurrentAttributes(null, cfg, null);
- verify(fakeJvpp, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
+
+ ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
+ verify(api, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
LispPitrSetLocatorSet request = cfgCaptor.getValue();
assertEquals(1, request.isAdd);
@Test
public void testUpdateCurrentAttributes() throws WriteFailedException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
-
- PitrCfgCustomizer customizer = new PitrCfgCustomizer(fakeJvpp);
PitrCfg cfg = new PitrCfgBuilder().setLocatorSet("Locator").build();
- ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
-
- LispPitrSetLocatorSetReply fakeReply = new LispPitrSetLocatorSetReply();
-
- CompletableFuture<LispPitrSetLocatorSetReply> finalStage = new CompletableFuture<>();
- finalStage.complete(fakeReply);
-
- when(fakeJvpp.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(finalStage);
+ whenLispPitrSetLocatorSetThenSuccess();
customizer.writeCurrentAttributes(null, cfg, null);
- verify(fakeJvpp, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
+
+ ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
+ verify(api, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
LispPitrSetLocatorSet request = cfgCaptor.getValue();
assertEquals(1, request.isAdd);
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
- new PitrCfgCustomizer(mock(FutureJVppCore.class)).deleteCurrentAttributes(null, null, null);
+ customizer.deleteCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesBadData() throws WriteFailedException {
- new PitrCfgCustomizer(mock(FutureJVppCore.class)).deleteCurrentAttributes(null, mock(PitrCfg.class), null);
+ customizer.deleteCurrentAttributes(null, mock(PitrCfg.class), null);
}
@Test
public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
- FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
-
- PitrCfgCustomizer customizer = new PitrCfgCustomizer(fakeJvpp);
PitrCfg cfg = new PitrCfgBuilder().setLocatorSet("Locator").build();
- ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
-
- LispPitrSetLocatorSetReply fakeReply = new LispPitrSetLocatorSetReply();
-
- CompletableFuture<LispPitrSetLocatorSetReply> finalStage = new CompletableFuture<>();
- finalStage.complete(fakeReply);
-
- when(fakeJvpp.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(finalStage);
+ whenLispPitrSetLocatorSetThenSuccess();
customizer.deleteCurrentAttributes(null, cfg, null);
- verify(fakeJvpp, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
+
+ ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
+ verify(api, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
LispPitrSetLocatorSet request = cfgCaptor.getValue();
assertEquals(0, request.isAdd);
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
-import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
private MappingId mappingId;
private RemoteMappingCustomizer customizer;
private RemoteMapping intf;
- private LispAddDelRemoteMappingReply fakeReply;
- private CompletableFuture<LispAddDelRemoteMappingReply> completeFuture;
private InstanceIdentifier<RemoteMapping> id;
private EidMappingContext remoteMappingContext;
final RemoteMappingKey key = new RemoteMappingKey(mappingId);
remoteMappingContext = new EidMappingContext("remote");
-
intf = new RemoteMappingBuilder()
.setEid(
eid)
.child(RemoteMappings.class)
.child(RemoteMapping.class, key).build();
- fakeReply = new LispAddDelRemoteMappingReply();
- completeFuture = new CompletableFuture<>();
- completeFuture.complete(fakeReply);
customizer = new RemoteMappingCustomizer(api, remoteMappingContext);
- when(api.lispAddDelRemoteMapping(Mockito.any())).thenReturn(completeFuture);
+ when(api.lispAddDelRemoteMapping(Mockito.any())).thenReturn(future(new LispAddDelRemoteMappingReply()));
when(mappingContext.read(Mockito.any())).thenReturn(com.google.common.base.Optional
.of(new RemoteMappingBuilder().setKey(key).setId(mappingId).setEid(eid).build()));
}
package io.fd.honeycomb.translate.v3po.interfaces;
import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.vppclassifier.VppClassifierContextManager;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
-import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.openvpp.jvpp.VppBaseCallException;
import org.openvpp.jvpp.core.dto.InputAclSetInterface;
import org.openvpp.jvpp.core.dto.InputAclSetInterfaceReply;
-import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
public class AclCustomizerTest extends WriterCustomizerTest {
@Mock
private VppClassifierContextManager classifyTableContext;
- private NamingContext interfaceContext;
private AclCustomizer customizer;
private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
private static final String ACL_TABLE_NAME = "table0";
@Override
- public void setUp() throws Exception {
- initMocks(this);
- interfaceContext = new NamingContext("generatedInterfaceName", IFC_TEST_INSTANCE);
+ public void setUp() {
ContextTestUtils.mockMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
-
- doReturn(mappingContext).when(writeContext).getMappingContext();
- customizer = new AclCustomizer(api, interfaceContext, classifyTableContext);
+ customizer = new AclCustomizer(api, new NamingContext("generatedInterfaceName", IFC_TEST_INSTANCE),
+ classifyTableContext);
}
-
private InstanceIdentifier<Acl> getAclId(final String name) {
return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation(
VppInterfaceAugmentation.class).child(Acl.class);
return builder.build();
}
- private void whenInputAclSetInterfaceThenSuccess() throws ExecutionException, InterruptedException {
- final CompletableFuture<InputAclSetInterfaceReply> replyFuture = new CompletableFuture<>();
- final InputAclSetInterfaceReply reply = new InputAclSetInterfaceReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).inputAclSetInterface(any(InputAclSetInterface.class));
- }
-
- private void whenInputAclSetInterfaceThenFailure() throws ExecutionException, InterruptedException {
- doReturn(TestHelperUtils.<L2InterfaceVlanTagRewriteReply>createFutureException()).when(api)
+ private void whenInputAclSetInterfaceThenSuccess() {
+ doReturn(future(new InputAclSetInterfaceReply())).when(api)
.inputAclSetInterface(any(InputAclSetInterface.class));
}
- private void verifyInputAclSetInterfaceWasInvoked(final InputAclSetInterface expected) {
- final ArgumentCaptor<InputAclSetInterface> argumentCaptor = ArgumentCaptor.forClass(InputAclSetInterface.class);
- verify(api).inputAclSetInterface(argumentCaptor.capture());
- final InputAclSetInterface actual = argumentCaptor.getValue();
- assertEquals(expected.swIfIndex, actual.swIfIndex);
- assertEquals(expected.l2TableIndex, actual.l2TableIndex);
- assertEquals(expected.ip4TableIndex, actual.ip4TableIndex);
- assertEquals(expected.ip6TableIndex, actual.ip6TableIndex);
- assertEquals(expected.isAdd, actual.isAdd);
- }
-
- private void verifyInputAclSetInterfaceDisableWasInvoked(final InputAclSetInterface expected) {
- final ArgumentCaptor<InputAclSetInterface> argumentCaptor = ArgumentCaptor.forClass(InputAclSetInterface.class);
- verify(api).inputAclSetInterface(argumentCaptor.capture());
- final InputAclSetInterface actual = argumentCaptor.getValue();
- assertEquals(expected.swIfIndex, actual.swIfIndex);
- assertEquals(expected.l2TableIndex, actual.l2TableIndex);
- assertEquals(0, actual.isAdd);
+ private void whenInputAclSetInterfaceThenFailure() {
+ doReturn(failedFuture()).when(api).inputAclSetInterface(any(InputAclSetInterface.class));
}
private static InputAclSetInterface generateInputAclSetInterface(final byte isAdd, final int ifIndex,
customizer.writeCurrentAttributes(id, acl, writeContext);
- verifyInputAclSetInterfaceWasInvoked(generateInputAclSetInterface((byte) 1, IF_INDEX, ACL_TABLE_INDEX));
+ verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 1, IF_INDEX, ACL_TABLE_INDEX));
}
@Test
customizer.writeCurrentAttributes(id, acl, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyInputAclSetInterfaceWasInvoked(generateInputAclSetInterface((byte) 1, IF_INDEX, ACL_TABLE_INDEX));
+ verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 1, IF_INDEX, ACL_TABLE_INDEX));
return;
}
fail("WriteFailedException.CreateFailedException was expected");
customizer.deleteCurrentAttributes(id, acl, writeContext);
- verifyInputAclSetInterfaceDisableWasInvoked(generateInputAclSetInterface((byte) 0, IF_INDEX, ACL_TABLE_INDEX));
+ verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 0, IF_INDEX, ACL_TABLE_INDEX));
}
@Test
customizer.deleteCurrentAttributes(id, acl, writeContext);
} catch (WriteFailedException.DeleteFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyInputAclSetInterfaceDisableWasInvoked(
- generateInputAclSetInterface((byte) 0, IF_INDEX, ACL_TABLE_INDEX));
+ verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 0, IF_INDEX, ACL_TABLE_INDEX));
return;
}
fail("WriteFailedException.DeleteFailedException was expected");
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
import com.google.common.net.InetAddresses;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
customizer = new GreCustomizer(api, new NamingContext("generateInterfaceNAme", IFC_TEST_INSTANCE));
}
- private void whenGreAddDelTunnelThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
- final CompletionStage<GreAddDelTunnelReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<GreAddDelTunnelReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
+ private void whenGreAddDelTunnelThenSuccess() {
final GreAddDelTunnelReply reply = new GreAddDelTunnelReply();
reply.swIfIndex = IFACE_ID;
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.greAddDelTunnel(any(GreAddDelTunnel.class))).thenReturn(replyCS);
+ doReturn(future(reply)).when(api).greAddDelTunnel(any(GreAddDelTunnel.class));
}
- /**
- * Failure response send
- */
- private void whenGreAddDelTunnelThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<GreAddDelTunnelReply>createFutureException()).when(api)
- .greAddDelTunnel(any(GreAddDelTunnel.class));
+ private void whenGreAddDelTunnelThenFailure() {
+ doReturn(failedFuture()).when(api).greAddDelTunnel(any(GreAddDelTunnel.class));
}
private GreAddDelTunnel verifyGreAddDelTunnelWasInvoked(final Gre gre) throws VppInvocationException {
assertEquals(DEL_GRE, actual.isAdd);
}
- private static Gre generateGre(long vni) {
+ private static Gre generateGre() {
final GreBuilder builder = new GreBuilder();
builder.setSrc(new IpAddress(new Ipv4Address("192.168.20.10")));
builder.setDst(new IpAddress(new Ipv4Address("192.168.20.11")));
return builder.build();
}
- private static Gre generateGre() {
- return generateGre(Long.valueOf(11));
- }
-
@Test
public void testWriteCurrentAttributes() throws Exception {
final Gre gre = generateGre();
@Test
public void testUpdateCurrentAttributes() throws Exception {
try {
- customizer.updateCurrentAttributes(id, generateGre(10), generateGre(11), writeContext);
+ customizer.updateCurrentAttributes(id, generateGre(), generateGre(), writeContext);
} catch (WriteFailedException.UpdateFailedException e) {
assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
return;
package io.fd.honeycomb.translate.v3po.interfaces;
import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.util.TagRewriteOperation;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Assert;
import org.junit.Test;
-import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
}
private static InstanceIdentifier<Rewrite> getVlanTagRewriteId(final String name, final long index) {
- final Class<ChildOf<? super SubInterface>> child = (Class)Rewrite.class;
+ final Class<ChildOf<? super SubInterface>> child = (Class) Rewrite.class;
final InstanceIdentifier id =
- InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation(
- SubinterfaceAugmentation.class).child(SubInterfaces.class)
- .child(SubInterface.class, new SubInterfaceKey(index))
- .child(child);
+ InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation(
+ SubinterfaceAugmentation.class).child(SubInterfaces.class)
+ .child(SubInterface.class, new SubInterfaceKey(index))
+ .child(child);
return id;
}
/**
* Positive response
*/
- private void whenL2InterfaceVlanTagRewriteThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException {
- final CompletableFuture<L2InterfaceVlanTagRewriteReply> replyFuture = new CompletableFuture<>();
- final L2InterfaceVlanTagRewriteReply reply = new L2InterfaceVlanTagRewriteReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).l2InterfaceVlanTagRewrite(any(L2InterfaceVlanTagRewrite.class));
+ private void whenL2InterfaceVlanTagRewriteThenSuccess() {
+ doReturn(future(new L2InterfaceVlanTagRewriteReply())).when(api)
+ .l2InterfaceVlanTagRewrite(any(L2InterfaceVlanTagRewrite.class));
}
/**
* Failure response send
*/
- private void whenL2InterfaceVlanTagRewriteThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<L2InterfaceVlanTagRewriteReply>createFutureException()).when(api)
- .l2InterfaceVlanTagRewrite(any(L2InterfaceVlanTagRewrite.class));
- }
-
- private void verifyL2InterfaceVlanTagRewriteWasInvoked(final L2InterfaceVlanTagRewrite expected)
- throws VppInvocationException {
- ArgumentCaptor<L2InterfaceVlanTagRewrite> argumentCaptor =
- ArgumentCaptor.forClass(L2InterfaceVlanTagRewrite.class);
- verify(api).l2InterfaceVlanTagRewrite(argumentCaptor.capture());
- final L2InterfaceVlanTagRewrite actual = argumentCaptor.getValue();
- assertEquals(expected.swIfIndex, actual.swIfIndex);
- assertEquals(expected.vtrOp, actual.vtrOp);
- assertEquals(expected.pushDot1Q, actual.pushDot1Q);
- assertEquals(expected.tag1, actual.tag1);
- assertEquals(expected.tag2, actual.tag2);
+ private void whenL2InterfaceVlanTagRewriteThenFailure() {
+ doReturn(failedFuture()).when(api).l2InterfaceVlanTagRewrite(any(L2InterfaceVlanTagRewrite.class));
}
private void verifyL2InterfaceVlanTagRewriteDeleteWasInvoked() throws VppInvocationException {
final L2InterfaceVlanTagRewrite request = new L2InterfaceVlanTagRewrite();
request.swIfIndex = VLAN_IF_INDEX;
- verifyL2InterfaceVlanTagRewriteWasInvoked(request);
+ verify(api).l2InterfaceVlanTagRewrite(request);
}
@Test
customizer.writeCurrentAttributes(VLAN_IID, vlanTagRewrite, writeContext);
- verifyL2InterfaceVlanTagRewriteWasInvoked(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op));
+ verify(api).l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op));
}
@Test
customizer.writeCurrentAttributes(VLAN_IID, vlanTagRewrite, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyL2InterfaceVlanTagRewriteWasInvoked(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op));
+ verify(api).l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op));
return;
}
fail("WriteFailedException.CreateFailedException was expected");
customizer.updateCurrentAttributes(VLAN_IID, before, after, writeContext);
- verifyL2InterfaceVlanTagRewriteWasInvoked(
- generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1));
+ verify(api)
+ .l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1));
}
@Test
customizer.updateCurrentAttributes(VLAN_IID, before, after, writeContext);
} catch (WriteFailedException.UpdateFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyL2InterfaceVlanTagRewriteWasInvoked(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX,
- TagRewriteOperation.pop_1));
+ verify(api)
+ .l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1));
return;
}
fail("WriteFailedException.UpdateFailedException was expected");
import static org.mockito.Mockito.verify;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import java.util.Arrays;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.CVlan;
.child(SubInterface.class, new SubInterfaceKey(index));
}
- private void whenCreateSubifThenSuccess() throws ExecutionException, InterruptedException, VppBaseCallException {
- final CompletableFuture<CreateSubifReply> replyFuture = new CompletableFuture<>();
- final CreateSubifReply reply = new CreateSubifReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).createSubif(any(CreateSubif.class));
+ private void whenCreateSubifThenSuccess() {
+ doReturn(future(new CreateSubifReply())).when(api).createSubif(any(CreateSubif.class));
}
/**
* Failure response send
*/
- private void whenCreateSubifThenFailure() throws ExecutionException, InterruptedException, VppBaseCallException {
- doReturn(TestHelperUtils.<CreateSubifReply>createFutureException()).when(api)
- .createSubif(any(CreateSubif.class));
- }
-
- private void whenSwInterfaceSetFlagsThenSuccess()
- throws ExecutionException, InterruptedException, VppBaseCallException {
- final CompletableFuture<SwInterfaceSetFlagsReply> replyFuture = new CompletableFuture<>();
- final SwInterfaceSetFlagsReply reply = new SwInterfaceSetFlagsReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).swInterfaceSetFlags(any(SwInterfaceSetFlags.class));
+ private void whenCreateSubifThenFailure() {
+ doReturn(failedFuture()).when(api).createSubif(any(CreateSubif.class));
}
- private CreateSubif verifyCreateSubifWasInvoked(final CreateSubif expected) throws VppBaseCallException {
- ArgumentCaptor<CreateSubif> argumentCaptor = ArgumentCaptor.forClass(CreateSubif.class);
- verify(api).createSubif(argumentCaptor.capture());
- final CreateSubif actual = argumentCaptor.getValue();
-
- assertEquals(expected.swIfIndex, actual.swIfIndex);
- assertEquals(expected.subId, actual.subId);
- assertEquals(expected.noTags, actual.noTags);
- assertEquals(expected.oneTag, actual.oneTag);
- assertEquals(expected.twoTags, actual.twoTags);
- assertEquals(expected.dot1Ad, actual.dot1Ad);
- assertEquals(expected.exactMatch, actual.exactMatch);
- assertEquals(expected.defaultSub, actual.defaultSub);
- assertEquals(expected.outerVlanIdAny, actual.outerVlanIdAny);
- assertEquals(expected.innerVlanIdAny, actual.innerVlanIdAny);
- assertEquals(expected.outerVlanId, actual.outerVlanId);
- assertEquals(expected.innerVlanId, actual.innerVlanId);
- return actual;
+ private void whenSwInterfaceSetFlagsThenSuccess() {
+ doReturn(future(new SwInterfaceSetFlagsReply())).when(api).swInterfaceSetFlags(any(SwInterfaceSetFlags.class));
}
private SwInterfaceSetFlags verifySwInterfaceSetFlagsWasInvoked(final SwInterfaceSetFlags expected)
customizer.writeCurrentAttributes(id, subInterface, writeContext);
- verifyCreateSubifWasInvoked(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false));
+ verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false));
verify(mappingContext)
.put(eq(ContextTestUtils.getMappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq(
- ContextTestUtils.getMapping(SUB_IFACE_NAME, 0).get()));
+ ContextTestUtils.getMapping(SUB_IFACE_NAME, 0).get()));
}
@Test
customizer.writeCurrentAttributes(id, subInterface, writeContext);
- verifyCreateSubifWasInvoked(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ANY_ID, true));
+ verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ANY_ID, true));
verify(mappingContext)
.put(eq(ContextTestUtils.getMappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq(
- ContextTestUtils.getMapping(SUB_IFACE_NAME, 0).get()));
+ ContextTestUtils.getMapping(SUB_IFACE_NAME, 0).get()));
}
@Test
customizer.writeCurrentAttributes(id, subInterface, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyCreateSubifWasInvoked(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false));
+ verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false));
verify(mappingContext, times(0)).put(
eq(ContextTestUtils.getMappingIid(SUPER_IF_NAME, IFC_TEST_INSTANCE)),
eq(ContextTestUtils.getMapping(SUPER_IF_NAME, 0).get()));
import static org.mockito.Mockito.verify;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
@Override
public Object answer(final InvocationOnMock invocation) throws Throwable {
- final CompletableFuture<Object> reply = new CompletableFuture<>();
final TapConnectReply t = new TapConnectReply();
t.swIfIndex = idx++;
- reply.complete(t);
- return reply;
+ return future(t);
}
}).when(api).tapConnect(any(TapConnect.class));
@Test
public void testModify() throws Exception {
- final CompletableFuture<TapConnectReply> reply = new CompletableFuture<>();
final TapConnectReply t = new TapConnectReply();
t.swIfIndex = 0;
- reply.complete(t);
- doReturn(reply).when(api).tapConnect(any(TapConnect.class));
+ doReturn(future(t)).when(api).tapConnect(any(TapConnect.class));
- final CompletableFuture<TapModifyReply> replyModif = new CompletableFuture<>();
final TapModifyReply tmodif = new TapModifyReply();
tmodif.swIfIndex = 0;
- replyModif.complete(tmodif);
- doReturn(replyModif).when(api).tapModify(any(TapModify.class));
+ doReturn(future(tmodif)).when(api).tapModify(any(TapModify.class));
tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
@Test
public void testDelete() throws Exception {
- final CompletableFuture<TapConnectReply> reply = new CompletableFuture<>();
final TapConnectReply t = new TapConnectReply();
t.swIfIndex = 0;
- reply.complete(t);
- doReturn(reply).when(api).tapConnect(any(TapConnect.class));
+ doReturn(future(t)).when(api).tapConnect(any(TapConnect.class));
- final CompletableFuture<TapDeleteReply> replyDelete = new CompletableFuture<>();
- final TapDeleteReply tmodif = new TapDeleteReply();
- replyDelete.complete(tmodif);
- doReturn(replyDelete).when(api).tapDelete(any(TapDelete.class));
+ doReturn(future(new TapDeleteReply())).when(api).tapDelete(any(TapDelete.class));
tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
ContextTestUtils.mockMapping(mappingContext, "tap", 1, IFC_TEST_INSTANCE);
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
customizer = new VhostUserCustomizer(api, new NamingContext("generatedInterfaceName", "test-instance"));
}
- private void whenCreateVhostUserIfThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
- final CompletionStage<CreateVhostUserIfReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<CreateVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final CreateVhostUserIfReply reply = new CreateVhostUserIfReply();
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.createVhostUserIf(any(CreateVhostUserIf.class))).thenReturn(replyCS);
- }
-
- /**
- * Failure response send
- */
- private void whenCreateVhostUserIfThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<CreateVhostUserIfReply>createFutureException()).when(api)
- .createVhostUserIf(any(CreateVhostUserIf.class));
- }
-
- private void whenModifyVhostUserIfThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
- final CompletionStage<ModifyVhostUserIfReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<ModifyVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final ModifyVhostUserIfReply reply = new ModifyVhostUserIfReply();
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.modifyVhostUserIf(any(ModifyVhostUserIf.class))).thenReturn(replyCS);
- }
-
- /**
- * Failure response send
- */
- private void whenModifyVhostUserIfThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<ModifyVhostUserIfReply>createFutureException()).when(api)
- .modifyVhostUserIf(any(ModifyVhostUserIf.class));
- }
-
- private void whenDeleteVhostUserIfThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
- final CompletionStage<DeleteVhostUserIfReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<DeleteVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final DeleteVhostUserIfReply reply = new DeleteVhostUserIfReply();
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.deleteVhostUserIf(any(DeleteVhostUserIf.class))).thenReturn(replyCS);
- }
-
- /**
- * Failure response send
- */
- private void whenDeleteVhostUserIfThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<DeleteVhostUserIfReply>createFutureException()).when(api)
- .deleteVhostUserIf(any(DeleteVhostUserIf.class));
- }
-
private CreateVhostUserIf verifyCreateVhostUserIfWasInvoked(final VhostUser vhostUser)
throws VppInvocationException {
ArgumentCaptor<CreateVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(CreateVhostUserIf.class);
public void testWriteCurrentAttributes() throws Exception {
final VhostUser vhostUser = generateVhostUser(VhostUserRole.Server, "socketName");
- whenCreateVhostUserIfThenSuccess();
+ when(api.createVhostUserIf(any(CreateVhostUserIf.class))).thenReturn(future(new CreateVhostUserIfReply()));
customizer.writeCurrentAttributes(ID, vhostUser, writeContext);
verifyCreateVhostUserIfWasInvoked(vhostUser);
public void testWriteCurrentAttributesFailed() throws Exception {
final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName");
- whenCreateVhostUserIfThenFailure();
+ doReturn(failedFuture()).when(api).createVhostUserIf(any(CreateVhostUserIf.class));
try {
customizer.writeCurrentAttributes(ID, vhostUser, writeContext);
final VhostUser vhostUserAfter = generateVhostUser(VhostUserRole.Server, "socketName1");
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
- whenModifyVhostUserIfThenSuccess();
+ when(api.modifyVhostUserIf(any(ModifyVhostUserIf.class))).thenReturn(future(new ModifyVhostUserIfReply()));
customizer.updateCurrentAttributes(ID, vhostUserBefore, vhostUserAfter, writeContext);
verifyModifyVhostUserIfWasInvoked(vhostUserAfter, IFACE_ID);
final VhostUser vhostUserAfter = generateVhostUser(VhostUserRole.Server, "socketName1");
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
- whenModifyVhostUserIfThenFailure();
+ doReturn(failedFuture()).when(api).modifyVhostUserIf(any(ModifyVhostUserIf.class));
try {
customizer.updateCurrentAttributes(ID, vhostUserBefore, vhostUserAfter, writeContext);
final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName");
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
- whenDeleteVhostUserIfThenSuccess();
+ when(api.deleteVhostUserIf(any(DeleteVhostUserIf.class))).thenReturn(future(new DeleteVhostUserIfReply()));
customizer.deleteCurrentAttributes(ID, vhostUser, writeContext);
verifyDeleteVhostUserIfWasInvoked(IFACE_ID);
final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName");
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
- whenDeleteVhostUserIfThenFailure();
+ doReturn(failedFuture()).when(api).deleteVhostUserIf(any(DeleteVhostUserIf.class));
try {
customizer.deleteCurrentAttributes(ID, vhostUser, writeContext);
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.google.common.net.InetAddresses;
-import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.v3po.DisabledInterfacesManager;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
public void setUp() throws Exception {
InterfaceTypeTestUtils.setupWriteContext(writeContext,
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanTunnel.class);
- // TODO HONEYCOMB-116 create base class for tests using vppApi
- NamingContext namingContext = new NamingContext("generateInterfaceNAme", "test-instance");
- final ModificationCache toBeReturned = new ModificationCache();
- doReturn(toBeReturned).when(writeContext).getModificationCache();
- doReturn(mappingContext).when(writeContext).getMappingContext();
- customizer = new VxlanCustomizer(api, namingContext, disableContext);
+ customizer =
+ new VxlanCustomizer(api, new NamingContext("generateInterfaceNAme", "test-instance"), disableContext);
ifaceName = "eth0";
id = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(ifaceName))
.augmentation(VppInterfaceAugmentation.class).child(Vxlan.class);
}
- private void whenVxlanAddDelTunnelThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
- final CompletionStage<VxlanAddDelTunnelReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<VxlanAddDelTunnelReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final VxlanAddDelTunnelReply reply = new VxlanAddDelTunnelReply();
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.vxlanAddDelTunnel(any(VxlanAddDelTunnel.class))).thenReturn(replyCS);
+ private void whenVxlanAddDelTunnelThenSuccess() {
+ when(api.vxlanAddDelTunnel(any(VxlanAddDelTunnel.class))).thenReturn(future(new VxlanAddDelTunnelReply()));
}
- /**
- * Failure response send
- */
- private void whenVxlanAddDelTunnelThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<VxlanAddDelTunnelReply>createFutureException()).when(api)
- .vxlanAddDelTunnel(any(VxlanAddDelTunnel.class));
+ private void whenVxlanAddDelTunnelThenFailure() {
+ doReturn(failedFuture()).when(api).vxlanAddDelTunnel(any(VxlanAddDelTunnel.class));
}
private VxlanAddDelTunnel verifyVxlanAddDelTunnelWasInvoked(final Vxlan vxlan) throws VppInvocationException {
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.google.common.net.InetAddresses;
import io.fd.honeycomb.translate.v3po.DisabledInterfacesManager;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VxlanGpeBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.jvpp.VppBaseCallException;
-import org.openvpp.jvpp.core.dto.VxlanAddDelTunnelReply;
import org.openvpp.jvpp.core.dto.VxlanGpeAddDelTunnel;
import org.openvpp.jvpp.core.dto.VxlanGpeAddDelTunnelReply;
ifaceName = "elth0";
id = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(ifaceName))
- .augmentation(VppInterfaceAugmentation.class).child(VxlanGpe.class);
+ .augmentation(VppInterfaceAugmentation.class).child(VxlanGpe.class);
}
- private void whenVxlanGpeAddDelTunnelThenSuccess()
- throws ExecutionException, InterruptedException, VppBaseCallException, TimeoutException {
- final CompletionStage<VxlanGpeAddDelTunnelReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<VxlanGpeAddDelTunnelReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final VxlanGpeAddDelTunnelReply reply = new VxlanGpeAddDelTunnelReply();
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class))).thenReturn(replyCS);
+ private void whenVxlanGpeAddDelTunnelThenSuccess() {
+ when(api.vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class)))
+ .thenReturn(future(new VxlanGpeAddDelTunnelReply()));
}
- /**
- * Failure response send
- */
- private void whenVxlanGpeAddDelTunnelThenFailure()
- throws ExecutionException, InterruptedException, VppBaseCallException {
- doReturn(TestHelperUtils.<VxlanAddDelTunnelReply>createFutureException()).when(api)
- .vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class));
+ private void whenVxlanGpeAddDelTunnelThenFailure() {
+ doReturn(failedFuture()).when(api).vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class));
}
private VxlanGpeAddDelTunnel verifyVxlanGpeAddDelTunnelWasInvoked(final VxlanGpe vxlanGpe)
- throws VppBaseCallException {
+ throws VppBaseCallException {
ArgumentCaptor<VxlanGpeAddDelTunnel> argumentCaptor = ArgumentCaptor.forClass(VxlanGpeAddDelTunnel.class);
verify(api).vxlanGpeAddDelTunnel(argumentCaptor.capture());
final VxlanGpeAddDelTunnel actual = argumentCaptor.getValue();
assertEquals(0, actual.isIpv6);
assertArrayEquals(InetAddresses.forString(vxlanGpe.getLocal().getIpv4Address().getValue()).getAddress(),
- actual.local);
+ actual.local);
assertArrayEquals(InetAddresses.forString(vxlanGpe.getRemote().getIpv4Address().getValue()).getAddress(),
- actual.remote);
+ actual.remote);
assertEquals(vxlanGpe.getVni().getValue().intValue(), actual.vni);
assertEquals(vxlanGpe.getNextProtocol().getIntValue(), actual.protocol);
assertEquals(vxlanGpe.getEncapVrfId().intValue(), actual.encapVrfId);
assertEquals(ADD_VXLAN_GPE, actual.isAdd);
}
- private void verifyVxlanGpeDeleteWasInvoked(final VxlanGpe vxlanGpe) throws VppBaseCallException{
+ private void verifyVxlanGpeDeleteWasInvoked(final VxlanGpe vxlanGpe) throws VppBaseCallException {
final VxlanGpeAddDelTunnel actual = verifyVxlanGpeAddDelTunnelWasInvoked(vxlanGpe);
assertEquals(DEL_VXLAN_GPE, actual.isAdd);
}
customizer.writeCurrentAttributes(id, vxlanGpe, writeContext);
verifyVxlanGpeAddWasInvoked(vxlanGpe);
verify(mappingContext).put(eq(getMappingIid(ifaceName, "test-instance")), eq(
- getMapping(ifaceName, 0).get()));
+ getMapping(ifaceName, 0).get()));
}
@Test
verifyVxlanGpeAddWasInvoked(vxlanGpe);
// Mapping not stored due to failure
verify(mappingContext, times(0))
- .put(eq(getMappingIid(ifaceName, "test-instance")), eq(
- getMapping(ifaceName, 0).get()));
+ .put(eq(getMappingIid(ifaceName, "test-instance")), eq(
+ getMapping(ifaceName, 0).get()));
return;
}
fail("WriteFailedException.CreateFailedException was expected");
package io.fd.honeycomb.translate.v3po.interfaces.ip;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import io.fd.honeycomb.translate.v3po.interfaces.ip.subnet.validation.SubnetValidationException;
import io.fd.honeycomb.translate.v3po.interfaces.ip.subnet.validation.SubnetValidator;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatcher;
-import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.jvpp.VppBaseCallException;
-import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import org.openvpp.jvpp.core.dto.SwInterfaceAddDelAddress;
import org.openvpp.jvpp.core.dto.SwInterfaceAddDelAddressReply;
private static final String IFACE_NAME = "eth0";
private static final int IFACE_ID = 123;
- @Captor
- private ArgumentCaptor<List<Address>> addressesCaptor;
-
@Mock
private SubnetValidator subnetValidator;
customizer = new Ipv4AddressCustomizer(api, interfaceContext, subnetValidator);
- CompletableFuture future = new CompletableFuture();
- future.complete(new IpAddressDetailsReplyDump());
-
- when(api.ipAddressDump(Mockito.any())).thenReturn(future);
+ doReturn(future(new IpAddressDetailsReplyDump())).when(api).ipAddressDump(any());
when(writeContext.readAfter(Mockito.any()))
.thenReturn(Optional.of(new Ipv4Builder().setAddress(Collections.emptyList()).build()));
}
}
private void whenSwInterfaceAddDelAddressThenSuccess() {
- final CompletableFuture<SwInterfaceAddDelAddressReply> replyFuture = new CompletableFuture<>();
- final SwInterfaceAddDelAddressReply reply = new SwInterfaceAddDelAddressReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
+ doReturn(future(new SwInterfaceAddDelAddressReply())).when(api).swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
}
private void whenSwInterfaceAddDelAddressThenFailure() {
- doReturn(TestHelperUtils.createFutureException()).when(api)
- .swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
- }
-
- private void verifySwInterfaceAddDelAddressWasInvoked(final SwInterfaceAddDelAddress expected) throws
- VppInvocationException {
- ArgumentCaptor<SwInterfaceAddDelAddress> argumentCaptor =
- ArgumentCaptor.forClass(SwInterfaceAddDelAddress.class);
- verify(api).swInterfaceAddDelAddress(argumentCaptor.capture());
- verifySwInterfaceAddDelAddressWasInvoked(expected, argumentCaptor.getValue());
- }
-
- private void verifySwInterfaceAddDelAddressWasInvoked(final SwInterfaceAddDelAddress expected,
- final SwInterfaceAddDelAddress actual) throws
- VppInvocationException {
- assertArrayEquals(expected.address, actual.address);
- assertEquals(expected.addressLength, actual.addressLength);
- assertEquals(expected.delAll, actual.delAll);
- assertEquals(expected.isAdd, actual.isAdd);
- assertEquals(expected.isIpv6, actual.isIpv6);
- assertEquals(expected.swIfIndex, actual.swIfIndex);
+ doReturn(failedFuture()).when(api).swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
}
@Test
customizer.writeCurrentAttributes(id, data, writeContext);
- verifySwInterfaceAddDelAddressWasInvoked(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+ verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
(byte) 1, (byte) 24));
}
customizer.writeCurrentAttributes(id, data, writeContext);
} catch (WriteFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifySwInterfaceAddDelAddressWasInvoked(
+ verify(api).swInterfaceAddDelAddress(
generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
(byte) 1, (byte) 24));
return;
assertTrue(e.getCause() instanceof SubnetValidationException);
//verify that validation call was invoked with data from writeContext
- verify(subnetValidator, times(1)).checkNotAddingToSameSubnet(addressesCaptor.capture());
- assertEquals(addressList, addressesCaptor.getValue());
+ verify(subnetValidator, times(1)).checkNotAddingToSameSubnet(addressList);
}
}
customizer.deleteCurrentAttributes(id, data, writeContext);
- verifySwInterfaceAddDelAddressWasInvoked(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+ verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
(byte) 0, (byte) 24));
}
customizer.deleteCurrentAttributes(id, data, writeContext);
} catch (WriteFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifySwInterfaceAddDelAddressWasInvoked(
+ verify(api).swInterfaceAddDelAddress(
generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
(byte) 0, (byte) 24));
return;
Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
-
- final CompletableFuture<SwInterfaceAddDelAddressReply> replyFuture = new CompletableFuture<>();
- replyFuture.complete(new SwInterfaceAddDelAddressReply());
- ArgumentCaptor<SwInterfaceAddDelAddress> argumentCaptor =
- ArgumentCaptor.forClass(SwInterfaceAddDelAddress.class);
- doReturn(replyFuture).when(api).swInterfaceAddDelAddress(argumentCaptor.capture());
+ whenSwInterfaceAddDelAddressThenSuccess();
customizer.writeCurrentAttributes(id, data, writeContext);
- verifySwInterfaceAddDelAddressWasInvoked(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
- (byte) 1, (byte) expectedPrefixLength), argumentCaptor.getValue());
+ verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+ (byte) 1, (byte) expectedPrefixLength));
}
private void testSingleIllegalNetmask(final String stringMask) throws Exception {
Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
-
- final CompletableFuture<SwInterfaceAddDelAddressReply> replyFuture = new CompletableFuture<>();
- replyFuture.complete(new SwInterfaceAddDelAddressReply());
- ArgumentCaptor<SwInterfaceAddDelAddress> argumentCaptor =
- ArgumentCaptor.forClass(SwInterfaceAddDelAddress.class);
- doReturn(replyFuture).when(api).swInterfaceAddDelAddress(argumentCaptor.capture());
+ whenSwInterfaceAddDelAddressThenSuccess();
customizer.writeCurrentAttributes(id, data, writeContext);
} catch (IllegalArgumentException e) {
package io.fd.honeycomb.translate.v3po.interfaces.ip;
import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.google.common.io.BaseEncoding;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
customizer = new Ipv4NeighbourCustomizer(api, new NamingContext("prefix", IFC_CTX_NAME));
requestCaptor = ArgumentCaptor.forClass(IpNeighborAddDel.class);
- CompletableFuture<IpNeighborAddDelReply> future = new CompletableFuture<>();
- future.complete(new IpNeighborAddDelReply());
- when(api.ipNeighborAddDel(Mockito.any(IpNeighborAddDel.class))).thenReturn(future);
+ when(api.ipNeighborAddDel(any())).thenReturn(future(new IpNeighborAddDelReply()));
}
@Test
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.vppclassifier.VppClassifierContextManager;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
final InstanceIdentifier<Acl> id = getAclId(IF_NAME);
final AclBuilder builder = mock(AclBuilder.class);
- final CompletableFuture<ClassifyTableByInterfaceReply> replyFuture = new CompletableFuture<>();
final ClassifyTableByInterfaceReply reply = new ClassifyTableByInterfaceReply();
reply.l2TableId = TABLE_INDEX;
reply.ip4TableId = ~0;
reply.ip6TableId = ~0;
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).classifyTableByInterface(any(ClassifyTableByInterface.class));
+ doReturn(future(reply)).when(api).classifyTableByInterface(any(ClassifyTableByInterface.class));
doReturn(TABLE_NAME).when(classifyTableContext).getTableName(TABLE_INDEX, mappingContext);
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
-import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
map.put(0, v);
cache.put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, map);
- final CompletableFuture<GreTunnelDetailsReplyDump> greTunnelDetailsReplyDumpCompletionStage =
- new CompletableFuture<>();
-
final GreTunnelDetailsReplyDump value = new GreTunnelDetailsReplyDump();
final GreTunnelDetails greTunnelDetails = new GreTunnelDetails();
greTunnelDetails.isIpv6 = 0;
greTunnelDetails.srcAddress = InetAddress.getByName("1.2.3.5").getAddress();
greTunnelDetails.outerFibId = 55;
greTunnelDetails.swIfIndex = 0;
-
value.greTunnelDetails = Lists.newArrayList(greTunnelDetails);
- greTunnelDetailsReplyDumpCompletionStage.complete(value);
- doReturn(greTunnelDetailsReplyDumpCompletionStage).when(api).greTunnelDump(any(GreTunnelDump.class));
+ doReturn(future(value)).when(api).greTunnelDump(any(GreTunnelDump.class));
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.DisabledInterfacesManager;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.InterfaceTestUtils;
-import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.SwInterfaceDetails;
+import org.openvpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
import org.openvpp.jvpp.core.dto.SwInterfaceDump;
public class InterfaceCustomizerTest extends
verify(builder).setInterface(value);
}
+ public void whenSwInterfaceDumpThenReturn(final List<SwInterfaceDetails> interfaceList) {
+ final SwInterfaceDetailsReplyDump reply = new SwInterfaceDetailsReplyDump();
+ reply.swInterfaceDetails = interfaceList;
+ when(api.swInterfaceDump(any(SwInterfaceDump.class))).thenReturn(future(reply));
+ }
+
private void verifySwInterfaceDumpWasInvoked(final int nameFilterValid, final String ifaceName,
final int dumpIfcsInvocationCount)
throws VppInvocationException {
iface.l2AddressLength = 6;
iface.l2Address = new byte[iface.l2AddressLength];
final List<SwInterfaceDetails> interfaceList = Collections.singletonList(iface);
- InterfaceTestUtils.whenSwInterfaceDumpThenReturn(api, interfaceList);
+ whenSwInterfaceDumpThenReturn(interfaceList);
getCustomizer().readCurrentAttributes(id, builder, ctx);
.child(Interface.class, new InterfaceKey(ifaceName));
final InterfaceBuilder builder = getCustomizer().getBuilder(id);
- InterfaceTestUtils.whenSwInterfaceDumpThenReturn(api, Collections.emptyList());
+ whenSwInterfaceDumpThenReturn(Collections.emptyList());
try {
getCustomizer().readCurrentAttributes(id, builder, ctx);
iface.supSwIfIndex = 1;
iface.subId = 1;
final List<SwInterfaceDetails> interfaceList = Collections.singletonList(iface);
- InterfaceTestUtils.whenSwInterfaceDumpThenReturn(api, interfaceList);
+ whenSwInterfaceDumpThenReturn(interfaceList);
getCustomizer().readCurrentAttributes(id, builder, ctx);
swSubIf1.subId = 1;
swSubIf1.supSwIfIndex = 1;
swSubIf1.interfaceName = SUB_IFACE_NAME.getBytes();
- InterfaceTestUtils.whenSwInterfaceDumpThenReturn(api, Arrays.asList(swIf0, swIf1, swSubIf1));
+ whenSwInterfaceDumpThenReturn(Arrays.asList(swIf0, swIf1, swSubIf1));
final List<InterfaceKey> expectedIds = Arrays.asList(new InterfaceKey(IFACE0_NAME), new InterfaceKey(
IFACE1_NAME));
final SwInterfaceDetails swIf1 = new SwInterfaceDetails();
swIf1.swIfIndex = 1;
swIf1.interfaceName = IFACE1_NAME.getBytes();
- InterfaceTestUtils.whenSwInterfaceDumpThenReturn(api, Arrays.asList(swIf0, swIf1));
+ whenSwInterfaceDumpThenReturn(Arrays.asList(swIf0, swIf1));
final List<InterfaceKey> expectedIds = Arrays.asList(new InterfaceKey(IFACE0_NAME));
final List<InterfaceKey> actualIds = getCustomizer().getAllIds(id, ctx);
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.base.attributes.Interconnection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.base.attributes.interconnection.BridgeBasedBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.BridgeDomainDetails;
import org.openvpp.jvpp.core.dto.BridgeDomainDetailsReplyDump;
import org.openvpp.jvpp.core.dto.BridgeDomainDump;
}
private void whenBridgeDomainSwIfDumpThenReturn(final List<BridgeDomainSwIfDetails> bdSwIfList,
- final List<BridgeDomainDetails> bridgeDomainDetailses)
- throws ExecutionException, InterruptedException, VppInvocationException {
+ final List<BridgeDomainDetails> bridgeDomainDetailses) {
final BridgeDomainDetailsReplyDump reply = new BridgeDomainDetailsReplyDump();
reply.bridgeDomainSwIfDetails = bdSwIfList;
reply.bridgeDomainDetails = bridgeDomainDetailses;
-
- final CompletableFuture<BridgeDomainDetailsReplyDump> replyFuture = new CompletableFuture<>();
- replyFuture.complete(reply);
- when(api.bridgeDomainSwIfDump(any(BridgeDomainDump.class))).thenReturn(replyFuture);
+ when(api.bridgeDomainSwIfDump(any(BridgeDomainDump.class))).thenReturn(future(reply));
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.InterfaceTestUtils;
-import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev150527.sub._interface.base.attributes.Tags;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.jvpp.core.dto.SwInterfaceDetails;
+import org.openvpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
+import org.openvpp.jvpp.core.dto.SwInterfaceDump;
public class SubInterfaceCustomizerTest extends
ListReaderCustomizerTest<SubInterface, SubInterfaceKey, SubInterfaceBuilder> {
iface.subId = VLAN_IF_ID;
iface.supSwIfIndex = SUPER_IF_INDEX;
final List<SwInterfaceDetails> ifaces = Collections.singletonList(iface);
- InterfaceTestUtils.whenSwInterfaceDumpThenReturn(api, ifaces);
+
+ final SwInterfaceDetailsReplyDump reply = new SwInterfaceDetailsReplyDump();
+ reply.swInterfaceDetails = ifaces;
+ when(api.swInterfaceDump(any(SwInterfaceDump.class))).thenReturn(future(reply));
final List<SubInterfaceKey> allIds =
getCustomizer().getAllIds(getSubInterfaceId(SUPER_IF_NAME, VLAN_IF_ID), ctx);
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
-import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
map.put(0, v);
cache.put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, map);
- final CompletableFuture<VxlanTunnelDetailsReplyDump> vxlanTunnelDetailsReplyDumpCompletionStage =
- new CompletableFuture<>();
-
final VxlanTunnelDetailsReplyDump value = new VxlanTunnelDetailsReplyDump();
final VxlanTunnelDetails vxlanTunnelDetails = new VxlanTunnelDetails();
vxlanTunnelDetails.isIpv6 = 0;
vxlanTunnelDetails.encapVrfId = 55;
vxlanTunnelDetails.swIfIndex = 0;
vxlanTunnelDetails.vni = 9;
-
value.vxlanTunnelDetails = Lists.newArrayList(vxlanTunnelDetails);
- vxlanTunnelDetailsReplyDumpCompletionStage.complete(value);
-
- doReturn(vxlanTunnelDetailsReplyDumpCompletionStage).when(api).vxlanTunnelDump(any(VxlanTunnelDump.class));
-
+ doReturn(future(value)).when(api).vxlanTunnelDump(any(VxlanTunnelDump.class));
}
@Test
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
-import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
map.put(0, v);
cache.put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, map);
- final CompletableFuture<VxlanGpeTunnelDetailsReplyDump> vxlanGpeTunnelDetailsReplyDumpCompletionStage =
- new CompletableFuture<>();
-
final VxlanGpeTunnelDetailsReplyDump value = new VxlanGpeTunnelDetailsReplyDump();
final VxlanGpeTunnelDetails vxlanGpeTunnelDetails = new VxlanGpeTunnelDetails();
vxlanGpeTunnelDetails.isIpv6 = 0;
vxlanGpeTunnelDetails.encapVrfId = 55;
vxlanGpeTunnelDetails.decapVrfId = 66;
vxlanGpeTunnelDetails.swIfIndex = 0;
-
value.vxlanGpeTunnelDetails = Lists.newArrayList(vxlanGpeTunnelDetails);
- vxlanGpeTunnelDetailsReplyDumpCompletionStage.complete(value);
-
- doReturn(vxlanGpeTunnelDetailsReplyDumpCompletionStage).when(api).vxlanGpeTunnelDump(any(VxlanGpeTunnelDump.class));
-
+ doReturn(future(value)).when(api).vxlanGpeTunnelDump(any(VxlanGpeTunnelDump.class));
}
@Test
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.Arrays;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import org.hamcrest.CoreMatchers;
import org.junit.Test;
IpAddressDetailsReplyDump reply2 = new IpAddressDetailsReplyDump();
reply2.ipAddressDetails = ImmutableList.of(detail2);
- CompletableFuture<IpAddressDetailsReplyDump> future = new CompletableFuture<>();
- future.complete(reply);
- CompletableFuture<IpAddressDetailsReplyDump> future2 = new CompletableFuture<>();
- future2.complete(reply2);
-
- when(api.ipAddressDump(Mockito.any(IpAddressDump.class))).thenReturn(future).thenReturn(future2);
+ when(api.ipAddressDump(Mockito.any(IpAddressDump.class))).thenReturn(future(reply)).thenReturn(future(reply2));
when(ctx.getModificationCache()).thenReturn(cache);
final InstanceIdentifier<Address> id = getId("192.168.2.1", IFACE_NAME);
IpAddressDetailsReplyDump reply = new IpAddressDetailsReplyDump();
reply.ipAddressDetails = ImmutableList.of(detail1, detail2, detail3);
-
- CompletableFuture<IpAddressDetailsReplyDump> future = new CompletableFuture<>();
- future.complete(reply);
-
- when(api.ipAddressDump(Mockito.any(IpAddressDump.class))).thenReturn(future);
+ when(api.ipAddressDump(Mockito.any(IpAddressDump.class))).thenReturn(future(reply));
when(ctx.getModificationCache()).thenReturn(cache);
-
final AddressBuilder builder = new AddressBuilder();
final InstanceIdentifier<Address> id = getId("192.168.2.1", IFACE_NAME);
IpAddressDetailsReplyDump reply = new IpAddressDetailsReplyDump();
reply.ipAddressDetails = ImmutableList.of(detail1, detail2, detail3);
-
- CompletableFuture<IpAddressDetailsReplyDump> future = new CompletableFuture<>();
- future.complete(reply);
-
- when(api.ipAddressDump(Mockito.any(IpAddressDump.class))).thenReturn(future);
+ when(api.ipAddressDump(Mockito.any(IpAddressDump.class))).thenReturn(future(reply));
when(ctx.getModificationCache()).thenReturn(cache);
final InstanceIdentifier<Address> id = getId("192.168.2.1", IFACE_NAME);
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.util.FutureProducer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.openvpp.jvpp.core.future.FutureJVppCore;
import org.openvpp.jvpp.core.notification.CoreNotificationRegistry;
-public class InterfaceChangeNotificationProducerTest {
+public class InterfaceChangeNotificationProducerTest implements FutureProducer {
private static final String IFC_CTX_NAME = "ifc-test-instance";
private static final String IFACE_NAME = "eth0";
doReturn(notificationListenerReg).when(notificationRegistry).registerSwInterfaceSetFlagsNotificationCallback(
callbackArgumentCaptor.capture());
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+ doReturn(future(new WantInterfaceEventsReply())).when(jVpp).wantInterfaceEvents(any(WantInterfaceEvents.class));
}
@Test
public void testStart() throws Exception {
- final CompletableFuture<WantInterfaceEventsReply> response = new CompletableFuture<>();
- response.complete(new WantInterfaceEventsReply());
- doReturn(response).when(jVpp).wantInterfaceEvents(any(WantInterfaceEvents.class));
final InterfaceChangeNotificationProducer interfaceChangeNotificationProducer =
new InterfaceChangeNotificationProducer(jVpp, namingContext, mappingContext);
@Test
public void testNotification() throws Exception {
- final CompletableFuture<WantInterfaceEventsReply> response = new CompletableFuture<>();
- response.complete(new WantInterfaceEventsReply());
- doReturn(response).when(jVpp).wantInterfaceEvents(any(WantInterfaceEvents.class));
final InterfaceChangeNotificationProducer interfaceChangeNotificationProducer =
new InterfaceChangeNotificationProducer(jVpp, namingContext, mappingContext);
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.fd.honeycomb.translate.v3po.test;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import org.openvpp.jvpp.VppBaseCallException;
-import org.openvpp.jvpp.core.dto.SwInterfaceDetails;
-import org.openvpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
-import org.openvpp.jvpp.core.dto.SwInterfaceDump;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-
-public final class InterfaceTestUtils {
- private InterfaceTestUtils() {
- throw new UnsupportedOperationException("Utility class cannot be instantiated");
- }
-
- public static void whenSwInterfaceDumpThenReturn(final FutureJVppCore api, final List<SwInterfaceDetails> interfaceList)
- throws ExecutionException, InterruptedException, VppBaseCallException, TimeoutException {
- final CompletionStage<SwInterfaceDetailsReplyDump> replyCS = mock(CompletionStage.class);
- final CompletableFuture<SwInterfaceDetailsReplyDump> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final SwInterfaceDetailsReplyDump reply = new SwInterfaceDetailsReplyDump();
- reply.swInterfaceDetails = interfaceList;
- when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
- when(api.swInterfaceDump(any(SwInterfaceDump.class))).thenReturn(replyCS);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.fd.honeycomb.translate.v3po.test;
-
-import org.openvpp.jvpp.VppCallbackException;
-import org.openvpp.jvpp.dto.JVppReply;
-
-import java.util.concurrent.CompletableFuture;
-
-public class TestHelperUtils {
- private final static int ERROR_RETVAL = -1;
-
- /**
- * Static helper method for creation of Exception failure state in CompletableFuture object
- * with retval = -1
- * @return CompletableFuture with VppCallbackException as a cause
- */
- public static CompletableFuture<? extends JVppReply> createFutureException() {
- final CompletableFuture<? extends JVppReply> replyFuture = new CompletableFuture<>();
- replyFuture.completeExceptionally(new VppCallbackException("test-call", 1, ERROR_RETVAL));
- return replyFuture;
- }
-}
import static org.mockito.Mockito.verify;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
}
private void whenBdIpMacAddDelThenSuccess() {
- final CompletableFuture<BdIpMacAddDelReply> replyFuture = new CompletableFuture<>();
- final BdIpMacAddDelReply reply = new BdIpMacAddDelReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).bdIpMacAddDel(any(BdIpMacAddDel.class));
+ doReturn(future(new BdIpMacAddDelReply())).when(api).bdIpMacAddDel(any(BdIpMacAddDel.class));
}
private void whenBdIpMacAddDelThenFailure() {
- doReturn(TestHelperUtils.<BdIpMacAddDelReply>createFutureException()).when(api)
- .bdIpMacAddDel(any(BdIpMacAddDel.class));
+ doReturn(failedFuture()).when(api).bdIpMacAddDel(any(BdIpMacAddDel.class));
}
private BdIpMacAddDel generateBdIpMacAddDelRequest(final byte[] ipAddress, final byte[] macAddress,
package io.fd.honeycomb.translate.v3po.vpp;
+import static io.fd.honeycomb.translate.v3po.util.TranslateUtils.booleanToByte;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
+import javax.annotation.Nullable;
import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.BridgeDomains;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.bridge.domains.BridgeDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.bridge.domains.BridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.bridge.domains.BridgeDomainKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.BridgeDomainAddDel;
import org.openvpp.jvpp.core.dto.BridgeDomainAddDelReply;
customizer = new BridgeDomainCustomizer(api, new NamingContext("generatedBDName", BD_CTX_NAME));
}
+ @Nullable
+ private static Boolean intToBoolean(final int value) {
+ if (value == 0) {
+ return Boolean.FALSE;
+ }
+ if (value == 1) {
+ return Boolean.TRUE;
+ }
+ return null;
+ }
+
+ private static KeyedInstanceIdentifier<BridgeDomain, BridgeDomainKey> bdIdentifierForName(
+ final String bdName) {
+ return InstanceIdentifier.create(BridgeDomains.class).child(BridgeDomain.class, new BridgeDomainKey(bdName));
+ }
+
private BridgeDomain generateBridgeDomain(final String bdName) {
final byte arpTerm = 0;
final byte flood = 1;
final int forward, final int learn, final int uuf) {
return new BridgeDomainBuilder()
.setName(bdName)
- .setArpTermination(BridgeDomainTestUtils.intToBoolean(arpTerm))
- .setFlood(BridgeDomainTestUtils.intToBoolean(flood))
- .setForward(BridgeDomainTestUtils.intToBoolean(forward))
- .setLearn(BridgeDomainTestUtils.intToBoolean(learn))
- .setUnknownUnicastFlood(BridgeDomainTestUtils.intToBoolean(uuf))
+ .setArpTermination(intToBoolean(arpTerm))
+ .setFlood(intToBoolean(flood))
+ .setForward(intToBoolean(forward))
+ .setLearn(intToBoolean(learn))
+ .setUnknownUnicastFlood(intToBoolean(uuf))
.build();
}
private void verifyBridgeDomainAddOrUpdateWasInvoked(final BridgeDomain bd, final int bdId)
throws VppInvocationException {
final BridgeDomainAddDel expected = new BridgeDomainAddDel();
- expected.arpTerm = BridgeDomainTestUtils.booleanToByte(bd.isArpTermination());
- expected.flood = BridgeDomainTestUtils.booleanToByte(bd.isFlood());
- expected.forward = BridgeDomainTestUtils.booleanToByte(bd.isForward());
- expected.learn = BridgeDomainTestUtils.booleanToByte(bd.isLearn());
- expected.uuFlood = BridgeDomainTestUtils.booleanToByte(bd.isUnknownUnicastFlood());
+ expected.arpTerm = booleanToByte(bd.isArpTermination());
+ expected.flood = booleanToByte(bd.isFlood());
+ expected.forward = booleanToByte(bd.isForward());
+ expected.learn = booleanToByte(bd.isLearn());
+ expected.uuFlood = booleanToByte(bd.isUnknownUnicastFlood());
expected.isAdd = ADD_OR_UPDATE_BD;
expected.bdId = bdId;
verify(api).bridgeDomainAddDel(expected);
verify(api).bridgeDomainAddDel(expected);
}
- private void whenBridgeDomainAddDelThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException {
- final CompletionStage<BridgeDomainAddDelReply> replyCS = mock(CompletionStage.class);
- final CompletableFuture<BridgeDomainAddDelReply> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
- final BridgeDomainAddDelReply reply = new BridgeDomainAddDelReply();
- when(replyFuture.get()).thenReturn(reply);
- when(api.bridgeDomainAddDel(any(BridgeDomainAddDel.class))).thenReturn(replyCS);
+ private void whenBridgeDomainAddDelThenSuccess() {
+ when(api.bridgeDomainAddDel(any(BridgeDomainAddDel.class))).thenReturn(future(new BridgeDomainAddDelReply()));
}
- private void whenBridgeDomainAddDelThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
- doReturn(TestHelperUtils.<BridgeDomainAddDelReply>createFutureException()).when(api)
- .bridgeDomainAddDel(any(BridgeDomainAddDel.class));
+ private void whenBridgeDomainAddDelThenFailure() {
+ doReturn(failedFuture()).when(api).bridgeDomainAddDel(any(BridgeDomainAddDel.class));
}
@Test
whenBridgeDomainAddDelThenSuccess();
- customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
+ customizer.writeCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
verifyBridgeDomainAddOrUpdateWasInvoked(bd, bdId);
verify(mappingContext).put(
whenBridgeDomainAddDelThenSuccess();
- customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
+ customizer.writeCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
verifyBridgeDomainAddOrUpdateWasInvoked(bd, bdId);
verify(mappingContext).put(
whenBridgeDomainAddDelThenFailure();
try {
- customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
+ customizer.writeCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
verifyBridgeDomainAddOrUpdateWasInvoked(bd, bdId);
return;
whenBridgeDomainAddDelThenSuccess();
- customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
+ customizer.deleteCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
verifyBridgeDomainDeleteWasInvoked(bdId);
}
ContextTestUtils.mockEmptyMapping(mappingContext, bdName, BD_CTX_NAME);
try {
- customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
+ customizer.deleteCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
} catch (IllegalArgumentException e) {
verify(api, never()).bridgeDomainAddDel(any(BridgeDomainAddDel.class));
return;
whenBridgeDomainAddDelThenFailure();
try {
- customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
+ customizer.deleteCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
} catch (WriteFailedException.DeleteFailedException e) {
verifyBridgeDomainDeleteWasInvoked(bdId);
return;
whenBridgeDomainAddDelThenSuccess();
customizer
- .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), dataBefore, dataAfter,
+ .updateCurrentAttributes(bdIdentifierForName(bdName), dataBefore, dataAfter,
writeContext);
verifyBridgeDomainAddOrUpdateWasInvoked(dataAfter, bdId);
}
try {
customizer
- .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bdBefore, bdAfter,
+ .updateCurrentAttributes(bdIdentifierForName(bdName), bdBefore, bdAfter,
writeContext);
} catch (IllegalArgumentException e) {
verify(api, never()).bridgeDomainAddDel(any(BridgeDomainAddDel.class));
try {
customizer
- .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bdBefore, bdAfter,
+ .updateCurrentAttributes(bdIdentifierForName(bdName), bdBefore, bdAfter,
writeContext);
} catch (WriteFailedException.UpdateFailedException e) {
verifyBridgeDomainAddOrUpdateWasInvoked(bdAfter, bdId);
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.fd.honeycomb.translate.v3po.vpp;
-
-import javax.annotation.Nullable;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.BridgeDomains;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.bridge.domains.BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.bridge.domains.BridgeDomainKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-
-final class BridgeDomainTestUtils {
-
- private BridgeDomainTestUtils() {
- throw new UnsupportedOperationException("Utility class cannot be instantiated.");
- }
-
- public static byte booleanToByte(@Nullable final Boolean value) {
- return value != null && value ? (byte) 1 : (byte) 0;
- }
-
- @Nullable
- public static Boolean intToBoolean(final int value) {
- if (value == 0) {
- return Boolean.FALSE;
- }
- if (value == 1) {
- return Boolean.TRUE;
- }
- return null;
- }
-
- public static KeyedInstanceIdentifier<BridgeDomain, BridgeDomainKey> bdIdentifierForName(
- final String bdName) {
- return InstanceIdentifier.create(BridgeDomains.class).child(BridgeDomain.class, new BridgeDomainKey(bdName));
- }
-}
\ No newline at end of file
import static org.mockito.Mockito.verify;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.L2FibAddDel;
import org.openvpp.jvpp.core.dto.L2FibAddDelReply;
-import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
public class L2FibEntryCustomizerTest extends WriterCustomizerTest {
private static final String BD_CTX_NAME = "bd-test-instance";
}
private void whenL2FibAddDelThenSuccess() {
- final CompletableFuture<L2FibAddDelReply> replyFuture = new CompletableFuture<>();
- final L2FibAddDelReply reply = new L2FibAddDelReply();
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).l2FibAddDel(any(L2FibAddDel.class));
+ doReturn(future(new L2FibAddDelReply())).when(api).l2FibAddDel(any(L2FibAddDel.class));
}
private void whenL2FibAddDelThenFailure() {
- doReturn(TestHelperUtils.<L2InterfaceVlanTagRewriteReply>createFutureException()).when(api)
- .l2FibAddDel(any(L2FibAddDel.class));
+ doReturn(failedFuture()).when(api).l2FibAddDel(any(L2FibAddDel.class));
}
private L2FibAddDel generateL2FibAddDelRequest(final long mac, final byte isAdd) {
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.HexString;
new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
(byte) 0x05, (byte) 0x07, 0x00, 0x00, 0x00, 0x00};
dump.classifySessionDetails = Arrays.asList(details1, details2);
-
- final CompletableFuture<ClassifySessionDetailsReplyDump> replyFuture = new CompletableFuture<>();
- replyFuture.complete(dump);
- doReturn(replyFuture).when(api).classifySessionDump(any(ClassifySessionDump.class));
+ doReturn(future(dump)).when(api).classifySessionDump(any(ClassifySessionDump.class));
when(classifierContext.containsTable(TABLE_NAME, mappingContext)).thenReturn(true);
when(classifierContext.getTableIndex(TABLE_NAME, mappingContext)).thenReturn(TABLE_INDEX);
package io.fd.honeycomb.translate.v3po.vppclassifier;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
-import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.HexString;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.OpaqueIndex;
import org.openvpp.jvpp.VppBaseCallException;
import org.openvpp.jvpp.core.dto.ClassifyAddDelSession;
import org.openvpp.jvpp.core.dto.ClassifyAddDelSessionReply;
-import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
public class ClassifySessionWriterTest extends WriterCustomizerTest {
.child(ClassifySession.class, new ClassifySessionKey(new HexString(match)));
}
- private void whenClassifyAddDelSessionThenSuccess() throws ExecutionException, InterruptedException {
- final CompletableFuture<ClassifyAddDelSessionReply> replyFuture = new CompletableFuture<>();
- replyFuture.complete(new ClassifyAddDelSessionReply());
- doReturn(replyFuture).when(api).classifyAddDelSession(any(ClassifyAddDelSession.class));
- }
-
- private void whenClassifyAddDelSessionThenFailure() throws ExecutionException, InterruptedException {
- doReturn(TestHelperUtils.<L2InterfaceVlanTagRewriteReply>createFutureException()).when(api)
+ private void whenClassifyAddDelSessionThenSuccess() {
+ doReturn(future(new ClassifyAddDelSessionReply())).when(api)
.classifyAddDelSession(any(ClassifyAddDelSession.class));
}
- private void verifyClassifyAddDelSessionWasInvoked(final ClassifyAddDelSession expected) {
- ArgumentCaptor<ClassifyAddDelSession> argumentCaptor = ArgumentCaptor.forClass(ClassifyAddDelSession.class);
- verify(api).classifyAddDelSession(argumentCaptor.capture());
- final ClassifyAddDelSession actual = argumentCaptor.getValue();
- assertEquals(expected.opaqueIndex, actual.opaqueIndex);
- assertEquals(expected.isAdd, actual.isAdd);
- assertEquals(expected.tableIndex, actual.tableIndex);
- assertEquals(expected.hitNextIndex, actual.hitNextIndex);
- assertArrayEquals(expected.match, actual.match);
- assertEquals(expected.advance, actual.advance);
- }
-
- private void verifyClassifyAddDelSessionDeleteWasInvoked(final ClassifyAddDelSession expected) {
- ArgumentCaptor<ClassifyAddDelSession> argumentCaptor = ArgumentCaptor.forClass(ClassifyAddDelSession.class);
- verify(api).classifyAddDelSession(argumentCaptor.capture());
- final ClassifyAddDelSession actual = argumentCaptor.getValue();
- assertEquals(expected.opaqueIndex, actual.opaqueIndex);
- assertEquals(expected.isAdd, actual.isAdd);
- assertEquals(expected.tableIndex, actual.tableIndex);
+ private void whenClassifyAddDelSessionThenFailure() {
+ doReturn(failedFuture()).when(api).classifyAddDelSession(any(ClassifyAddDelSession.class));
}
private static ClassifyAddDelSession generateClassifyAddDelSession(final byte isAdd, final int tableIndex,
customizer.writeCurrentAttributes(id, classifySession, writeContext);
- verifyClassifyAddDelSessionWasInvoked(generateClassifyAddDelSession((byte) 1, TABLE_INDEX, SESSION_INDEX));
+ verify(api).classifyAddDelSession(generateClassifyAddDelSession((byte) 1, TABLE_INDEX, SESSION_INDEX));
}
@Test
customizer.writeCurrentAttributes(id, classifySession, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyClassifyAddDelSessionWasInvoked(generateClassifyAddDelSession((byte) 1, TABLE_INDEX, SESSION_INDEX));
+ verify(api).classifyAddDelSession(generateClassifyAddDelSession((byte) 1, TABLE_INDEX, SESSION_INDEX));
return;
}
fail("WriteFailedException.CreateFailedException was expected");
customizer.deleteCurrentAttributes(id, classifySession, writeContext);
- verifyClassifyAddDelSessionDeleteWasInvoked(
+ verify(api).classifyAddDelSession(
generateClassifyAddDelSession((byte) 0, TABLE_INDEX, SESSION_INDEX));
}
customizer.deleteCurrentAttributes(id, classifySession, writeContext);
} catch (WriteFailedException.DeleteFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyClassifyAddDelSessionDeleteWasInvoked(
+ verify(api).classifyAddDelSession(
generateClassifyAddDelSession((byte) 0, TABLE_INDEX, SESSION_INDEX));
return;
}
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.HexString;
@Test
public void testRead() throws ReadFailedException {
- final CompletableFuture<ClassifyTableInfoReply> replyFuture = new CompletableFuture<>();
- replyFuture.complete(generateClassifyTableInfoReply());
- doReturn(replyFuture).when(api).classifyTableInfo(any(ClassifyTableInfo.class));
+ doReturn(future(generateClassifyTableInfoReply())).when(api).classifyTableInfo(any(ClassifyTableInfo.class));
when(classifierContext.containsTable(TABLE_NAME_1, mappingContext)).thenReturn(true);
when(classifierContext.getTableIndex(TABLE_NAME_1, mappingContext)).thenReturn(TABLE_INDEX_1);
@Test
public void testGetAllIds() throws ReadFailedException {
- final CompletableFuture<ClassifyTableIdsReply> replyFuture = new CompletableFuture<>();
final ClassifyTableIdsReply reply = new ClassifyTableIdsReply();
reply.ids = new int[] {1, 2};
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).classifyTableIds(any(ClassifyTableIds.class));
+ doReturn(future(reply)).when(api).classifyTableIds(any(ClassifyTableIds.class));
when(classifierContext.getTableName(TABLE_INDEX_1, mappingContext)).thenReturn(TABLE_NAME_1);
when(classifierContext.getTableName(TABLE_INDEX_2, mappingContext)).thenReturn(TABLE_NAME_2);
package io.fd.honeycomb.translate.v3po.vppclassifier;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import org.junit.Test;
-import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.HexString;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.PacketHandlingAction;
import org.openvpp.jvpp.VppBaseCallException;
import org.openvpp.jvpp.core.dto.ClassifyAddDelTable;
import org.openvpp.jvpp.core.dto.ClassifyAddDelTableReply;
-import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
public class ClassifyTableWriterTest extends WriterCustomizerTest {
.child(ClassifyTable.class, new ClassifyTableKey(name));
}
- private void whenClassifyAddDelTableThenSuccess() throws ExecutionException, InterruptedException {
- final CompletableFuture<ClassifyAddDelTableReply> replyFuture = new CompletableFuture<>();
+ private void whenClassifyAddDelTableThenSuccess() {
final ClassifyAddDelTableReply reply = new ClassifyAddDelTableReply();
reply.newTableIndex = TABLE_INDEX;
- replyFuture.complete(reply);
- doReturn(replyFuture).when(api).classifyAddDelTable(any(ClassifyAddDelTable.class));
- }
-
- private void whenClassifyAddDelTableThenFailure() throws ExecutionException, InterruptedException {
- doReturn(TestHelperUtils.<L2InterfaceVlanTagRewriteReply>createFutureException()).when(api)
- .classifyAddDelTable(any(ClassifyAddDelTable.class));
+ doReturn(future(reply)).when(api).classifyAddDelTable(any(ClassifyAddDelTable.class));
}
- private void verifyClassifyAddDelTableAddWasInvoked(final ClassifyAddDelTable expected) {
- ArgumentCaptor<ClassifyAddDelTable> argumentCaptor = ArgumentCaptor.forClass(ClassifyAddDelTable.class);
- verify(api).classifyAddDelTable(argumentCaptor.capture());
- final ClassifyAddDelTable actual = argumentCaptor.getValue();
- assertEquals(expected.isAdd, actual.isAdd);
- assertEquals(~0, actual.tableIndex);
- assertEquals(expected.nbuckets, actual.nbuckets);
- assertEquals(expected.memorySize, actual.memorySize);
- assertEquals(expected.skipNVectors, actual.skipNVectors);
- assertEquals(expected.matchNVectors, actual.matchNVectors);
- assertEquals(expected.nextTableIndex, actual.nextTableIndex);
- assertEquals(expected.missNextIndex, actual.missNextIndex);
- assertArrayEquals(expected.mask, actual.mask);
+ private void whenClassifyAddDelTableThenFailure() {
+ doReturn(failedFuture()).when(api).classifyAddDelTable(any(ClassifyAddDelTable.class));
}
- private void verifyClassifyAddDelTableDeleteWasInvoked(final ClassifyAddDelTable expected) {
- ArgumentCaptor<ClassifyAddDelTable> argumentCaptor = ArgumentCaptor.forClass(ClassifyAddDelTable.class);
- verify(api).classifyAddDelTable(argumentCaptor.capture());
- final ClassifyAddDelTable actual = argumentCaptor.getValue();
- assertEquals(expected.isAdd, actual.isAdd);
- assertEquals(expected.tableIndex, actual.tableIndex);
+ private static ClassifyAddDelTable generateClassifyAddDelTable(final byte isAdd) {
+ return generateClassifyAddDelTable(isAdd, -1);
}
private static ClassifyAddDelTable generateClassifyAddDelTable(final byte isAdd, final int tableIndex) {
customizer.writeCurrentAttributes(id, classifyTable, writeContext);
- verifyClassifyAddDelTableAddWasInvoked(generateClassifyAddDelTable((byte) 1, TABLE_INDEX));
+ verify(api).classifyAddDelTable(generateClassifyAddDelTable((byte) 1));
verify(classifierContext)
.addTable(TABLE_INDEX, classifyTable.getName(), classifyTable.getClassifierNode(), mappingContext);
}
customizer.writeCurrentAttributes(id, classifyTable, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyClassifyAddDelTableAddWasInvoked(generateClassifyAddDelTable((byte) 1, TABLE_INDEX));
+ verify(api).classifyAddDelTable(generateClassifyAddDelTable((byte) 1));
verify(classifierContext, times(0))
.addTable(TABLE_INDEX, classifyTable.getName(), classifyTable.getClassifierNode(), mappingContext);
return;
customizer.deleteCurrentAttributes(id, classifyTable, writeContext);
- verifyClassifyAddDelTableDeleteWasInvoked(generateClassifyAddDelTable((byte) 0, TABLE_INDEX));
+ verify(api).classifyAddDelTable(generateClassifyAddDelTable((byte) 0, TABLE_INDEX));
}
@Test
customizer.deleteCurrentAttributes(id, classifyTable, writeContext);
} catch (WriteFailedException.DeleteFailedException e) {
assertTrue(e.getCause() instanceof VppBaseCallException);
- verifyClassifyAddDelTableDeleteWasInvoked(generateClassifyAddDelTable((byte) 0, TABLE_INDEX));
+ verify(api).classifyAddDelTable(generateClassifyAddDelTable((byte) 0, TABLE_INDEX));
return;
}
fail("WriteFailedException.DeleteFailedException was expected");
import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
throws ExecutionException, InterruptedException, VppInvocationException {
final L2FibTableEntryReplyDump reply = new L2FibTableEntryReplyDump();
reply.l2FibTableEntry = l2FibTableEntryList;
-
- final CompletableFuture<L2FibTableEntryReplyDump> replyFuture = new CompletableFuture<>();
- replyFuture.complete(reply);
- when(api.l2FibTableDump(any(L2FibTableDump.class))).thenReturn(replyFuture);
+ when(api.l2FibTableDump(any(L2FibTableDump.class))).thenReturn(future(reply));
}
@Test
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
-import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppStateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.Version;
@Test
public void testReadCurrentAttributes() throws Exception {
- final CompletableFuture<ShowVersionReply> replyFuture = new CompletableFuture<>();
final ShowVersionReply reply = new ShowVersionReply();
reply.version = new byte[] {};
reply.program = new byte[] {};
reply.buildDate = new byte[] {};
reply.buildDirectory = new byte[] {};
- replyFuture.complete(reply);
- when(api.showVersion(any(ShowVersion.class))).thenReturn(replyFuture);
+ when(api.showVersion(any(ShowVersion.class))).thenReturn(future(reply));
getCustomizer().readCurrentAttributes(InstanceIdentifier.create(Version.class), new VersionBuilder(), ctx);
verify(api).showVersion(any(ShowVersion.class));
}
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.impl.read.GenericListReader;
+import io.fd.honeycomb.translate.impl.read.GenericReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
+import io.fd.honeycomb.translate.util.read.registry.CompositeReaderRegistryBuilder;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.util.FutureProducer;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
+import javax.annotation.Nonnull;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppStateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.fib.attributes.L2FibTable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.fib.attributes.l2.fib.table.L2FibEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.fib.attributes.l2.fib.table.L2FibEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.BridgeDomains;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.BridgeDomainsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.Version;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.VersionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.BridgeDomainDetails;
import org.openvpp.jvpp.core.dto.BridgeDomainDetailsReplyDump;
import org.openvpp.jvpp.core.dto.BridgeDomainDump;
import org.openvpp.jvpp.core.dto.ShowVersionReply;
import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class VppStateTest {
+public class VppStateTest implements FutureProducer {
private static final String BD_CTX_NAME = "bd-test-instance";
@Mock
private MappingContext mappingContext;
private NamingContext bdContext;
- private NamingContext interfaceContext;
private ReaderRegistry readerRegistry;
+ private static InstanceIdentifier<BridgeDomains> bridgeDomainsId;
+
+ /**
+ * Create root VppState reader with all its children wired.
+ */
+ private static ReaderRegistry getVppStateReader(@Nonnull final FutureJVppCore jVpp,
+ @Nonnull final NamingContext bdContext) {
+ final CompositeReaderRegistryBuilder registry = new CompositeReaderRegistryBuilder();
+
+ // VppState(Structural)
+ final InstanceIdentifier<VppState> vppStateId = InstanceIdentifier.create(VppState.class);
+ registry.addStructuralReader(vppStateId, VppStateBuilder.class);
+ // Version
+ registry.add(new GenericReader<>(vppStateId.child(Version.class), new VersionCustomizer(jVpp)));
+ // BridgeDomains(Structural)
+ bridgeDomainsId = vppStateId.child(BridgeDomains.class);
+ registry.addStructuralReader(bridgeDomainsId, BridgeDomainsBuilder.class);
+ // BridgeDomain
+ registry.add(getBridgeDomainReader(jVpp, bdContext));
+ return registry.build();
+ }
+
+ private static GenericListReader<BridgeDomain, BridgeDomainKey, BridgeDomainBuilder> getBridgeDomainReader(
+ final @Nonnull FutureJVppCore jVpp, final @Nonnull NamingContext bdContext) {
+ final InstanceIdentifier<BridgeDomain> bridgeDomainId = bridgeDomainsId.child(BridgeDomain.class);
+ return new GenericListReader<>(bridgeDomainId, new BridgeDomainCustomizer(jVpp, bdContext));
+ }
+
@Before
public void setUp() throws Exception {
initMocks(this);
doReturn(mappingContext).when(ctx).getMappingContext();
bdContext = new NamingContext("generatedBdName", BD_CTX_NAME);
- interfaceContext = new NamingContext("generatedIfaceName", "ifc-test-instance");
- readerRegistry = VppStateTestUtils.getVppStateReader(api, bdContext);
+ readerRegistry = getVppStateReader(api, bdContext);
}
private static Version getVersion() {
.build();
}
- private void whenShowVersionThenReturn(int retval, Version version)
- throws ExecutionException, InterruptedException, VppInvocationException {
- final CompletableFuture<ShowVersionReply> replyFuture = new CompletableFuture<>();
+ private void whenShowVersionThenReturn(final Version version) {
final ShowVersionReply reply = new ShowVersionReply();
reply.buildDate = version.getBuildDate().getBytes();
reply.program = version.getName().getBytes();
reply.version = version.getBranch().getBytes();
reply.buildDirectory = version.getBuildDirectory().getBytes();
-
- replyFuture.complete(reply);
- when(api.showVersion(any(ShowVersion.class))).thenReturn(replyFuture);
+ when(api.showVersion(any(ShowVersion.class))).thenReturn(future(reply));
}
- private void whenL2FibTableDumpThenReturn(final List<L2FibTableEntry> entryList)
- throws ExecutionException, InterruptedException, VppInvocationException {
- final CompletionStage<L2FibTableEntryReplyDump> replyCS = mock(CompletionStage.class);
- final CompletableFuture<L2FibTableEntryReplyDump> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
+ private void whenL2FibTableDumpThenReturn(final List<L2FibTableEntry> entryList) {
final L2FibTableEntryReplyDump reply = new L2FibTableEntryReplyDump();
reply.l2FibTableEntry = entryList;
- when(replyFuture.get()).thenReturn(reply);
- when(api.l2FibTableDump(any(L2FibTableDump.class))).thenReturn(replyCS);
+ when(api.l2FibTableDump(any(L2FibTableDump.class))).thenReturn(future(reply));
}
- private void whenBridgeDomainDumpThenReturn(final List<BridgeDomainDetails> bdList)
- throws ExecutionException, InterruptedException, VppInvocationException {
- final CompletionStage<BridgeDomainDetailsReplyDump> replyCS = mock(CompletionStage.class);
- final CompletableFuture<BridgeDomainDetailsReplyDump> replyFuture = mock(CompletableFuture.class);
- when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
+ private void whenBridgeDomainDumpThenReturn(final List<BridgeDomainDetails> bdList) {
final BridgeDomainDetailsReplyDump reply = new BridgeDomainDetailsReplyDump();
reply.bridgeDomainDetails = bdList;
- when(replyFuture.get()).thenReturn(reply);
doAnswer(invocation -> {
BridgeDomainDump request = (BridgeDomainDump) invocation.getArguments()[0];
} else {
reply.bridgeDomainDetails = Collections.singletonList(bdList.get(request.bdId));
}
- return replyCS;
+ return future(reply);
}).when(api).bridgeDomainDump(any(BridgeDomainDump.class));
}
@Test
public void testReadAll() throws Exception {
final Version version = getVersion();
- whenShowVersionThenReturn(0, version);
+ whenShowVersionThenReturn(version);
final BridgeDomainDetails bridgeDomainDetails = new BridgeDomainDetails();
final BridgeDomainDetails bridgeDomainDetails2 = new BridgeDomainDetails();
@Test
public void testReadSpecific() throws Exception {
final Version version = getVersion();
- whenShowVersionThenReturn(0, version);
+ whenShowVersionThenReturn(version);
whenBridgeDomainDumpThenReturn(Collections.emptyList());
final Optional<? extends DataObject> read = readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx);
@Test
public void testReadBridgeDomains() throws Exception {
final Version version = getVersion();
- whenShowVersionThenReturn(0, version);
+ whenShowVersionThenReturn(version);
final BridgeDomainDetails details = new BridgeDomainDetails();
whenBridgeDomainDumpThenReturn(Collections.singletonList(details));
@Test
public void testReadBridgeDomainAll() throws Exception {
final Version version = getVersion();
- whenShowVersionThenReturn(0, version);
+ whenShowVersionThenReturn(version);
final BridgeDomainDetails details = new BridgeDomainDetails();
whenBridgeDomainDumpThenReturn(Collections.singletonList(details));
mockBdMapping(details, "bd2");
VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
final GenericListReader<BridgeDomain, BridgeDomainKey, BridgeDomainBuilder> bridgeDomainReader =
- VppStateTestUtils.getBridgeDomainReader(api, bdContext);
+ getBridgeDomainReader(api, bdContext);
final List<BridgeDomain> read =
bridgeDomainReader.readList(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
mockBdMapping(bd, bdName);
whenBridgeDomainDumpThenReturn(Collections.singletonList(bd));
- whenShowVersionThenReturn(0, getVersion());
+ whenShowVersionThenReturn(getVersion());
VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
@Test
public void testReadVersion() throws Exception {
- whenShowVersionThenReturn(0, getVersion());
+ whenShowVersionThenReturn(getVersion());
whenBridgeDomainDumpThenReturn(Collections.emptyList());
VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.fd.honeycomb.translate.v3po.vppstate;
-
-import io.fd.honeycomb.translate.impl.read.GenericListReader;
-import io.fd.honeycomb.translate.impl.read.GenericReader;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import io.fd.honeycomb.translate.util.read.registry.CompositeReaderRegistryBuilder;
-import io.fd.honeycomb.translate.v3po.util.NamingContext;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppState;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppStateBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.BridgeDomains;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.BridgeDomainsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.Version;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-
-final class VppStateTestUtils {
-
- private static InstanceIdentifier<BridgeDomains> bridgeDomainsId;
-
- public VppStateTestUtils() {
- }
-
- /**
- * Create root VppState reader with all its children wired.
- */
- static ReaderRegistry getVppStateReader(@Nonnull final FutureJVppCore jVpp,
- @Nonnull final NamingContext bdContext) {
- final CompositeReaderRegistryBuilder registry = new CompositeReaderRegistryBuilder();
-
- // VppState(Structural)
- final InstanceIdentifier<VppState> vppStateId = InstanceIdentifier.create(VppState.class);
- registry.addStructuralReader(vppStateId, VppStateBuilder.class);
- // Version
- registry.add(new GenericReader<>(vppStateId.child(Version.class), new VersionCustomizer(jVpp)));
- // BridgeDomains(Structural)
- bridgeDomainsId = vppStateId.child(BridgeDomains.class);
- registry.addStructuralReader(bridgeDomainsId, BridgeDomainsBuilder.class);
- // BridgeDomain
- registry.add(getBridgeDomainReader(jVpp, bdContext));
- return registry.build();
- }
-
- static GenericListReader<BridgeDomain, BridgeDomainKey, BridgeDomainBuilder> getBridgeDomainReader(
- final @Nonnull FutureJVppCore jVpp, final @Nonnull NamingContext bdContext) {
- final InstanceIdentifier<BridgeDomain> bridgeDomainId = bridgeDomainsId.child(BridgeDomain.class);
- return new GenericListReader<>(bridgeDomainId, new BridgeDomainCustomizer(jVpp, bdContext));
- }
-}
<artifactId>translate-spi</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>io.fd.vpp</groupId>
+ <artifactId>jvpp-registry</artifactId>
+ </dependency>
<dependency>
<groupId>io.fd.vpp</groupId>
<artifactId>jvpp-core</artifactId>
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.util.FutureProducer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
* @param <D> Specific DataObject derived type (Identifiable), that is handled by this customizer
* @param <B> Specific Builder for handled type (D)
*/
-public abstract class ReaderCustomizerTest<D extends DataObject, B extends Builder<D>> {
+public abstract class ReaderCustomizerTest<D extends DataObject, B extends Builder<D>> implements FutureProducer {
@Mock
protected FutureJVppCore api;
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.vpp.test.util;
+
+import java.util.concurrent.CompletableFuture;
+import javax.annotation.Nonnull;
+import org.openvpp.jvpp.VppCallbackException;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+/**
+ * <p>VPP translation test helper, that produces instances of {@link CompletableFuture} with desired results.</p>
+ * <p>Useful when stubbing {@link FutureJVppCore} methods: <br>{@code when(api.showVersion(any())).thenReturn(future(new
+ * ShowVersionReply()));}</p>
+ */
+public interface FutureProducer {
+
+ /**
+ * Returns {@link CompletableFuture} with desired result.
+ *
+ * @param result returned when {@link CompletableFuture#get()} is invoked
+ * @param <T> the result type of returned future
+ */
+ default <T> CompletableFuture<T> future(@Nonnull final T result) {
+ final CompletableFuture<T> future = new CompletableFuture<>();
+ future.complete(result);
+ return future;
+ }
+
+ /**
+ * Returns {@link CompletableFuture} with provided {@link Exception} as a result.
+ *
+ * @param exception to be thrown when {@link CompletableFuture#get()} is invoked
+ * @param <T> the result type of returned future
+ */
+ default <T> CompletableFuture<T> failedFuture(@Nonnull final Exception exception) {
+ final CompletableFuture<T> future = new CompletableFuture<>();
+ future.completeExceptionally(exception);
+ return future;
+ }
+
+ /**
+ * Returns {@link CompletableFuture} with VppCallbackException(retval = -1) as a cause.
+ *
+ * @param <T> the result type of returned future
+ */
+ default <T> CompletableFuture<T> failedFuture() {
+ return failedFuture(new VppCallbackException("test-call", 1 /* ctxId */, -1 /* retval */));
+ }
+}
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.vpp.test.util.FutureProducer;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.Mockito;
/**
* Generic test for classes implementing {@link WriterCustomizer} interface.
*/
-public abstract class WriterCustomizerTest {
+public abstract class WriterCustomizerTest implements FutureProducer {
@Mock
protected FutureJVppCore api;
Code Review / honeycomb.git / commitdiff