<artifactId>hamcrest-all</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>io.fd.honeycomb.vpp</groupId>
+ <artifactId>vpp-translate-test</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
</dependencies>
</project>
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
-import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
-import io.fd.honeycomb.translate.write.WriteContext;
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.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
-import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSets;
import org.openvpp.jvpp.core.dto.LispAddDelLocatorReply;
import org.openvpp.jvpp.core.future.FutureJVppCore;
-
-public class InterfaceCustomizerTest {
-
- @Mock
- private FutureJVppCore fakeJvpp;
-
- @Mock
- private WriteContext writeContext;
-
- @Mock
- private MappingContext mappingContext;
+public class InterfaceCustomizerTest extends WriterCustomizerTest {
@Captor
private ArgumentCaptor<LispAddDelLocator> intfCaptor;
private Interface intf;
private InterfaceCustomizer customizer;
- @Before
- public void init() {
- MockitoAnnotations.initMocks(this);
-
+ @Override
+ public void setUp() {
id = InstanceIdentifier.builder(Lisp.class)
.child(LocatorSets.class)
.child(LocatorSet.class, new LocatorSetKey("Locator"))
namingContext = new NamingContext("PREFIX", "INSTANCE");
- customizer = new InterfaceCustomizer(fakeJvpp, namingContext);
+ customizer = new InterfaceCustomizer(api, namingContext);
fakeReply = new LispAddDelLocatorReply();
completeFuture = new CompletableFuture<>();
completeFuture.complete(fakeReply);
- when(writeContext.getMappingContext()).thenReturn(mappingContext);
when(mappingContext.read(Mockito.any()))
.thenReturn(Optional.of((DataObject) new MappingBuilder().setIndex(5).setName("interface").build()));
- when(fakeJvpp.lispAddDelLocator(any(LispAddDelLocator.class))).thenReturn(completeFuture);
-
+ when(api.lispAddDelLocator(any(LispAddDelLocator.class))).thenReturn(completeFuture);
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
customizer.writeCurrentAttributes(id, intf, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelLocator(intfCaptor.capture());
+ verify(api, times(1)).lispAddDelLocator(intfCaptor.capture());
LispAddDelLocator request = intfCaptor.getValue();
@Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws WriteFailedException {
- new InterfaceCustomizer(fakeJvpp, namingContext)
+ new InterfaceCustomizer(api, namingContext)
.updateCurrentAttributes(null, null, null, null);
}
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
- new InterfaceCustomizer(fakeJvpp, namingContext)
+ new InterfaceCustomizer(api, namingContext)
.deleteCurrentAttributes(null, null, null);
}
public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
customizer.deleteCurrentAttributes(id, intf, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelLocator(intfCaptor.capture());
+ verify(api, times(1)).lispAddDelLocator(intfCaptor.capture());
LispAddDelLocator request = intfCaptor.getValue();
import static org.mockito.Mockito.when;
import io.fd.honeycomb.lisp.context.util.EidMappingContext;
-import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
-import io.fd.honeycomb.translate.write.WriteContext;
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.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
-import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
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.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class LocalMappingCustomizerTest {
-
- @Mock
- private FutureJVppCore fakeJvpp;
-
+public class LocalMappingCustomizerTest extends WriterCustomizerTest {
@Captor
private ArgumentCaptor<LispAddDelLocalEid> mappingCaptor;
private CompletableFuture<LispAddDelLocalEidReply> completeFuture;
private LocalMappingCustomizer customizer;
private EidMappingContext localMappingContext;
- private WriteContext writeContext;
- private MappingContext mappingCtx;
-
- @Before
- public void init() {
- MockitoAnnotations.initMocks(this);
+ @Override
+ public void setUp() {
final Eid
eid = new EidBuilder().setAddress(
new Ipv4Builder().setIpv4(
mappingId = new MappingId("REMOTE");
final LocalMappingKey key = new LocalMappingKey(mappingId);
localMappingContext = new EidMappingContext("local");
- mappingCtx = mock(MappingContext.class);
- writeContext = mock(WriteContext.class);
mapping = new LocalMappingBuilder()
.setEid(eid)
fakeReply = new LispAddDelLocalEidReply();
completeFuture = new CompletableFuture<>();
completeFuture.complete(fakeReply);
- customizer = new LocalMappingCustomizer(fakeJvpp, localMappingContext);
+ customizer = new LocalMappingCustomizer(api, localMappingContext);
- when(fakeJvpp.lispAddDelLocalEid(any(LispAddDelLocalEid.class))).thenReturn(completeFuture);
- when(writeContext.getMappingContext()).thenReturn(mappingCtx);
- when(mappingCtx.read(Mockito.any())).thenReturn(com.google.common.base.Optional
+ when(api.lispAddDelLocalEid(any(LispAddDelLocalEid.class))).thenReturn(completeFuture);
+ when(mappingContext.read(Mockito.any())).thenReturn(com.google.common.base.Optional
.of(new LocalMappingBuilder().setKey(key).setId(mappingId).setEid(eid).build()));
}
@Test
public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
//to simulate no mapping
- when(mappingCtx.read(Mockito.any())).thenReturn(com.google.common.base.Optional.absent());
+ when(mappingContext.read(Mockito.any())).thenReturn(com.google.common.base.Optional.absent());
customizer.writeCurrentAttributes(id, mapping, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelLocalEid(mappingCaptor.capture());
+ verify(api, times(1)).lispAddDelLocalEid(mappingCaptor.capture());
LispAddDelLocalEid request = mappingCaptor.getValue();
public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
customizer.deleteCurrentAttributes(id, mapping, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelLocalEid(mappingCaptor.capture());
+ verify(api, times(1)).lispAddDelLocalEid(mappingCaptor.capture());
LispAddDelLocalEid request = mappingCaptor.getValue();
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
-import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
+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.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSets;
import org.openvpp.jvpp.core.dto.LispAddDelLocatorSetReply;
import org.openvpp.jvpp.core.dto.LispLocatorSetDetails;
import org.openvpp.jvpp.core.dto.LispLocatorSetDetailsReplyDump;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
+public class LocatorSetCustomizerTest extends WriterCustomizerTest {
-public class LocatorSetCustomizerTest {
-
- private FutureJVppCore fakeJvpp;
private NamingContext locatorSetContext;
- private MappingContext mappingContext;
- private ModificationCache cache;
- private WriteContext context;
- @Before
- public void init() {
- fakeJvpp = mock(FutureJVppCore.class);
+ @Override
+ public void setUp() {
locatorSetContext = new NamingContext("locator-set", "instance");
- context = mock(WriteContext.class);
- mappingContext = mock(MappingContext.class);
- cache = new ModificationCache();
- when(context.getMappingContext()).thenReturn(mappingContext);
- when(context.getModificationCache()).thenReturn(cache);
}
-
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesNullData() throws WriteFailedException {
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext).writeCurrentAttributes(null, null, null);
+ new LocatorSetCustomizer(api, locatorSetContext).writeCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testWriteCurrentAttributesBadData() throws WriteFailedException {
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext)
+ new LocatorSetCustomizer(api, locatorSetContext)
.writeCurrentAttributes(null, mock(LocatorSet.class), null);
}
CompletableFuture<LispAddDelLocatorSetReply> completeFuture = new CompletableFuture<>();
completeFuture.complete(fakeReply);
- when(fakeJvpp.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
- when(context.readAfter(validId)).thenReturn(Optional.of(locatorSet));
+ when(api.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
+ when(writeContext.readAfter(validId)).thenReturn(Optional.of(locatorSet));
final LispLocatorSetDetailsReplyDump reply = new LispLocatorSetDetailsReplyDump();
LispLocatorSetDetails details = new LispLocatorSetDetails();
cache.put(io.fd.honeycomb.lisp.translate.read.LocatorSetCustomizer.LOCATOR_SETS_CACHE_ID, reply);
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext).writeCurrentAttributes(validId, locatorSet, context);
+ new LocatorSetCustomizer(api, locatorSetContext).writeCurrentAttributes(validId, locatorSet, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
+ verify(api, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
LispAddDelLocatorSet request = locatorSetCaptor.getValue();
assertNotNull(request);
assertEquals("Locator", new String(request.locatorSetName));
assertEquals(1, request.isAdd);
-
}
@Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws WriteFailedException {
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext).updateCurrentAttributes(null, null, null, null);
+ new LocatorSetCustomizer(api, locatorSetContext).updateCurrentAttributes(null, null, null, null);
}
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext).deleteCurrentAttributes(null, null, null);
+ new LocatorSetCustomizer(api, locatorSetContext).deleteCurrentAttributes(null, null, null);
}
@Test(expected = NullPointerException.class)
public void testDeleteCurrentAttributesBadData() throws WriteFailedException {
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext)
+ new LocatorSetCustomizer(api, locatorSetContext)
.deleteCurrentAttributes(null, mock(LocatorSet.class), null);
}
CompletableFuture<LispAddDelLocatorSetReply> completeFuture = new CompletableFuture<>();
completeFuture.complete(fakeReply);
- when(fakeJvpp.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
+ when(api.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
- new LocatorSetCustomizer(fakeJvpp, locatorSetContext).deleteCurrentAttributes(null, locatorSet, context);
+ new LocatorSetCustomizer(api, locatorSetContext).deleteCurrentAttributes(null, locatorSet, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
+ verify(api, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
LispAddDelLocatorSet request = locatorSetCaptor.getValue();
assertNotNull(request);
assertEquals("Locator", new String(request.locatorSetName));
assertEquals(0, request.isAdd);
-
}
}
import static org.mockito.Mockito.when;
import io.fd.honeycomb.lisp.context.util.EidMappingContext;
-import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
-import io.fd.honeycomb.translate.write.WriteContext;
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.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
-import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MapReplyAction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.EidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.locator.list.NegativeMappingBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.locator.list.positive.mapping.rlocs.Locator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.locator.list.positive.mapping.rlocs.LocatorBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.jvpp.core.dto.LispAddDelRemoteMapping;
import org.openvpp.jvpp.core.dto.LispAddDelRemoteMappingReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class RemoteMappingCustomizerTest {
-
- @Mock
- private FutureJVppCore fakeJvpp;
+public class RemoteMappingCustomizerTest extends WriterCustomizerTest {
@Captor
private ArgumentCaptor<LispAddDelRemoteMapping> mappingCaptor;
private CompletableFuture<LispAddDelRemoteMappingReply> completeFuture;
private InstanceIdentifier<RemoteMapping> id;
private EidMappingContext remoteMappingContext;
- private WriteContext writeContext;
- private MappingContext mapping;
-
-
- @Before
- public void init() {
- MockitoAnnotations.initMocks(this);
+ @Override
+ public void setUp() {
final Eid eid = new EidBuilder().setAddress(
new Ipv4Builder().setIpv4(
new Ipv4Address("192.168.2.1"))
mappingId = new MappingId("REMOTE");
final RemoteMappingKey key = new RemoteMappingKey(mappingId);
remoteMappingContext = new EidMappingContext("remote");
- mapping = mock(MappingContext.class);
- writeContext = mock(WriteContext.class);
intf = new RemoteMappingBuilder()
fakeReply = new LispAddDelRemoteMappingReply();
completeFuture = new CompletableFuture<>();
completeFuture.complete(fakeReply);
- customizer = new RemoteMappingCustomizer(fakeJvpp, remoteMappingContext);
+ customizer = new RemoteMappingCustomizer(api, remoteMappingContext);
- when(fakeJvpp.lispAddDelRemoteMapping(Mockito.any())).thenReturn(completeFuture);
- when(writeContext.getMappingContext()).thenReturn(mapping);
- when(mapping.read(Mockito.any())).thenReturn(com.google.common.base.Optional
+ when(api.lispAddDelRemoteMapping(Mockito.any())).thenReturn(completeFuture);
+ when(mappingContext.read(Mockito.any())).thenReturn(com.google.common.base.Optional
.of(new RemoteMappingBuilder().setKey(key).setId(mappingId).setEid(eid).build()));
}
@Test
public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
//to simulate no mapping
- when(mapping.read(Mockito.any())).thenReturn(com.google.common.base.Optional.absent());
+ when(mappingContext.read(Mockito.any())).thenReturn(com.google.common.base.Optional.absent());
customizer.writeCurrentAttributes(id, intf, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelRemoteMapping(mappingCaptor.capture());
+ verify(api, times(1)).lispAddDelRemoteMapping(mappingCaptor.capture());
LispAddDelRemoteMapping request = mappingCaptor.getValue();
public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
customizer.deleteCurrentAttributes(id, intf, writeContext);
- verify(fakeJvpp, times(1)).lispAddDelRemoteMapping(mappingCaptor.capture());
+ verify(api, times(1)).lispAddDelRemoteMapping(mappingCaptor.capture());
LispAddDelRemoteMapping request = mappingCaptor.getValue();
</dependency>
<!-- Testing Dependencies -->
+ <dependency>
+ <groupId>io.fd.honeycomb.vpp</groupId>
+ <artifactId>vpp-translate-test</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import io.fd.honeycomb.translate.MappingContext;
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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
-import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.openvpp.jvpp.core.dto.InputAclSetInterface;
import org.openvpp.jvpp.core.dto.InputAclSetInterfaceReply;
import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class AclCustomizerTest {
+public class AclCustomizerTest extends WriterCustomizerTest {
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
@Mock
private VppClassifierContextManager classifyTableContext;
private static final int ACL_TABLE_INDEX = 0;
private static final String ACL_TABLE_NAME = "table0";
- @Before
+ @Override
public void setUp() throws Exception {
initMocks(this);
interfaceContext = new NamingContext("generatedInterfaceName", IFC_TEST_INSTANCE);
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.net.InetAddresses;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.ModificationCache;
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.WriteContext;
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 org.junit.Before;
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.inet.types.rev130715.IpAddress;
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.interfaces.rev140508.Interfaces;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.GreAddDelTunnel;
import org.openvpp.jvpp.core.dto.GreAddDelTunnelReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class GreCustomizerTest {
+public class GreCustomizerTest extends WriterCustomizerTest {
private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
private final String IFACE_NAME = "eth0";
private static final byte ADD_GRE = 1;
private static final byte DEL_GRE = 0;
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
-
private GreCustomizer customizer;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
InterfaceTypeTestUtils.setupWriteContext(writeContext,
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.GreTunnel.class);
- // TODO HONEYCOMB-116 create base class for tests using vppApi
- NamingContext namingContext = new NamingContext("generateInterfaceNAme", IFC_TEST_INSTANCE);
- final ModificationCache toBeReturned = new ModificationCache();
- doReturn(toBeReturned).when(writeContext).getModificationCache();
- doReturn(mappingContext).when(writeContext).getMappingContext();
-
- customizer = new GreCustomizer(api, namingContext);
+ customizer = new GreCustomizer(api, new NamingContext("generateInterfaceNAme", IFC_TEST_INSTANCE));
}
private void whenGreAddDelTunnelThenSuccess()
package io.fd.honeycomb.translate.v3po.interfaces;
-import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
-import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
-import io.fd.honeycomb.translate.write.WriteContext;
-import org.junit.Before;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-
-public class ProxyArpCustomizerTest {
-
- @Mock
- private FutureJVppCore vppApi;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
-
- private ProxyArpCustomizer proxyArpCustomizer;
- private NamingContext namingContext;
-
- @Before
- protected void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
- namingContext = new NamingContext("generatedSubInterfaceName", "test-instance");
- doReturn(mappingContext).when(writeContext).getMappingContext();
-
- proxyArpCustomizer = new ProxyArpCustomizer(vppApi, namingContext);
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import org.junit.Test;
+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;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.ProxyArp;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class ProxyArpCustomizerTest extends WriterCustomizerTest {
+
+ private ProxyArpCustomizer customizer;
+
+ @Override
+ public void setUp() throws Exception {
+ customizer = new ProxyArpCustomizer(api, new NamingContext("generatedSubInterfaceName", "test-instance"));
+ }
+
+ @Test(expected = WriteFailedException.UpdateFailedException.class)
+ public void testUpdate() throws Exception {
+ final ProxyArp dataBefore = mock(ProxyArp.class);
+ final ProxyArp dataAfter = mock(ProxyArp.class);
+ customizer.updateCurrentAttributes(getProxyArpId("eth0"), dataBefore, dataAfter, writeContext);
+ }
+
+ private InstanceIdentifier<ProxyArp> getProxyArpId(final String eth0) {
+ return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(eth0)).augmentation(
+ VppInterfaceAugmentation.class).child(ProxyArp.class);
}
}
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.MappingContext;
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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.Assert;
-import org.junit.Before;
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.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewrite;
import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class RewriteCustomizerTest {
-
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
+public class RewriteCustomizerTest extends WriterCustomizerTest {
private NamingContext namingContext;
private RewriteCustomizer customizer;
private static final int VLAN_IF_INDEX = 11;
private InstanceIdentifier<Rewrite> VLAN_IID;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
namingContext = new NamingContext("generatedSubInterfaceName", IFC_TEST_INSTANCE);
- doReturn(mappingContext).when(writeContext).getMappingContext();
customizer = new RewriteCustomizer(api, namingContext);
VLAN_IID = getVlanTagRewriteId(IF_NAME, VLAN_IF_ID);
ContextTestUtils.mockMapping(mappingContext, VLAN_IF_NAME, VLAN_IF_INDEX, IFC_TEST_INSTANCE);
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-import io.fd.honeycomb.translate.MappingContext;
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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
-import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.CVlan;
import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.Dot1qTagVlanType;
import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.Dot1qVlanId;
import org.openvpp.jvpp.core.dto.CreateSubifReply;
import org.openvpp.jvpp.core.dto.SwInterfaceSetFlags;
import org.openvpp.jvpp.core.dto.SwInterfaceSetFlagsReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class SubInterfaceCustomizerTest {
-
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
+public class SubInterfaceCustomizerTest extends WriterCustomizerTest {
private NamingContext namingContext;
private SubInterfaceCustomizer customizer;
CTAG_ANY = generateTag((short) 1, CVlan.class, new Dot1qTag.VlanId(Dot1qTag.VlanId.Enumeration.Any));
}
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
namingContext = new NamingContext("generatedSubInterfaceName", IFC_TEST_INSTANCE);
- doReturn(mappingContext).when(writeContext).getMappingContext();
- // TODO HONEYCOMB-116 create base class for tests using vppApi
customizer = new SubInterfaceCustomizer(api, namingContext);
ContextTestUtils.mockMapping(mappingContext, SUB_IFACE_NAME, SUBIF_INDEX, IFC_TEST_INSTANCE);
ContextTestUtils.mockMapping(mappingContext, SUPER_IF_NAME, SUPER_IF_ID, IFC_TEST_INSTANCE);
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.ModificationCache;
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.write.WriteContext;
import java.util.concurrent.CompletableFuture;
-import org.junit.Before;
import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.openvpp.jvpp.core.dto.TapDeleteReply;
import org.openvpp.jvpp.core.dto.TapModify;
import org.openvpp.jvpp.core.dto.TapModifyReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class TapCustomizerTest {
+public class TapCustomizerTest extends WriterCustomizerTest {
private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
-
- @Mock
- private FutureJVppCore vppApi;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
-
private TapCustomizer tapCustomizer;
- @Before
+ @Override
public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
InterfaceTypeTestUtils.setupWriteContext(writeContext,
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.Tap.class);
- final NamingContext ctx = new NamingContext("ifcintest", IFC_TEST_INSTANCE);
- final ModificationCache toBeReturned = new ModificationCache();
- doReturn(toBeReturned).when(writeContext).getModificationCache();
- doReturn(mappingContext).when(writeContext).getMappingContext();
-
- tapCustomizer = new TapCustomizer(vppApi, ctx);
+ tapCustomizer = new TapCustomizer(api, new NamingContext("ifcintest", IFC_TEST_INSTANCE));
}
@Test
reply.complete(t);
return reply;
}
- }).when(vppApi).tapConnect(any(TapConnect.class));
+ }).when(api).tapConnect(any(TapConnect.class));
tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
tapCustomizer.writeCurrentAttributes(getTapId("tap2"), getTapData("tap2", "ff:ff:ff:ff:ff:ff"), writeContext);
- verify(vppApi, times(2)).tapConnect(any(TapConnect.class));
+ verify(api, times(2)).tapConnect(any(TapConnect.class));
verify(mappingContext).put(eq(ContextTestUtils.getMappingIid("tap", IFC_TEST_INSTANCE)), eq(
ContextTestUtils.getMapping("tap", 0).get()));
verify(mappingContext).put(eq(ContextTestUtils.getMappingIid("tap2", IFC_TEST_INSTANCE)), eq(
final TapConnectReply t = new TapConnectReply();
t.swIfIndex = 0;
reply.complete(t);
- doReturn(reply).when(vppApi).tapConnect(any(TapConnect.class));
+ doReturn(reply).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(vppApi).tapModify(any(TapModify.class));
+ doReturn(replyModif).when(api).tapModify(any(TapModify.class));
tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
ContextTestUtils.mockMapping(mappingContext, "tap", 1, IFC_TEST_INSTANCE);
tapCustomizer.updateCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), getTapData("tap", "ff:ff:ff:ff:ff:f1"), writeContext);
- verify(vppApi).tapConnect(any(TapConnect.class));
- verify(vppApi).tapModify(any(TapModify.class));
+ verify(api).tapConnect(any(TapConnect.class));
+ verify(api).tapModify(any(TapModify.class));
verify(mappingContext).put(eq(ContextTestUtils.getMappingIid("tap", IFC_TEST_INSTANCE)), eq(
ContextTestUtils.getMapping("tap", 0).get()));
final TapConnectReply t = new TapConnectReply();
t.swIfIndex = 0;
reply.complete(t);
- doReturn(reply).when(vppApi).tapConnect(any(TapConnect.class));
+ doReturn(reply).when(api).tapConnect(any(TapConnect.class));
final CompletableFuture<TapDeleteReply> replyDelete = new CompletableFuture<>();
final TapDeleteReply tmodif = new TapDeleteReply();
replyDelete.complete(tmodif);
- doReturn(replyDelete).when(vppApi).tapDelete(any(TapDelete.class));
+ doReturn(replyDelete).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);
tapCustomizer.deleteCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
- verify(vppApi).tapConnect(any(TapConnect.class));
- verify(vppApi).tapDelete(any(TapDelete.class));
+ verify(api).tapConnect(any(TapConnect.class));
+ verify(api).tapDelete(any(TapDelete.class));
verify(mappingContext).delete(eq(ContextTestUtils.getMappingIid("tap", IFC_TEST_INSTANCE)));
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.ModificationCache;
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.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import org.junit.Before;
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.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.openvpp.jvpp.core.dto.DeleteVhostUserIfReply;
import org.openvpp.jvpp.core.dto.ModifyVhostUserIf;
import org.openvpp.jvpp.core.dto.ModifyVhostUserIfReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class VhostUserCustomizerTest {
-
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
+public class VhostUserCustomizerTest extends WriterCustomizerTest {
private VhostUserCustomizer customizer;
private static final int IFACE_ID = 1;
private static final String IFACE_NAME = "eth0";
private static final InstanceIdentifier<VhostUser> ID =
- InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME))
- .augmentation(VppInterfaceAugmentation.class).child(VhostUser.class);
+ InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME))
+ .augmentation(VppInterfaceAugmentation.class).child(VhostUser.class);
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
InterfaceTypeTestUtils.setupWriteContext(writeContext,
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUser.class);
- final NamingContext namingContext = new NamingContext("generatedInterfaceName", "test-instance");
- final ModificationCache toBeReturned = new ModificationCache();
- doReturn(toBeReturned).when(writeContext).getModificationCache();
- doReturn(mappingContext).when(writeContext).getMappingContext();
-
- // TODO HONEYCOMB-116 create base class for tests using vppApi
- customizer = new VhostUserCustomizer(api, namingContext);
+ customizer = new VhostUserCustomizer(api, new NamingContext("generatedInterfaceName", "test-instance"));
}
private void whenCreateVhostUserIfThenSuccess()
* Failure response send
*/
private void whenCreateVhostUserIfThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
+ throws ExecutionException, InterruptedException, VppInvocationException {
doReturn(TestHelperUtils.<CreateVhostUserIfReply>createFutureException()).when(api)
- .createVhostUserIf(any(CreateVhostUserIf.class));
+ .createVhostUserIf(any(CreateVhostUserIf.class));
}
private void whenModifyVhostUserIfThenSuccess()
* Failure response send
*/
private void whenModifyVhostUserIfThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
+ throws ExecutionException, InterruptedException, VppInvocationException {
doReturn(TestHelperUtils.<ModifyVhostUserIfReply>createFutureException()).when(api)
- .modifyVhostUserIf(any(ModifyVhostUserIf.class));
+ .modifyVhostUserIf(any(ModifyVhostUserIf.class));
}
private void whenDeleteVhostUserIfThenSuccess()
* Failure response send
*/
private void whenDeleteVhostUserIfThenFailure()
- throws ExecutionException, InterruptedException, VppInvocationException {
+ throws ExecutionException, InterruptedException, VppInvocationException {
doReturn(TestHelperUtils.<DeleteVhostUserIfReply>createFutureException()).when(api)
- .deleteVhostUserIf(any(DeleteVhostUserIf.class));
+ .deleteVhostUserIf(any(DeleteVhostUserIf.class));
}
- private CreateVhostUserIf verifyCreateVhostUserIfWasInvoked(final VhostUser vhostUser) throws VppInvocationException {
+ private CreateVhostUserIf verifyCreateVhostUserIfWasInvoked(final VhostUser vhostUser)
+ throws VppInvocationException {
ArgumentCaptor<CreateVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(CreateVhostUserIf.class);
verify(api).createVhostUserIf(argumentCaptor.capture());
final CreateVhostUserIf actual = argumentCaptor.getValue();
}
private ModifyVhostUserIf verifyModifyVhostUserIfWasInvoked(final VhostUser vhostUser, final int swIfIndex)
- throws VppInvocationException {
+ throws VppInvocationException {
ArgumentCaptor<ModifyVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(ModifyVhostUserIf.class);
verify(api).modifyVhostUserIf(argumentCaptor.capture());
final ModifyVhostUserIf actual = argumentCaptor.getValue();
customizer.writeCurrentAttributes(ID, vhostUser, writeContext);
verifyCreateVhostUserIfWasInvoked(vhostUser);
verify(mappingContext).put(eq(ContextTestUtils.getMappingIid(IFACE_NAME, "test-instance")), eq(
- ContextTestUtils.getMapping(IFACE_NAME, 0).get()));
+ ContextTestUtils.getMapping(IFACE_NAME, 0).get()));
}
@Test
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.net.InetAddresses;
-import io.fd.honeycomb.translate.MappingContext;
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.WriteContext;
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 org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.VxlanAddDelTunnel;
import org.openvpp.jvpp.core.dto.VxlanAddDelTunnelReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class VxlanCustomizerTest {
+public class VxlanCustomizerTest extends WriterCustomizerTest {
private static final byte ADD_VXLAN = 1;
private static final byte DEL_VXLAN = 0;
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
@Mock
private DisabledInterfacesManager disableContext;
private String ifaceName;
private InstanceIdentifier<Vxlan> id;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
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
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.net.InetAddresses;
-import io.fd.honeycomb.translate.MappingContext;
-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.WriteContext;
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 org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.openvpp.jvpp.core.dto.VxlanAddDelTunnelReply;
import org.openvpp.jvpp.core.dto.VxlanGpeAddDelTunnel;
import org.openvpp.jvpp.core.dto.VxlanGpeAddDelTunnelReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class VxlanGpeCustomizerTest {
+public class VxlanGpeCustomizerTest extends WriterCustomizerTest {
private static final byte ADD_VXLAN_GPE = 1;
private static final byte DEL_VXLAN_GPE = 0;
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
@Mock
private DisabledInterfacesManager interfaceDisableContext;
private String ifaceName;
private InstanceIdentifier<VxlanGpe> id;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
InterfaceTypeTestUtils.setupWriteContext(writeContext,
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanGpeTunnel.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();
-
+ NamingContext namingContext = new NamingContext("generateInterfaceName", "test-instance");
customizer = new VxlanGpeCustomizer(api, namingContext, interfaceDisableContext);
ifaceName = "elth0";
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.base.Optional;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.ModificationCache;
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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.Arrays;
import java.util.Collections;
import org.openvpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import org.openvpp.jvpp.core.dto.SwInterfaceAddDelAddress;
import org.openvpp.jvpp.core.dto.SwInterfaceAddDelAddressReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class Ipv4AddressCustomizerTest {
+public class Ipv4AddressCustomizerTest extends WriterCustomizerTest {
private static final String IFC_CTX_NAME = "ifc-test-instance";
private static final String IFACE_NAME = "eth0";
@Captor
private ArgumentCaptor<List<Address>> addressesCaptor;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
- @Mock
- private FutureJVppCore api;
@Mock
private SubnetValidator subnetValidator;
private NamingContext interfaceContext;
private Ipv4AddressCustomizer customizer;
- private ModificationCache cache;
@Before
public void setUp() throws Exception {
- initMocks(this);
- doReturn(mappingContext).when(writeContext).getMappingContext();
- interfaceContext = new NamingContext("generatedlIfaceName", IFC_CTX_NAME);
+ interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
customizer = new Ipv4AddressCustomizer(api, interfaceContext, subnetValidator);
- cache = new ModificationCache();
- when(writeContext.getModificationCache()).thenReturn(cache);
CompletableFuture future = new CompletableFuture();
future.complete(new IpAddressDetailsReplyDump());
import static org.mockito.Mockito.when;
import com.google.common.io.BaseEncoding;
-import io.fd.honeycomb.translate.MappingContext;
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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.concurrent.CompletableFuture;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.Mapping;
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;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.jvpp.core.dto.IpNeighborAddDel;
import org.openvpp.jvpp.core.dto.IpNeighborAddDelReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class Ipv4NeighbourCustomizerTest {
+public class Ipv4NeighbourCustomizerTest extends WriterCustomizerTest {
private static final String IFC_CTX_NAME = "ifc-test-instance";
private static final String IFACE_NAME = "parent";
private static final int IFACE_ID = 5;
- @Mock
- private FutureJVppCore jvpp;
-
- @Mock
- private WriteContext context;
-
- @Mock
- private MappingContext mappingContext;
-
- @Mock
- private Mapping mapping;
-
private ArgumentCaptor<IpNeighborAddDel> requestCaptor;
private Ipv4NeighbourCustomizer customizer;
- private NamingContext namingContext;
-
@Before
public void init() {
- MockitoAnnotations.initMocks(this);
- when(context.getMappingContext()).thenReturn(mappingContext);
-
- namingContext = new NamingContext("prefix", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
-
- customizer = new Ipv4NeighbourCustomizer(jvpp,namingContext);
+ 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(jvpp.ipNeighborAddDel(Mockito.any(IpNeighborAddDel.class))).thenReturn(future);
+ when(api.ipNeighborAddDel(Mockito.any(IpNeighborAddDel.class))).thenReturn(future);
}
@Test
Neighbor data = new NeighborBuilder().setIp(noZoneIp).setLinkLayerAddress(mac).build();
- customizer.writeCurrentAttributes(id, data, context);
+ customizer.writeCurrentAttributes(id, data, writeContext);
- verify(jvpp, times(1)).ipNeighborAddDel(requestCaptor.capture());
+ verify(api, times(1)).ipNeighborAddDel(requestCaptor.capture());
IpNeighborAddDel request = requestCaptor.getValue();
Neighbor data = new NeighborBuilder().setIp(noZoneIp).setLinkLayerAddress(mac).build();
- customizer.deleteCurrentAttributes(id, data, context);
+ customizer.deleteCurrentAttributes(id, data, writeContext);
- verify(jvpp, times(1)).ipNeighborAddDel(requestCaptor.capture());
+ verify(api, times(1)).ipNeighborAddDel(requestCaptor.capture());
IpNeighborAddDel request = requestCaptor.getValue();
import java.util.List;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.MockitoAnnotations;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.NetmaskBuilder;
@Before
public void init() {
- MockitoAnnotations.initMocks(this);
subnetValidator = new SubnetValidator();
}
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.ReaderCustomizerTest;
+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;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IF_NAME, IF_INDEX, IFC_CTX_NAME);
}
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.translate.v3po.test.ReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.net.InetAddress;
import java.net.UnknownHostException;
}
@Override
- public void setUpBefore() {
+ public void setUp() throws UnknownHostException, VppInvocationException {
interfacesContext = new NamingContext("gre-tunnel", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
final Map<Integer, SwInterfaceDetails> map = new HashMap<>();
map.put(0, v);
cache.put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, map);
- }
- @Override
- protected void setUpAfter() throws UnknownHostException, VppInvocationException {
final CompletableFuture<GreTunnelDetailsReplyDump> greTunnelDetailsReplyDumpCompletionStage =
new CompletableFuture<>();
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.translate.v3po.test.ListReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.util.Arrays;
import java.util.Collections;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
interfacesContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE0_NAME, IFACE0_ID, IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE1_NAME, IFACE1_ID, IFC_CTX_NAME);
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.ReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.util.Collections;
import java.util.HashMap;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
bridgeDomainContext = new NamingContext("generatedBDName", BD_CTX_NAME);
}
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.ReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import io.fd.honeycomb.translate.v3po.util.TagRewriteOperation;
import java.util.HashMap;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
interfacesContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, VLAN_IF_NAME, VLAN_IF_INDEX, IFC_CTX_NAME);
}
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.translate.v3po.test.ListReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.util.Collections;
import java.util.HashMap;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
interfacesContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, SUPER_IF_NAME, SUPER_IF_INDEX, IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, VLAN_IF_NAME, VLAN_IF_INDEX, IFC_CTX_NAME);
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.translate.v3po.test.ReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.net.InetAddress;
import java.net.UnknownHostException;
}
@Override
- public void setUpBefore() {
+ public void setUp() throws UnknownHostException, VppInvocationException {
interfacesContext = new NamingContext("vxlan-tunnel", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IF_NAME, IF_INDEX, IFC_CTX_NAME);
final Map<Integer, SwInterfaceDetails> map = new HashMap<>();
map.put(0, v);
cache.put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, map);
- }
- @Override
- protected void setUpAfter() throws UnknownHostException, VppInvocationException {
final CompletableFuture<VxlanTunnelDetailsReplyDump> vxlanTunnelDetailsReplyDumpCompletionStage =
new CompletableFuture<>();
vxlanTunnelDetailsReplyDumpCompletionStage.complete(value);
doReturn(vxlanTunnelDetailsReplyDumpCompletionStage).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.translate.v3po.test.ReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.net.InetAddress;
import java.net.UnknownHostException;
}
@Override
- public void setUpBefore() {
+ public void setUp() throws UnknownHostException, VppBaseCallException {
interfacesContext = new NamingContext("vxlan_gpe_inf", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IF_NAME, IF_INDEX, IFC_CTX_NAME);
final Map<Integer, SwInterfaceDetails> map = new HashMap<>();
map.put(0, v);
cache.put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, map);
- }
- @Override
- protected void setUpAfter() throws UnknownHostException, VppBaseCallException {
final CompletableFuture<VxlanGpeTunnelDetailsReplyDump> vxlanGpeTunnelDetailsReplyDumpCompletionStage =
new CompletableFuture<>();
vxlanGpeTunnelDetailsReplyDumpCompletionStage.complete(value);
doReturn(vxlanGpeTunnelDetailsReplyDumpCompletionStage).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.translate.v3po.test.ListReaderCustomizerTest;
+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 java.util.Arrays;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
interfacesContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE_2_NAME, IFACE_2_ID, IFC_CTX_NAME);
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-import io.fd.honeycomb.translate.MappingContext;
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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.concurrent.CompletableFuture;
-import org.junit.Before;
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.inet.types.rev130715.IpAddress;
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.yang.types.rev130715.PhysAddress;
import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.BdIpMacAddDel;
import org.openvpp.jvpp.core.dto.BdIpMacAddDelReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class ArpTerminationTableEntryCustomizerTest {
+public class ArpTerminationTableEntryCustomizerTest extends WriterCustomizerTest {
private static final String BD_CTX_NAME = "bd-test-instance";
private static final String IFC_CTX_NAME = "ifc-test-instance";
private static final int BD_ID = 111;
private static final String IFACE_NAME = "eth0";
private static final int IFACE_ID = 123;
-
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
-
- private NamingContext bdContext;
-
private ArpTerminationTableEntryCustomizer customizer;
private byte[] ipAddressRaw;
private byte[] physAddressRaw;
private ArpTerminationTableEntry entry;
private InstanceIdentifier<ArpTerminationTableEntry> id;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
- doReturn(mappingContext).when(writeContext).getMappingContext();
- bdContext = new NamingContext("generatedBdName", BD_CTX_NAME);
-
- customizer = new ArpTerminationTableEntryCustomizer(api, bdContext);
+ customizer = new ArpTerminationTableEntryCustomizer(api, new NamingContext("generatedBdName", BD_CTX_NAME));
ipAddressRaw = new byte[] {1, 2, 3, 4};
physAddressRaw = new byte[] {1, 2, 3, 4, 5, 6};
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
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.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.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
-import org.junit.Before;
import org.junit.Test;
-import org.mockito.Mock;
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.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.core.dto.BridgeDomainAddDel;
import org.openvpp.jvpp.core.dto.BridgeDomainAddDelReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class BridgeDomainCustomizerTest {
+public class BridgeDomainCustomizerTest extends WriterCustomizerTest {
private static final String BD_CTX_NAME = "bd-test-instance";
-
private static final byte ADD_OR_UPDATE_BD = (byte) 1;
- private static final byte ZERO = 0;
-
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext ctx;
- @Mock
- private MappingContext mappingContext;
-
private BridgeDomainCustomizer customizer;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
- // TODO HONEYCOMB-116 create base class for tests using vppApi
- final ModificationCache toBeReturned = new ModificationCache();
- doReturn(toBeReturned).when(ctx).getModificationCache();
- doReturn(mappingContext).when(ctx).getMappingContext();
-
customizer = new BridgeDomainCustomizer(api, new NamingContext("generatedBDName", BD_CTX_NAME));
}
whenBridgeDomainAddDelThenSuccess();
- customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, ctx);
+ customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
verifyBridgeDomainAddOrUpdateWasInvoked(bd, bdId);
verify(mappingContext).put(
- ContextTestUtils.getMappingIid(bdName, BD_CTX_NAME), ContextTestUtils.getMapping(bdName, bdId).get());
+ ContextTestUtils.getMappingIid(bdName, BD_CTX_NAME), ContextTestUtils.getMapping(bdName, bdId).get());
}
@Test
whenBridgeDomainAddDelThenSuccess();
- customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, ctx);
+ customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
verifyBridgeDomainAddOrUpdateWasInvoked(bd, bdId);
verify(mappingContext).put(
- ContextTestUtils.getMappingIid(bdName, BD_CTX_NAME), ContextTestUtils.getMapping(bdName, bdId).get());
+ ContextTestUtils.getMappingIid(bdName, BD_CTX_NAME), ContextTestUtils.getMapping(bdName, bdId).get());
}
@Test
whenBridgeDomainAddDelThenFailure();
try {
- customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, ctx);
+ customizer.writeCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
} catch (WriteFailedException.CreateFailedException e) {
verifyBridgeDomainAddOrUpdateWasInvoked(bd, bdId);
return;
whenBridgeDomainAddDelThenSuccess();
- customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, ctx);
+ customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
verifyBridgeDomainDeleteWasInvoked(bdId);
}
ContextTestUtils.mockEmptyMapping(mappingContext, bdName, BD_CTX_NAME);
try {
- customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, ctx);
+ customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
} catch (IllegalArgumentException e) {
verify(api, never()).bridgeDomainAddDel(any(BridgeDomainAddDel.class));
return;
whenBridgeDomainAddDelThenFailure();
try {
- customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, ctx);
+ customizer.deleteCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bd, writeContext);
} catch (WriteFailedException.DeleteFailedException e) {
verifyBridgeDomainDeleteWasInvoked(bdId);
return;
whenBridgeDomainAddDelThenSuccess();
customizer
- .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), dataBefore, dataAfter, ctx);
+ .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), dataBefore, dataAfter,
+ writeContext);
verifyBridgeDomainAddOrUpdateWasInvoked(dataAfter, bdId);
}
try {
customizer
- .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bdBefore, bdAfter, ctx);
+ .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bdBefore, bdAfter,
+ writeContext);
} catch (IllegalArgumentException e) {
verify(api, never()).bridgeDomainAddDel(any(BridgeDomainAddDel.class));
return;
try {
customizer
- .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bdBefore, bdAfter, ctx);
+ .updateCurrentAttributes(BridgeDomainTestUtils.bdIdentifierForName(bdName), bdBefore, bdAfter,
+ writeContext);
} catch (WriteFailedException.UpdateFailedException e) {
verifyBridgeDomainAddOrUpdateWasInvoked(bdAfter, bdId);
return;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
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.write.WriteContext;
-import io.fd.honeycomb.translate.MappingContext;
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 org.junit.Before;
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.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.L2FibFilter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.fib.attributes.L2FibTable;
import org.openvpp.jvpp.core.dto.L2FibAddDel;
import org.openvpp.jvpp.core.dto.L2FibAddDelReply;
import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class L2FibEntryCustomizerTest {
+public class L2FibEntryCustomizerTest extends WriterCustomizerTest {
private static final String BD_CTX_NAME = "bd-test-instance";
private static final String IFC_CTX_NAME = "ifc-test-instance";
private static final String IFACE_NAME = "eth0";
private static final int IFACE_ID = 123;
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext mappingContext;
-
- private NamingContext bdContext;
- private NamingContext interfaceContext;
-
private L2FibEntryCustomizer customizer;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
- doReturn(mappingContext).when(writeContext).getMappingContext();
- bdContext = new NamingContext("generatedBdName", BD_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, BD_NAME, BD_ID, BD_CTX_NAME);
- interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
- customizer = new L2FibEntryCustomizer(api, bdContext, interfaceContext);
+ customizer = new L2FibEntryCustomizer(
+ api,
+ new NamingContext("generatedBdName", BD_CTX_NAME),
+ new NamingContext("generatedIfaceName", IFC_CTX_NAME));
}
private static InstanceIdentifier<L2FibEntry> getL2FibEntryId(final PhysAddress address) {
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
-import io.fd.honeycomb.translate.v3po.test.ListReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.openvpp.jvpp.core.dto.ClassifySessionDump;
public class ClassifySessionReaderTest extends
- ListReaderCustomizerTest<ClassifySession, ClassifySessionKey, ClassifySessionBuilder> {
+ ListReaderCustomizerTest<ClassifySession, ClassifySessionKey, ClassifySessionBuilder> {
private static final String MATCH_1 = "00:00:00:00:00:00:01:02:03:04:05:06:00:00:00:00";
private static final String MATCH_2 = "00:00:00:00:00:00:01:02:03:04:05:07:00:00:00:00";
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.base.Optional;
-import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.translate.write.WriteContext;
+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 org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.openvpp.jvpp.core.dto.ClassifyAddDelSession;
import org.openvpp.jvpp.core.dto.ClassifyAddDelSessionReply;
import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class ClassifySessionWriterTest {
+public class ClassifySessionWriterTest extends WriterCustomizerTest {
private static final int TABLE_INDEX = 123;
private static final String TABLE_NAME = "table123";
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext ctx;
@Mock
private VppClassifierContextManager classfierContext;
private ClassifySessionWriter customizer;
private static final int SESSION_INDEX = 456;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
- doReturn(ctx).when(writeContext).getMappingContext();
customizer = new ClassifySessionWriter(api, classfierContext);
- when(classfierContext.containsTable(TABLE_NAME, ctx)).thenReturn(true);
- when(classfierContext.getTableIndex(TABLE_NAME, ctx)).thenReturn(TABLE_INDEX);
+ when(classfierContext.containsTable(TABLE_NAME, mappingContext)).thenReturn(true);
+ when(classfierContext.getTableIndex(TABLE_NAME, mappingContext)).thenReturn(TABLE_INDEX);
final ClassifyTable table = mock(ClassifyTable.class);
when(table.getClassifierNode()).thenReturn(new VppNodeName("ip4-classifier"));
import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
-import io.fd.honeycomb.translate.v3po.test.ListReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.openvpp.jvpp.core.dto.ClassifyTableInfoReply;
public class ClassifyTableReaderTest extends
- ListReaderCustomizerTest<ClassifyTable, ClassifyTableKey, ClassifyTableBuilder> {
+ ListReaderCustomizerTest<ClassifyTable, ClassifyTableKey, ClassifyTableBuilder> {
private static final int TABLE_INDEX_1 = 1;
private static final String TABLE_NAME_1 = "table1";
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.v3po.test.TestHelperUtils;
-import io.fd.honeycomb.translate.write.WriteContext;
+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 org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.openvpp.jvpp.core.dto.ClassifyAddDelTable;
import org.openvpp.jvpp.core.dto.ClassifyAddDelTableReply;
import org.openvpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
-import org.openvpp.jvpp.core.future.FutureJVppCore;
-public class ClassifyTableWriterTest {
+public class ClassifyTableWriterTest extends WriterCustomizerTest {
private static final int TABLE_INDEX = 123;
private static final String TABLE_NAME = "table123";
- @Mock
- private FutureJVppCore api;
- @Mock
- private WriteContext writeContext;
- @Mock
- private MappingContext ctx;
@Mock
private VppClassifierContextManager classifierContext;
private ClassifyTableWriter customizer;
- @Before
+ @Override
public void setUp() throws Exception {
- initMocks(this);
customizer = new ClassifyTableWriter(api, classifierContext);
- doReturn(ctx).when(writeContext).getMappingContext();
}
private static ClassifyTable generateClassifyTable(final String name) {
customizer.writeCurrentAttributes(id, classifyTable, writeContext);
verifyClassifyAddDelTableAddWasInvoked(generateClassifyAddDelTable((byte) 1, TABLE_INDEX));
- verify(classifierContext).addTable(TABLE_INDEX, classifyTable.getName(), classifyTable.getClassifierNode(), ctx);
+ verify(classifierContext)
+ .addTable(TABLE_INDEX, classifyTable.getName(), classifyTable.getClassifierNode(), mappingContext);
}
@Test
assertTrue(e.getCause() instanceof VppBaseCallException);
verifyClassifyAddDelTableAddWasInvoked(generateClassifyAddDelTable((byte) 1, TABLE_INDEX));
verify(classifierContext, times(0))
- .addTable(TABLE_INDEX, classifyTable.getName(), classifyTable.getClassifierNode(), ctx);
+ .addTable(TABLE_INDEX, classifyTable.getName(), classifyTable.getClassifierNode(), mappingContext);
return;
}
fail("WriteFailedException.CreateFailedException was expected");
final ClassifyTable classifyTable = generateClassifyTable(TABLE_NAME);
final InstanceIdentifier<ClassifyTable> id = getClassifyTableId(TABLE_NAME);
- when(classifierContext.containsTable(TABLE_NAME, ctx)).thenReturn(true);
- when(classifierContext.getTableIndex(TABLE_NAME, ctx)).thenReturn(TABLE_INDEX);
+ when(classifierContext.containsTable(TABLE_NAME, mappingContext)).thenReturn(true);
+ when(classifierContext.getTableIndex(TABLE_NAME, mappingContext)).thenReturn(TABLE_INDEX);
whenClassifyAddDelTableThenSuccess();
customizer.deleteCurrentAttributes(id, classifyTable, writeContext);
final ClassifyTable classifyTable = generateClassifyTable(TABLE_NAME);
final InstanceIdentifier<ClassifyTable> id = getClassifyTableId(TABLE_NAME);
- when(classifierContext.containsTable(TABLE_NAME, ctx)).thenReturn(true);
- when(classifierContext.getTableIndex(TABLE_NAME, ctx)).thenReturn(TABLE_INDEX);
+ when(classifierContext.containsTable(TABLE_NAME, mappingContext)).thenReturn(true);
+ when(classifierContext.getTableIndex(TABLE_NAME, mappingContext)).thenReturn(TABLE_INDEX);
whenClassifyAddDelTableThenFailure();
try {
import static org.mockito.Mockito.verify;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
-import io.fd.honeycomb.translate.v3po.test.ListReaderCustomizerTest;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.util.Collections;
import java.util.List;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
bdContext = new NamingContext("generatedBdName", "bd-test-instance");
interfacesContext = new NamingContext("generatedIfaceName", "ifc-test-instance");
}
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.v3po.test.ContextTestUtils;
-import io.fd.honeycomb.translate.v3po.test.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
}
@Override
- public void setUpBefore() {
+ public void setUp() {
bdContext = new NamingContext("generatedBdName", BD_CTX_NAME);
ContextTestUtils.mockMapping(mappingContext, BD_NAME, BD_ID, BD_CTX_NAME);
interfacesContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
import static org.mockito.Mockito.when;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
-import io.fd.honeycomb.translate.v3po.test.ReaderCustomizerTest;
+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;
<module>naming-context-impl</module>
<module>minimal-distribution</module>
<module>vpp-impl-parent</module>
+ <module>vpp-translate-test</module>
</modules>
<!-- DO NOT install or deploy the repo root pom as it's only needed to initiate a build -->
<build>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ 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.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+ <parent>
+ <groupId>io.fd.honeycomb.vpp</groupId>
+ <artifactId>vpp-impl-parent</artifactId>
+ <version>1.16.12-SNAPSHOT</version>
+ <relativePath>../../vpp-common/vpp-impl-parent</relativePath>
+ </parent>
+
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>io.fd.honeycomb.vpp</groupId>
+ <artifactId>vpp-translate-test</artifactId>
+ <version>1.16.12-SNAPSHOT</version>
+ <packaging>bundle</packaging>
+
+ <dependencies>
+ <dependency>
+ <groupId>io.fd.honeycomb</groupId>
+ <artifactId>translate-spi</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.fd.vpp</groupId>
+ <artifactId>jvpp-core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-all</artifactId>
+ <version>1.9.5</version>
+ <scope>compile</scope>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.12</version>
+ <scope>compile</scope>
+ </dependency>
+ </dependencies>
+</project>
* limitations under the License.
*/
-package io.fd.honeycomb.translate.v3po.test;
+package io.fd.honeycomb.vpp.test.read;
import static org.junit.Assert.assertNotNull;
* @param <B> Specific Builder for handled type (D)
*/
public abstract class ListReaderCustomizerTest<D extends DataObject & Identifiable<K>, K extends Identifier<D>, B extends Builder<D>> extends
- ReaderCustomizerTest<D, B> {
-
+ ReaderCustomizerTest<D, B> {
protected ListReaderCustomizerTest(Class<D> dataObjectClass) {
super(dataObjectClass);
* limitations under the License.
*/
-package io.fd.honeycomb.translate.v3po.test;
+package io.fd.honeycomb.vpp.test.read;
import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.MockitoAnnotations.initMocks;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Mock
protected FutureJVppCore api;
- protected ModificationCache cache;
@Mock
protected ReadContext ctx;
@Mock
protected MappingContext mappingContext;
+ protected ModificationCache cache;
protected final Class<D> dataObjectClass;
private ReaderCustomizer<D, B> customizer;
@Before
public void setUpParent() throws Exception {
- initMocks(this);
+ MockitoAnnotations.initMocks(this);
cache = new ModificationCache();
- doReturn(cache).when(ctx).getModificationCache();
- doReturn(mappingContext).when(ctx).getMappingContext();
-
- setUpBefore();
+ Mockito.doReturn(cache).when(ctx).getModificationCache();
+ Mockito.doReturn(mappingContext).when(ctx).getMappingContext();
+ setUp();
customizer = initCustomizer();
- setUpAfter();
}
/**
* Optional setup for subclasses. Invoked before customizer is initialized.
*/
- protected void setUpBefore() {
-
- }
-
- /**
- * Optional setup for subclasses. Invoked after customizer is initialized.
- */
- protected void setUpAfter() throws Exception {
-
+ protected void setUp() throws Exception {
}
protected abstract ReaderCustomizer<D, B> initCustomizer();
public void testGetBuilder() throws Exception {
assertNotNull(customizer.getBuilder(InstanceIdentifier.create(dataObjectClass)));
}
+
+ // TODO HONEYCOMB-116: create generic testMerge()
}
--- /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.write;
+
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
+import io.fd.honeycomb.translate.write.WriteContext;
+import org.junit.Before;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+/**
+ * Generic test for classes implementing {@link WriterCustomizer} interface.
+ */
+public abstract class WriterCustomizerTest {
+
+ @Mock
+ protected FutureJVppCore api;
+ @Mock
+ protected WriteContext writeContext;
+ @Mock
+ protected MappingContext mappingContext;
+
+ protected ModificationCache cache;
+
+ protected WriterCustomizerTest() {
+ }
+
+ @Before
+ public void setUpParent() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ cache = new ModificationCache();
+ Mockito.doReturn(cache).when(writeContext).getModificationCache();
+ Mockito.doReturn(mappingContext).when(writeContext).getMappingContext();
+ setUp();
+ }
+
+ /**
+ * Optional setup for subclasses. Invoked after parent initialization.
+ */
+ protected void setUp() throws Exception {
+ }
+}
Code Review / hc2vpp.git / commitdiff