.execute(getjVppAclFacade());
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id,
- @Nonnull final VppMacipAcl dataBefore,
- @Nonnull final VppMacipAcl dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id,
@Nonnull final VppMacipAcl dataBefore,
private void verifyVariant(final AclInterfaceAssignmentRequest request) throws WriteFailedException {
verifyCreateFailsWithNullPointer(request);
- verifyUpdateFailsWithNullPointer(request);
verifyDeleteFailsWithNullPointer(request);
}
verifyValidRequest(requestCaptor.getValue());
}
- @Test
- public void executeAsUpdate() throws Exception {
- createValidRequest().executeAsUpdate(api, mock(Acl.class), mock(Acl.class));
-
- verify(api).aclInterfaceSetAclList(requestCaptor.capture());
- verifyValidRequest(requestCaptor.getValue());
- }
-
@Test
public void executeAsDelete() throws Exception {
create(mappingContext)
fail("Test should have thrown null pointer");
}
- private void verifyUpdateFailsWithNullPointer(final AclInterfaceAssignmentRequest request)
- throws WriteFailedException {
- try {
- request.executeAsUpdate(api, mock(Acl.class), mock(Acl.class));
- } catch (NullPointerException e) {
- return;
- }
- fail("Test should have thrown null pointer");
- }
-
private void verifyDeleteFailsWithNullPointer(final AclInterfaceAssignmentRequest request)
throws WriteFailedException {
try {
import io.fd.hc2vpp.acl.util.AclContextManager;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceAddDel;
import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceAddDelReply;
import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
verify(aclApi).macipAclInterfaceAddDel(request);
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws Exception {
customizer.updateCurrentAttributes(ACL_IID, acl, acl, writeContext);
}
setAddress(true, id, interfaceName, interfaceIndex, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(InstanceIdentifier<Address> id, Address dataBefore, Address dataAfter,
- WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(InstanceIdentifier<Address> id, Address dataBefore, WriteContext writeContext)
throws WriteFailedException {
LOG.debug("Handling Ipv4 leaves (mtu, forwarding) is not supported by VPP API. Ignoring configuration");
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv4> id,
- @Nonnull final Ipv4 dataBefore, @Nonnull final Ipv4 dataAfter,
- @Nonnull final WriteContext writeContext) {
- LOG.debug("Handling Ipv4 leaves (mtu, forwarding) is not supported by VPP API. Ignoring configuration");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv4> id,
@Nonnull final Ipv4 dataBefore, @Nonnull final WriteContext writeContext) {
LOG.debug("Neighbour {} successfully written", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore,
- @Nonnull Neighbor dataAfter,
- @Nonnull WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor data,
@Nonnull WriteContext writeContext)
LOG.debug("Proxy ARP was successfully enabled on interface {} (id={})", swIfName, swIfIndex);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ProxyArp> id,
- @Nonnull final ProxyArp dataBefore,
- @Nonnull final ProxyArp dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Proxy ARP feature update is not supported."));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ProxyArp> id,
@Nonnull final ProxyArp dataBefore,
createProxyArp(getProxyArpRequestFuture(dataAfter, (byte) 1 /* 1 is add */), id, dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ProxyRange> id,
- @Nonnull final ProxyRange dataBefore,
- @Nonnull final ProxyRange dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("ARP proxy range update is not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ProxyRange> id,
@Nonnull final ProxyRange dataBefore,
setAddress(true, id, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(InstanceIdentifier<Address> id, Address dataBefore, Address dataAfter,
- WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(InstanceIdentifier<Address> id, Address dataBefore, WriteContext writeContext)
throws WriteFailedException {
LOG.debug("Neighbour {} successfully written", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore,
- @Nonnull Neighbor dataAfter,
- @Nonnull WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor data,
@Nonnull WriteContext writeContext)
dataAfter.getPrefixLength().byteValue());
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Address> id,
- @Nonnull final Address dataBefore,
- @Nonnull final Address dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Address> id,
@Nonnull final Address dataBefore,
LOG.warn("Unsupported, ignoring configuration {}", dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6> id,
- @Nonnull final Ipv6 dataBefore, @Nonnull final Ipv6 dataAfter,
- @Nonnull final WriteContext writeContext) {
- LOG.warn("Unsupported, ignoring configuration {}", dataAfter);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6> id,
@Nonnull final Ipv6 dataBefore, @Nonnull final WriteContext writeContext) {
LOG.debug("Neighbour successfully written");
}
- @Override
- public void updateCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore,
- @Nonnull Neighbor dataAfter,
- @Nonnull WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore,
@Nonnull WriteContext writeContext)
LOG.debug("ND proxy was successfully added for interface {}(id={}): {}", interfaceName, swIfIndex, dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id,
- @Nonnull final NdProxy dataBefore, @Nonnull final NdProxy dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("NdProxy update is not supported."));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id,
@Nonnull final NdProxy dataBefore,
setAddress(true, id, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(InstanceIdentifier<Address> id, Address dataBefore, Address dataAfter,
- WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(InstanceIdentifier<Address> id, Address dataBefore, WriteContext writeContext)
throws WriteFailedException {
LOG.debug("Neighbour {} successfully written", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore,
- @Nonnull Neighbor dataAfter,
- @Nonnull WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor data,
@Nonnull WriteContext writeContext)
customizer.writeCurrentAttributes(IID, data, writeContext);
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws WriteFailedException {
customizer.updateCurrentAttributes(IID, data, data, writeContext);
}
customizer.writeCurrentAttributes(IID, RANGE, writeContext);
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws WriteFailedException {
customizer.updateCurrentAttributes(IID, RANGE, RANGE, writeContext);
}
fail("WriteFailedException was expected");
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws Exception {
final Address data = mock(Address.class);
customizer.updateCurrentAttributes(getAddressId(IFACE_NAME), data, data, writeContext);
return request;
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws Exception {
final Address address = address(prefixLength());
customizer.updateCurrentAttributes(IID, address, address, writeContext);
verify(api).ip6NdProxyAddDel(request);
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws WriteFailedException {
final Ipv6AddressNoZone address = new Ipv6AddressNoZone("2001::2");
final NdProxy data = new NdProxyBuilder().setAddress(address).build();
createNativePath(id, dataAfter, writeContext);
}
-
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPath> id,
- @Nonnull final NativeForwardPath dataBefore,
- @Nonnull final NativeForwardPath dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- deleteNativePath(id, dataBefore, writeContext);
- createNativePath(id, dataAfter, writeContext);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPath> id,
@Nonnull final NativeForwardPath dataBefore,
createFibTable(id, dataAfter);
}
-
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
- @Nonnull final NativeForwardPathsTable dataBefore,
- @Nonnull final NativeForwardPathsTable dataAfter,
- @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- // not sure if update makes sense, but just in case
- deleteFibTable(id);
- createFibTable(id, dataAfter);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTable dataBefore,
LOG.debug("{} successfully written", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id,
- @Nonnull final BridgeDomainSubtable dataBefore,
- @Nonnull final BridgeDomainSubtable dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id,
@Nonnull final BridgeDomainSubtable dataBefore,
}
- @Override
- public void updateCurrentAttributes(InstanceIdentifier<Interface> id, Interface dataBefore, Interface dataAfter,
- WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(InstanceIdentifier<Interface> id, Interface dataBefore,
WriteContext writeContext) throws WriteFailedException {
}
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
- @Nonnull final ItrRemoteLocatorSet dataBefore,
- @Nonnull final ItrRemoteLocatorSet dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSet dataBefore,
return locators != null && !locators.isEmpty();
}
- @Override
- public void updateCurrentAttributes(@Nonnull InstanceIdentifier<LocatorSet> id,
- @Nonnull LocatorSet dataBefore,
- @Nonnull LocatorSet dataAfter,
- @Nonnull WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<LocatorSet> id,
@Nonnull LocatorSet dataBefore,
}
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<MapResolver> id,
- @Nonnull final MapResolver dataBefore, @Nonnull final MapResolver dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MapResolver> id,
@Nonnull final MapResolver dataBefore, @Nonnull final WriteContext writeContext)
addDelMapServer(true, instanceIdentifier, mapServer);
}
- @Override
- public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
- @Nonnull MapServer mapServerBefore,
- @Nonnull MapServer mapServerAfter,
- @Nonnull WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(instanceIdentifier, mapServerBefore, mapServerAfter,
- new UnsupportedOperationException("Not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext) throws WriteFailedException {
lispStateCheckService.checkLispEnabledBefore(writeContext);
checkAtLeastOnChildExists(id, writeContext, false);
}
- @Override
- public void updateCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataBefore, VniTable dataAfter,
- WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataBefore, WriteContext writeContext)
throws WriteFailedException {
LOG.debug("{} successfully written", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
- @Nonnull final VrfSubtable dataBefore, @Nonnull final VrfSubtable dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Operation not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtable dataBefore, @Nonnull final WriteContext writeContext)
@Test
public void testUpdateValid() throws WriteFailedException {
when(api.gpeAddDelNativeFwdRpath(any())).thenReturn(future(new GpeAddDelNativeFwdRpathReply()));
- customizer.updateCurrentAttributes(validId, validTableBefore(), validTable(), writeContext);
+ final NativeForwardPathsTable before = validTableBefore();
+ final NativeForwardPathsTable after = validTable();
+ // emulates what default update would do
+ customizer.deleteCurrentAttributes(validId, before, writeContext);
+ customizer.writeCurrentAttributes(validId, after, writeContext);
verify(api, times(2)).gpeAddDelIface(requestCaptor.capture());
final List<GpeAddDelIface> requests = requestCaptor.getAllValues();
fail("Test should have thrown exception");
}
- @Test
- public void updateCurrentAttributes() {
- try {
- customizer.updateCurrentAttributes(validId, validData, validData, writeContext);
- } catch (WriteFailedException e) {
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- return;
- }
-
- fail("Test should have thrown exception");
+ @Test(expected = UnsupportedOperationException.class)
+ public void updateCurrentAttributes() throws WriteFailedException {
+ customizer.updateCurrentAttributes(validId, validData, validData, writeContext);
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
assertEquals(1, request.isAdd);
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws WriteFailedException {
final InstanceIdentifier<LocatorSet> identifier = InstanceIdentifier.create(LocatorSet.class);
- try {
- customizer
- .updateCurrentAttributes(identifier, mock(LocatorSet.class), mock(LocatorSet.class), writeContext);
- } catch (WriteFailedException e) {
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- assertEquals(identifier, e.getFailedId());
- return;
- }
- fail("Test should have failed");
+ customizer.updateCurrentAttributes(identifier, mock(LocatorSet.class), mock(LocatorSet.class), writeContext);
}
@Test(expected = NullPointerException.class)
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void updateCurrentAttributes() throws Exception {
- try {
- customizer.updateCurrentAttributes(ID, data, data, writeContext);
- } catch (WriteFailedException e) {
- assertTrue(e instanceof WriteFailedException.UpdateFailedException);
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- verify(api, times(0)).oneAddDelMapServer(any());
- }
+ customizer.updateCurrentAttributes(ID, data, data, writeContext);
}
@Test
LOG.debug("Address range: {} added successfully", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id,
- @Nonnull final ExternalIpAddressPool dataBefore,
- @Nonnull final ExternalIpAddressPool dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Address range update is not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id,
@Nonnull final ExternalIpAddressPool dataBefore,
return false;
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id,
- @Nonnull final MappingEntry dataBefore,
- @Nonnull final MappingEntry dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- deleteCurrentAttributes(id, dataBefore, writeContext);
- writeCurrentAttributes(id, dataAfter, writeContext);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id,
@Nonnull final MappingEntry dataBefore,
LOG.trace("Writing nat-instance: {}", id);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NatInstance> id,
- @Nonnull final NatInstance dataBefore, @Nonnull final NatInstance dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- LOG.trace("Updating nat-instance: {}", id);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NatInstance> id,
@Nonnull final NatInstance dataBefore, @Nonnull final WriteContext writeContext)
getLog().debug("NAT {} enabled successfully on: {}, reply: {}", dataAfter, ifcName, reply);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final D dataBefore, @Nonnull final D dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Unable to update NAT feature"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
@Nonnull final D dataBefore, @Nonnull final WriteContext writeContext)
verify(jvppSnat).snatAddAddressRange(expectedRequest);
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws WriteFailedException {
final ExternalIpAddressPool data = mock(ExternalIpAddressPool.class);
customizer.updateCurrentAttributes(IID, data, data, writeContext);
customizer.writeCurrentAttributes(IID, extractMappingEntry(data), writeContext);
}
- @Test(expected = IllegalArgumentException.class)
- public void testWriteNat64UnsupportedProtocol(
- @InjectTestData(resourcePath = "/nat64/static-mapping-unsupported-proto.json", id = MAPPING_TABLE_PATH) MappingTable data)
- throws WriteFailedException {
- customizer.writeCurrentAttributes(IID, extractMappingEntry(data), writeContext);
- }
-
- @Test
- public void testUpdateNat44(
- @InjectTestData(resourcePath = "/nat44/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable before,
- @InjectTestData(resourcePath = "/nat44/static-mapping-address-update.json", id = MAPPING_TABLE_PATH) MappingTable after)
- throws WriteFailedException {
- customizer.updateCurrentAttributes(IID, extractMappingEntry(before), extractMappingEntry(after), writeContext);
- final SnatAddStaticMapping expectedDeleteRequest = getExpectedNat44Request();
- verify(jvppSnat).snatAddStaticMapping(expectedDeleteRequest);
- final SnatAddStaticMapping expectedUpdateRequest = getExpectedNat44UpdateRequest();
- expectedUpdateRequest.isAdd = 1;
- verify(jvppSnat).snatAddStaticMapping(expectedUpdateRequest);
- }
-
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdateNat64(
@InjectTestData(resourcePath = "/nat64/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable before,
@InjectTestData(resourcePath = "/nat64/static-mapping-address-update.json", id = MAPPING_TABLE_PATH) MappingTable after)
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelFeature;
import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelFeatureReply;
import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelOutputFeature;
verify(snatApi).snatInterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, true));
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdatePreRouting() throws Exception {
customizer.updateCurrentAttributes(getIId(IFACE_NAME), getPreRoutingConfig(), getPreRoutingConfig(),
writeContext);
}
- @Test(expected = WriteFailedException.UpdateFailedException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdatePostRouting() throws Exception {
customizer.updateCurrentAttributes(getIId(IFACE_NAME), getPostRoutingConfig(), getPostRoutingConfig(),
writeContext);
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.vppnsh.impl.util.FutureJVppNshCustomizer;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.hc2vpp.vppnsh.impl.util.FutureJVppNshCustomizer;
import io.fd.vpp.jvpp.nsh.dto.NshAddDelEntry;
import io.fd.vpp.jvpp.nsh.dto.NshAddDelEntryReply;
import io.fd.vpp.jvpp.nsh.future.FutureJVppNsh;
+import java.util.List;
import java.util.concurrent.CompletionStage;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.Ethernet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.MdType2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.NshMdType1Augment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.NshMdType2Augment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.nsh.md.type2.attributes.Md2Data;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.vpp.nsh.nsh.entries.NshEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.vpp.nsh.nsh.entries.NshEntryKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.nsh.md.type2.attributes.Md2Data;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-
/**
* Writer customizer responsible for NshEntry create/delete.
*/
LOG.debug("Successfully created nsh entry(id={]): iid={} dataAfter={}", newEntryIndex, id, dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NshEntry> id,
- @Nonnull final NshEntry dataBefore, @Nonnull final NshEntry dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Nsh entry update is not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NshEntry> id,
@Nonnull final NshEntry dataBefore,
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.vppnsh.impl.util.FutureJVppNshCustomizer;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.hc2vpp.vppnsh.impl.util.FutureJVppNshCustomizer;
import io.fd.vpp.jvpp.nsh.dto.NshAddDelMap;
import io.fd.vpp.jvpp.nsh.dto.NshAddDelMapReply;
import io.fd.vpp.jvpp.nsh.future.FutureJVppNsh;
import java.util.concurrent.CompletionStage;
import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.None;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.Pop;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.Push;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.Swap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.VxlanGpe;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.Vxlan4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.Vxlan6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.None;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.VxlanGpe;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.vpp.nsh.nsh.maps.NshMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nsh.rev170315.vpp.nsh.nsh.maps.NshMapKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
LOG.debug("Successfully created nsh map(id={]): iid={} dataAfter={}", newMapIndex, id, dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NshMap> id,
- @Nonnull final NshMap dataBefore, @Nonnull final NshMap dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException("Nsh map update is not supported");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NshMap> id,
@Nonnull final NshMap dataBefore,
routesContext.addName(routeName, writeContext.getMappingContext());
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier,
- @Nonnull final Route route,
- @Nonnull final Route d1, @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- throw new WriteFailedException(instanceIdentifier,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier,
@Nonnull final Route route,
LOG.debug("Writing {}", instanceIdentifier);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier,
- @Nonnull final Routing before, @Nonnull final Routing after,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- LOG.debug("Updating {} to {}", instanceIdentifier, after);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier,
@Nonnull final Routing routing, @Nonnull final WriteContext writeContext)
checkSingletonInstance(dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<RoutingInstance> id,
- @Nonnull final RoutingInstance dataBefore,
- @Nonnull final RoutingInstance dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<RoutingInstance> id,
@Nonnull final RoutingInstance dataBefore,
}
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<RoutingProtocol> instanceIdentifier,
- @Nonnull final RoutingProtocol routingProtocolBefore,
- @Nonnull final RoutingProtocol routingProtocolAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(instanceIdentifier, routingProtocolBefore,
- routingProtocolAfter, new UnsupportedOperationException("Operation not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<RoutingProtocol> instanceIdentifier,
@Nonnull final RoutingProtocol routingProtocol,
import static io.fd.hc2vpp.routing.helpers.InterfaceTestHelper.INTERFACE_INDEX;
import static io.fd.hc2vpp.routing.helpers.InterfaceTestHelper.INTERFACE_NAME;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableList;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
requestCaptor);
}
- @Test
- public void testUpdate() {
- try {
- customizer.updateCurrentAttributes(validId, Ipv6RouteData.IPV6_ROUTE_WITH_CLASSIFIER_BLACKHOLE_HOP,
- Ipv6RouteData.IPV6_ROUTE_WITH_CLASSIFIER_RECEIVE_HOP, writeContext);
- } catch (WriteFailedException e) {
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- verifyNotInvoked(api);
- return;
- }
- fail("Test should have thrown exception");
+ @Test(expected = UnsupportedOperationException.class)
+ public void testUpdate() throws WriteFailedException {
+ customizer.updateCurrentAttributes(validId, Ipv6RouteData.IPV6_ROUTE_WITH_CLASSIFIER_BLACKHOLE_HOP,
+ Ipv6RouteData.IPV6_ROUTE_WITH_CLASSIFIER_RECEIVE_HOP, writeContext);
}
@Test
*/
package io.fd.hc2vpp.routing.write;
-import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.routing.RoutingConfiguration;
-import io.fd.honeycomb.translate.write.WriteFailedException;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.routing.rev140524.routing.RoutingInstance;
customizer.writeCurrentAttributes(id, invalidData, writeContext);
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void updateCurrentAttributes() throws Exception {
- try {
- customizer.updateCurrentAttributes(id, validData, validData, writeContext);
- } catch (WriteFailedException.UpdateFailedException e) {
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- return;
- }
- fail("Test should throw WriteFailedException.UpdateFailedException");
+ customizer.updateCurrentAttributes(id, validData, validData, writeContext);
}
@Test
fail("Test should have thrown exception");
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdate() throws WriteFailedException {
- try {
- customizer.updateCurrentAttributes(validId, validData, validData, writeContext);
- } catch (Exception e) {
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- return;
- }
- fail("Test should have thrown exception");
+ customizer.updateCurrentAttributes(validId, validData, validData, writeContext);
}
}
createGreTunnel(id, swIfName, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore,
- @Nonnull final Gre dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Gre tunnel update is not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore,
@Nonnull final WriteContext writeContext)
package io.fd.hc2vpp.v3po.interfaces;
-import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.L2;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
createLoopback(id, ifcName, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Loopback> id, @Nonnull final Loopback dataBefore,
- @Nonnull final Loopback dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Modification of loopback interface is not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Loopback> id, @Nonnull final Loopback dataBefore,
@Nonnull final WriteContext writeContext)
import static com.google.common.base.Preconditions.checkArgument;
+import com.google.common.net.InetAddresses;
+import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnel;
+import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnelReply;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
import java.net.InetAddress;
import java.util.concurrent.CompletionStage;
-
import javax.annotation.Nonnull;
-
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.interfaces.rev140508.InterfaceType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.net.InetAddresses;
-
-import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnel;
-import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnelReply;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-
public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> implements JvppReplyConsumer {
private static final Logger LOG = LoggerFactory.getLogger(VxlanCustomizer.class);
createVxlanTunnel(id, swIfName, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore,
- @Nonnull final Vxlan dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("Vxlan tunnel update is not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore,
@Nonnull final WriteContext writeContext)
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.net.InetAddresses;
-import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.vpp.jvpp.core.dto.VxlanGpeAddDelTunnel;
createVxlanGpeTunnel(id, swIfName, dataAfter, writeContext);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id,
- @Nonnull final VxlanGpe dataBefore,
- @Nonnull final VxlanGpe dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter,
- new UnsupportedOperationException("VxlanGpe tunnel update is not supported"));
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id,
@Nonnull final VxlanGpe dataBefore,
sourceInterfaceName, destinationInterfaceName, spanState);
}
-
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterface> instanceIdentifier,
- @Nonnull final MirroredInterface mirroredInterfaceBefore,
- @Nonnull final MirroredInterface mirroredInterfaceAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- deleteCurrentAttributes(instanceIdentifier, mirroredInterfaceBefore, writeContext);
- writeCurrentAttributes(instanceIdentifier, mirroredInterfaceAfter, writeContext);
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterface> id,
@Nonnull final MirroredInterface mirroredInterface,
LOG.debug("L2 ARP termination table entry created successfully: {} {}", id, dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id,
- @Nonnull final ArpTerminationTableEntry dataBefore,
- @Nonnull final ArpTerminationTableEntry dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException(
- "ARP termination table entry update is not supported. It has to be deleted and then created.");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id,
@Nonnull final ArpTerminationTableEntry dataBefore,
LOG.debug("L2 FIB entry created successfully: {} {}", id, dataAfter);
}
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id,
- @Nonnull final L2FibEntry dataBefore, @Nonnull final L2FibEntry dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException {
- throw new UnsupportedOperationException(
- "L2 FIB entry update is not supported. It has to be deleted and then created.");
- }
-
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id,
@Nonnull final L2FibEntry dataBefore, @Nonnull final WriteContext writeContext)
fail("WriteFailedException.CreateFailedException was expected");
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws Exception {
- try {
- customizer.updateCurrentAttributes(id, generateGre(), generateGre(), writeContext);
- } catch (WriteFailedException.UpdateFailedException e) {
- assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
- return;
- }
- fail("WriteFailedException.UpdateFailedException was expected");
+ customizer.updateCurrentAttributes(id, generateGre(), generateGre(), writeContext);
}
@Test
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.net.InetAddresses;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.VppInvocationException;
+import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnel;
+import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnelReply;
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.rev170607.interfaces._interface.VxlanBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.net.InetAddresses;
-
-import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.VppInvocationException;
-import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnel;
-import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnelReply;
-
public class VxlanCustomizerTest extends WriterCustomizerTest {
private static final byte ADD_VXLAN = 1;
fail("WriteFailedException.CreateFailedException was expected");
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws Exception {
- try {
- customizer.updateCurrentAttributes(id, generateVxlan(10), generateVxlan(11), writeContext);
- } catch (WriteFailedException.UpdateFailedException e) {
- assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
- return;
- }
- fail("WriteFailedException.UpdateFailedException was expected");
+ customizer.updateCurrentAttributes(id, generateVxlan(10), generateVxlan(11), writeContext);
}
@Test
fail("WriteFailedException.CreateFailedException was expected");
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void testUpdateCurrentAttributes() throws Exception {
- try {
- customizer.updateCurrentAttributes(id, generateVxlanGpe(10), generateVxlanGpe(11), writeContext);
- } catch (WriteFailedException.UpdateFailedException e) {
- assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
- return;
- }
- fail("WriteFailedException.UpdateFailedException was expected");
+ customizer.updateCurrentAttributes(id, generateVxlanGpe(10), generateVxlanGpe(11), writeContext);
}
@Test
assertCreateRequest(requestCaptor.getValue());
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void updateCurrentAttributes() throws Exception {
customizer.updateCurrentAttributes(validId, validData, validData, writeContext);
- verify(api, times(2)).swInterfaceSpanEnableDisable(requestCaptor.capture());
- assertDeleteRequest(requestCaptor.getAllValues().get(0));
- assertCreateRequest(requestCaptor.getAllValues().get(1));
}
@Test
Code Review / hc2vpp.git / commitdiff