import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.Credentials;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.credentials.LoginPasswordBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
final Node node = new NodeBuilder()
.withKey(new NodeKey(nodeId))
.setNodeId(nodeId)
- .addAugmentation(NetconfNode.class, netconfNode)
+ .addAugmentation(netconfNode)
.build();
final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
final String newPassword = Strings.isNullOrEmpty(updated.get(NetconfConsoleConstants.PASSWORD))
? updated.get(NetconfConsoleConstants.PASSWORD) : password;
- final Credentials credentials =
- new LoginPasswordBuilder().setPassword(newPassword).setUsername(newUsername).build();
- final NetconfNode updatedNetconfNode = new NetconfNodeBuilder()
- .setHost(new Host(new IpAddress(new Ipv4Address(deviceIp))))
- .setPort(new PortNumber(Uint16.valueOf(Integer.decode(devicePort))))
- .setTcpOnly(tcpOnly)
- .setSchemaless(isSchemaless)
- .setCredentials(credentials)
- .build();
-
final Node updatedNode = new NodeBuilder()
.withKey(node.key())
.setNodeId(node.getNodeId())
- .addAugmentation(NetconfNode.class, updatedNetconfNode)
+ .addAugmentation(new NetconfNodeBuilder()
+ .setHost(new Host(new IpAddress(new Ipv4Address(deviceIp))))
+ .setPort(new PortNumber(Uint16.valueOf(Integer.decode(devicePort))))
+ .setTcpOnly(tcpOnly)
+ .setSchemaless(isSchemaless)
+ .setCredentials(new LoginPasswordBuilder()
+ .setPassword(newPassword)
+ .setUsername(newUsername)
+ .build())
+ .build())
.build();
final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
final AvailableCapabilities avCaps =
new AvailableCapabilitiesBuilder().setAvailableCapability(avCapList).build();
- final NetconfNode nn = new NetconfNodeBuilder().setConnectionStatus(cs).setHost(host).setPort(port)
- .setAvailableCapabilities(avCaps).build();
final NodeId nodeId = new NodeId(nodeIdent);
final NodeKey nk = new NodeKey(nodeId);
- final NodeBuilder nb = new NodeBuilder();
- nb.withKey(nk);
- nb.setNodeId(nodeId);
- nb.addAugmentation(NetconfNode.class, nn);
- return nb.build();
+ return new NodeBuilder()
+ .withKey(nk)
+ .setNodeId(nodeId)
+ .addAugmentation(new NetconfNodeBuilder()
+ .setConnectionStatus(cs).setHost(host).setPort(port).setAvailableCapabilities(avCaps).build())
+ .build();
}
private static void assertBaseNodeAttributes(final Map<?, ?> mapNode) {
import org.opendaylight.netconf.sal.connect.netconf.sal.SchemalessNetconfDeviceRpc;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.get.config.input.source.ConfigSource;
-import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Provides base operations for netconf e.g. get, get-config, edit-config, (un)lock, commit etc.
private final MountPointContext mountContext;
private final RpcStructureTransformer transformer;
- @Deprecated
- public NetconfBaseOps(final DOMRpcService rpc, final EffectiveModelContext schemaContext) {
- this(rpc, new EmptyMountPointContext(schemaContext));
- }
-
public NetconfBaseOps(final DOMRpcService rpc, final MountPointContext mountContext) {
this.rpc = rpc;
this.mountContext = mountContext;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
@Test
public void testIgnoreNonVisibleData() {
- final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(EffectiveModelContext.class)),
+ final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(MountPointContext.class)),
false);
final MapNode emptyList = ImmutableNodes.mapNodeBuilder(NETCONF_FILTER_QNAME).build();
tx.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
.when(rpc).invokeRpc(any(SchemaPath.class), isNull());
- final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(EffectiveModelContext.class)),
+ final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(MountPointContext.class)),
false);
try {
tx.commit().get();
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
.doReturn(rpcErrorFuture).when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
- final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(EffectiveModelContext.class)),
+ final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(MountPointContext.class)),
false);
try {
.when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
final WriteRunningTx tx = new WriteRunningTx(id,
- new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchemaWithNotifications().getEffectiveModelContext()), false);
+ new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchemaWithNotifications().getMountPointContext()), false);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
tx.commit();
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
.when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
final WriteCandidateTx tx = new WriteCandidateTx(
- id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getEffectiveModelContext()), false);
+ id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getMountPointContext()), false);
final TxListener listener = mock(TxListener.class);
tx.addListener(listener);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
.when(rpc).invokeRpc(any(SchemaPath.class), isNull());
final WriteCandidateTx tx = new WriteCandidateTx(
- id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getEffectiveModelContext()), false);
+ id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getMountPointContext()), false);
final TxListener listener = mock(TxListener.class);
tx.addListener(listener);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
doReturn(FluentFutures.immediateFailedFluentFuture(cause))
.when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
final WriteCandidateTx tx = new WriteCandidateTx(
- id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getEffectiveModelContext()), false);
+ id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getMountPointContext()), false);
final TxListener listener = mock(TxListener.class);
tx.addListener(listener);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ReadOnlyTxTest {
-
- private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.create();
-
@Mock
private DOMRpcService rpc;
@Mock
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(mockedNode))).when(rpc)
.invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
- doReturn("node").when(mockedNode).toString();
}
@Test
public void testRead() throws Exception {
- final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(EffectiveModelContext.class));
+ final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(MountPointContext.class));
final ReadOnlyTx readOnlyTx =
new ReadOnlyTx(netconfOps, new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)));
- readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create());
+ readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME)), any(ContainerNode.class));
- readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, PATH);
+ readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
NetconfMessageTransformUtil.NETCONF_GET_QNAME)), any(ContainerNode.class));
}
@Test
public void testExists() throws Exception {
- final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(EffectiveModelContext.class));
+ final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(MountPointContext.class));
final ReadOnlyTx readOnlyTx =
new ReadOnlyTx(netconfOps, new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)));
- readOnlyTx.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create());
+ readOnlyTx.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME)), any(ContainerNode.class));
- readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, PATH);
+ readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
NetconfMessageTransformUtil.NETCONF_GET_QNAME)), any(ContainerNode.class));
}
@Test
public void testIdentifier() throws Exception {
- final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(EffectiveModelContext.class));
+ final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(MountPointContext.class));
final ReadOnlyTx tx1 =
new ReadOnlyTx(netconfOps, new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)));
final ReadOnlyTx tx2 =
import java.net.InetSocketAddress;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class WriteCandidateRunningTxTest extends AbstractTestModelTest {
@Mock
private DOMRpcService rpc;
private RemoteDeviceId id;
@Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
+ public void setUp() {
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult())).when(rpc).invokeRpc(any(), any());
- netconfOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+ netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
}
import java.net.InetSocketAddress;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class WriteCandidateTxTest extends AbstractTestModelTest {
@Mock
private DOMRpcService rpc;
private RemoteDeviceId id;
@Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
+ public void setUp() {
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult())).when(rpc).invokeRpc(any(), any());
- netconfOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+ netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
}
NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
verify(rpc).invokeRpc(eq(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_UNLOCK_QNAME)), any());
}
-
}
\ No newline at end of file
import java.net.InetSocketAddress;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class WriteRunningTxTest extends AbstractTestModelTest {
@Mock
private DOMRpcService rpc;
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult())).when(rpc).invokeRpc(any(), any());
- netconfOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+ netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
}
*/
package org.opendaylight.netconf.sal.connect.netconf.schema;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertThrows;
-import com.google.common.io.ByteStreams;
import com.google.common.util.concurrent.ListenableFuture;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.URL;
+import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
public class YangLibrarySchemaYangSourceProviderTest {
-
private SourceIdentifier workingSid;
private YangLibrarySchemaYangSourceProvider yangLibrarySchemaYangSourceProvider;
public void testGetSource() throws Exception {
ListenableFuture<? extends YangTextSchemaSource> source = yangLibrarySchemaYangSourceProvider
.getSource(workingSid);
- final String x = new String(ByteStreams.toByteArray(source.get().openStream()));
- Assert.assertThat(x, CoreMatchers.containsString("module config-test-rpc"));
+
+ final String x = source.get().asCharSource(StandardCharsets.UTF_8).read();
+ assertThat(x, containsString("module config-test-rpc"));
}
@Test
final YangLibrarySchemaYangSourceProvider failingYangLibrarySchemaYangSourceProvider =
new YangLibrarySchemaYangSourceProvider(id, sourceIdentifierURLMap);
- try {
- failingYangLibrarySchemaYangSourceProvider.getSource(workingSid).get();
- fail();
- } catch (ExecutionException e) {
- final Throwable cause = e.getCause();
- assertTrue(cause instanceof SchemaSourceException);
- }
+ final ListenableFuture<?> future = failingYangLibrarySchemaYangSourceProvider.getSource(workingSid);
+ final ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(SchemaSourceException.class));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testGetSourceNotAvailable() throws Exception {
- yangLibrarySchemaYangSourceProvider.getSource(RevisionSourceIdentifier.create("aaaaa"));
+ assertThrows(IllegalArgumentException.class,
+ () -> yangLibrarySchemaYangSourceProvider.getSource(RevisionSourceIdentifier.create("aaaaa")));
}
}
public void toActionRequestConflictingInListTest() {
QName barInputQname = QName.create(BAR_QNAME, "bar");
QName barIdQname = QName.create(BAR_QNAME, "bar-id");
- Byte barInput = new Byte("1");
+ Byte barInput = 1;
List<PathArgument> nodeIdentifiers = new ArrayList<>();
nodeIdentifiers.add(NodeIdentifier.create(BAR_QNAME));
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.ModifyAction;
import org.opendaylight.netconf.api.NetconfMessage;
import org.w3c.dom.NamedNodeMap;
import org.xml.sax.SAXException;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class NetconfBaseOpsTest extends AbstractTestModelTest {
private static final QName CONTAINER_Q_NAME = QName.create("test:namespace", "2013-07-22", "c");
@Before
public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
final InputStream okStream = getClass().getResourceAsStream("/netconfMessages/rpc-reply_ok.xml");
final InputStream dataStream = getClass().getResourceAsStream("/netconfMessages/rpc-reply_get.xml");
final NetconfMessage ok = new NetconfMessage(XmlUtil.readXmlToDocument(okStream));
final RemoteDeviceId id =
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));
callback = new NetconfRpcFutureCallback("prefix", id);
- baseOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+ baseOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
}
@Test
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.parser.impl.YangParserFactoryImpl;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.ASTSchemaSource;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class YangLibProviderTest {
private static final File CACHE_DIR = new File("target/yanglib");
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
-
try {
if (CACHE_DIR.exists()) {
FileUtils.cleanDirectory(CACHE_DIR);
List<PotentialSchemaSource<?>> potentialSources = Collections.emptyList();
yangLibProvider.schemaSourceRegistered(potentialSources);
- verifyZeroInteractions(dataBroker, writeTransaction);
+ verifyNoMoreInteractions(dataBroker, writeTransaction);
// test list of non yang schema sources registered
// expected behavior is to do nothing
ASTSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
yangLibProvider.schemaSourceRegistered(potentialSources);
- verifyZeroInteractions(dataBroker, writeTransaction);
+ verifyNoMoreInteractions(dataBroker, writeTransaction);
// add yang schema source to list
potentialSources.add(
yangLibProvider.schemaSourceUnregistered(nonYangSource);
// expected behaviour is to do nothing if non yang based source is unregistered
- verifyZeroInteractions(dataBroker, writeTransaction);
+ verifyNoMoreInteractions(dataBroker, writeTransaction);
}
@Test
/**
* Implementation of {@link DOMMountPointServiceHandler}.
- *
*/
@Singleton
public final class DOMMountPointServiceHandler implements Handler<DOMMountPointService> {
this.domMountPointService = requireNonNull(domMountPointService);
}
- @Deprecated
- public static DOMMountPointServiceHandler newInstance(final DOMMountPointService domMountPointService) {
- return new DOMMountPointServiceHandler(domMountPointService);
- }
-
@Override
public DOMMountPointService get() {
return this.domMountPointService;
this.domSchemaService = domSchemaService;
}
- @Deprecated
- public static SchemaContextHandler newInstance(final TransactionChainHandler transactionChainHandler,
- final DOMSchemaService domSchemaService) {
- return new SchemaContextHandler(transactionChainHandler, domSchemaService);
- }
-
@PostConstruct
public void init() {
listenerRegistration = domSchemaService.registerSchemaContextListener(this);
doReturn(mockTx).when(mockChain).newWriteOnlyTransaction();
doReturn(mockChain).when(mockDataBroker).createTransactionChain(any());
- SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(
+ SchemaContextHandler schemaContextHandler = new SchemaContextHandler(
new TransactionChainHandler(mockDataBroker), Mockito.mock(DOMSchemaService.class));
schemaContextHandler.onModelContextUpdated(schemaContext);
return schemaContextHandler;
doReturn(schemaContext).when(mountPoint).getEffectiveModelContext();
doCallRealMethod().when(mountPoint).getSchemaContext();
- mountPointServiceHandler = DOMMountPointServiceHandler.newInstance(mountPointService);
+ mountPointServiceHandler = new DOMMountPointServiceHandler(mountPointService);
}
protected abstract MediaType getMediaType();
return TestRestconfUtils.loadSchemaContext(yangPath, schemaContext);
}
- protected static <T extends AbstractIdentifierAwareJaxRsProvider> void mockBodyReader(
+ protected static <T extends AbstractIdentifierAwareJaxRsProvider<?>> void mockBodyReader(
final String identifier, final T normalizedNodeProvider,
final boolean isPost) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException {
package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
final TransactionChainHandler txChainHandler = new TransactionChainHandler(mockDOMDataBroker);
final DOMMountPointServiceHandler mountPointServiceHandler =
- DOMMountPointServiceHandler.newInstance(mockMountPointService);
+ new DOMMountPointServiceHandler(mockMountPointService);
final DOMNotificationService mockNotificationService = mock(DOMNotificationService.class);
final ServicesWrapper servicesWrapper = ServicesWrapper.newInstance(schemaContextHandler,
doReturn(Optional.of(mockDOMDataBroker)).when(mockMountPoint).getService(DOMDataBroker.class);
- doReturn(Optional.of(mockMountPoint))
- .when(mockMountPointService).getMountPoint(notNull(YangInstanceIdentifier.class));
+ doReturn(Optional.of(mockMountPoint)).when(mockMountPointService).getMountPoint(notNull());
return mockMountPoint;
}
transactionChainHandler = new TransactionChainHandler(mockDataBroker);
- final SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(transactionChainHandler,
+ final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(transactionChainHandler,
Mockito.mock(DOMSchemaService.class));
schemaContextHandler.onModelContextUpdated(this.contextRef.get());
this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler,
- DOMMountPointServiceHandler.newInstance(mountPointService), this.delegRestconfSubscrService,
+ new DOMMountPointServiceHandler(mountPointService), this.delegRestconfSubscrService,
this.actionServiceHandler);
doReturn(Optional.of(this.mountPoint)).when(this.mountPointService)
.getMountPoint(any(YangInstanceIdentifier.class));
final DOMDataTreeWriteTransaction wTx = mock(DOMDataTreeWriteTransaction.class);
when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
- final SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(txHandler,
+ final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(txHandler,
mock(DOMSchemaService.class));
schemaContextHandler.onModelContextUpdated(contextRef.get());
this.invokeOperationsService =
doReturn(domTx).when(dataBroker).createTransactionChain(any());
transactionHandler = new TransactionChainHandler(dataBroker);
- schemaHandler = SchemaContextHandler.newInstance(transactionHandler, mock(DOMSchemaService.class));
+ schemaHandler = new SchemaContextHandler(transactionHandler, mock(DOMSchemaService.class));
DOMDataTreeChangeService dataTreeChangeService = mock(DOMDataTreeChangeService.class);
doReturn(mock(ListenerRegistration.class)).when(dataTreeChangeService)
import javax.ws.rs.core.UriInfo;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class RestconfOperationsServiceTest {
@Mock
@Before
public void init() throws Exception {
- MockitoAnnotations.initMocks(this);
this.schemaContext = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/modules"));
this.schemaContextHandler = TestUtils.newSchemaContextHandler(schemaContext);
- this.domMountPointServiceHandler = DOMMountPointServiceHandler.newInstance(this.domMountPointService);
+ this.domMountPointServiceHandler = new DOMMountPointServiceHandler(this.domMountPointService);
final QNameModule module1 = QNameModule.create(URI.create("module:1"));
final QNameModule module2 = QNameModule.create(URI.create("module:2"));
domDataBroker = getDomBroker();
transactionChainHandler = new TransactionChainHandler(domDataBroker);
- schemaContextHandler = SchemaContextHandler.newInstance(transactionChainHandler,
- Mockito.mock(DOMSchemaService.class));
+ schemaContextHandler = new SchemaContextHandler(transactionChainHandler, Mockito.mock(DOMSchemaService.class));
schemaContextHandler.onModelContextUpdated(SCHEMA_CONTEXT);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.streams.websockets;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
import java.io.IOException;
import java.util.List;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.eclipse.jetty.websocket.api.Session;
-import org.junit.Assert;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
import org.opendaylight.restconf.nb.rfc8040.streams.listeners.BaseListenerInterface;
public class WebSocketSessionHandlerTest {
private final ScheduledFuture pingFuture;
private WebSocketTestSessionState(final int maxFragmentSize, final int heartbeatInterval) {
- listener = Mockito.mock(BaseListenerInterface.class);
- executorService = Mockito.mock(ScheduledExecutorService.class);
+ listener = mock(BaseListenerInterface.class);
+ executorService = mock(ScheduledExecutorService.class);
this.heartbeatInterval = heartbeatInterval;
this.maxFragmentSize = maxFragmentSize;
webSocketSessionHandler = new WebSocketSessionHandler(executorService, listener, maxFragmentSize,
heartbeatInterval);
- pingFuture = Mockito.mock(ScheduledFuture.class);
- Mockito.when(executorService.scheduleWithFixedDelay(Mockito.any(Runnable.class),
- Mockito.eq((long) heartbeatInterval), Mockito.eq((long) heartbeatInterval),
- Mockito.eq(TimeUnit.MILLISECONDS))).thenReturn(pingFuture);
+ pingFuture = mock(ScheduledFuture.class);
+ when(executorService.scheduleWithFixedDelay(any(Runnable.class), eq((long) heartbeatInterval),
+ eq((long) heartbeatInterval), eq(TimeUnit.MILLISECONDS))).thenReturn(pingFuture);
}
}
final int heartbeatInterval = 1000;
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(
1000, heartbeatInterval);
- final Session session = Mockito.mock(Session.class);
+ final Session session = mock(Session.class);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
- Mockito.verify(webSocketTestSessionState.listener).addSubscriber(
+ verify(webSocketTestSessionState.listener).addSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
- Mockito.verify(webSocketTestSessionState.executorService).scheduleWithFixedDelay(Mockito.any(Runnable.class),
- Mockito.eq((long) webSocketTestSessionState.heartbeatInterval),
- Mockito.eq((long) webSocketTestSessionState.heartbeatInterval), Mockito.eq(TimeUnit.MILLISECONDS));
+ verify(webSocketTestSessionState.executorService).scheduleWithFixedDelay(any(Runnable.class),
+ eq((long) webSocketTestSessionState.heartbeatInterval),
+ eq((long) webSocketTestSessionState.heartbeatInterval), eq(TimeUnit.MILLISECONDS));
}
@Test
final int heartbeatInterval = 0;
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(
1000, heartbeatInterval);
- final Session session = Mockito.mock(Session.class);
+ final Session session = mock(Session.class);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
- Mockito.verify(webSocketTestSessionState.listener).addSubscriber(
+ verify(webSocketTestSessionState.listener).addSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
- Mockito.verifyZeroInteractions(webSocketTestSessionState.executorService);
+ verifyNoMoreInteractions(webSocketTestSessionState.executorService);
}
@Test
public void onWebSocketConnectedWithAlreadyOpenSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
- final Session session = Mockito.mock(Session.class);
- Mockito.when(session.isOpen()).thenReturn(true);
+ final Session session = mock(Session.class);
+ when(session.isOpen()).thenReturn(true);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
- Mockito.verify(webSocketTestSessionState.listener, Mockito.times(1)).addSubscriber(Mockito.any());
+ verify(webSocketTestSessionState.listener, times(1)).addSubscriber(any());
}
@Test
public void onWebSocketClosedWithOpenSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(200, 10000);
- final Session session = Mockito.mock(Session.class);
+ final Session session = mock(Session.class);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
- Mockito.verify(webSocketTestSessionState.listener).addSubscriber(
+ verify(webSocketTestSessionState.listener).addSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketClosed(200, "Simulated close");
- Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+ verify(webSocketTestSessionState.listener).removeSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
}
public void onWebSocketClosedWithNotInitialisedSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(300, 12000);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketClosed(500, "Simulated close");
- Mockito.verifyZeroInteractions(webSocketTestSessionState.listener);
+ verifyNoMoreInteractions(webSocketTestSessionState.listener);
}
@Test
public void onWebSocketErrorWithEnabledPingAndLivingSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
- final Session session = Mockito.mock(Session.class);
- Mockito.when(session.isOpen()).thenReturn(true);
+ final Session session = mock(Session.class);
+ when(session.isOpen()).thenReturn(true);
final Throwable sampleError = new IllegalStateException("Simulated error");
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
- Mockito.when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
- Mockito.when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(false);
+ when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
+ when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(false);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketError(sampleError);
- Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+ verify(webSocketTestSessionState.listener).removeSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
- Mockito.verify(session).close();
- Mockito.verify(webSocketTestSessionState.pingFuture).cancel(Mockito.anyBoolean());
+ verify(session).close();
+ verify(webSocketTestSessionState.pingFuture).cancel(anyBoolean());
}
@Test
public void onWebSocketErrorWithEnabledPingAndDeadSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
- final Session session = Mockito.mock(Session.class);
- Mockito.when(session.isOpen()).thenReturn(false);
+ final Session session = mock(Session.class);
+ when(session.isOpen()).thenReturn(false);
final Throwable sampleError = new IllegalStateException("Simulated error");
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketError(sampleError);
- Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+ verify(webSocketTestSessionState.listener).removeSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
- Mockito.verify(session, Mockito.never()).close();
- Mockito.verify(webSocketTestSessionState.pingFuture).cancel(Mockito.anyBoolean());
+ verify(session, never()).close();
+ verify(webSocketTestSessionState.pingFuture).cancel(anyBoolean());
}
@Test
public void onWebSocketErrorWithDisabledPingAndDeadSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
- final Session session = Mockito.mock(Session.class);
- Mockito.when(session.isOpen()).thenReturn(false);
+ final Session session = mock(Session.class);
+ when(session.isOpen()).thenReturn(false);
final Throwable sampleError = new IllegalStateException("Simulated error");
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
- Mockito.when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
- Mockito.when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(true);
+ when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
+ when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(true);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketError(sampleError);
- Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+ verify(webSocketTestSessionState.listener).removeSubscriber(
webSocketTestSessionState.webSocketSessionHandler);
- Mockito.verify(session, Mockito.never()).close();
- Mockito.verify(webSocketTestSessionState.pingFuture, Mockito.never()).cancel(Mockito.anyBoolean());
+ verify(session, never()).close();
+ verify(webSocketTestSessionState.pingFuture, never()).cancel(anyBoolean());
}
@Test
public void sendDataMessageWithDisabledFragmentation() throws IOException {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(0, 0);
- final Session session = Mockito.mock(Session.class);
- final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
- Mockito.when(session.isOpen()).thenReturn(true);
- Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+ final Session session = mock(Session.class);
+ final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+ when(session.isOpen()).thenReturn(true);
+ when(session.getRemote()).thenReturn(remoteEndpoint);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
final String testMessage = generateRandomStringOfLength(100);
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
- Mockito.verify(remoteEndpoint).sendString(testMessage);
+ verify(remoteEndpoint).sendString(testMessage);
}
@Test
public void sendDataMessageWithDisabledFragAndDeadSession() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(0, 0);
- final Session session = Mockito.mock(Session.class);
- final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
- Mockito.when(session.isOpen()).thenReturn(false);
- Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+ final Session session = mock(Session.class);
+ final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+ when(session.isOpen()).thenReturn(false);
+ when(session.getRemote()).thenReturn(remoteEndpoint);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
final String testMessage = generateRandomStringOfLength(11);
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
- Mockito.verifyZeroInteractions(remoteEndpoint);
+ verifyNoMoreInteractions(remoteEndpoint);
}
@Test
public void sendDataMessageWithEnabledFragAndSmallMessage() throws IOException {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
- final Session session = Mockito.mock(Session.class);
- final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
- Mockito.when(session.isOpen()).thenReturn(true);
- Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+ final Session session = mock(Session.class);
+ final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+ when(session.isOpen()).thenReturn(true);
+ when(session.getRemote()).thenReturn(remoteEndpoint);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
// in both cases, fragmentation should not be applied
final String testMessage2 = generateRandomStringOfLength(50);
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage1);
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage2);
- Mockito.verify(remoteEndpoint).sendString(testMessage1);
- Mockito.verify(remoteEndpoint).sendString(testMessage2);
- Mockito.verify(remoteEndpoint, Mockito.never()).sendPartialString(Mockito.anyString(), Mockito.anyBoolean());
+ verify(remoteEndpoint).sendString(testMessage1);
+ verify(remoteEndpoint).sendString(testMessage2);
+ verify(remoteEndpoint, never()).sendPartialString(anyString(), anyBoolean());
}
@Test
public void sendDataMessageWithZeroLength() {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
- final Session session = Mockito.mock(Session.class);
- final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
- Mockito.when(session.isOpen()).thenReturn(true);
- Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+ final Session session = mock(Session.class);
+ final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+ when(session.isOpen()).thenReturn(true);
+ when(session.getRemote()).thenReturn(remoteEndpoint);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage("");
- Mockito.verifyZeroInteractions(remoteEndpoint);
+ verifyNoMoreInteractions(remoteEndpoint);
}
@Test
public void sendDataMessageWithEnabledFragAndLargeMessage1() throws IOException {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
- final Session session = Mockito.mock(Session.class);
- final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
- Mockito.when(session.isOpen()).thenReturn(true);
- Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+ final Session session = mock(Session.class);
+ final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+ when(session.isOpen()).thenReturn(true);
+ when(session.getRemote()).thenReturn(remoteEndpoint);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
// there should be 10 fragments of length 100 characters
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
final ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
final ArgumentCaptor<Boolean> isLastCaptor = ArgumentCaptor.forClass(Boolean.class);
- Mockito.verify(remoteEndpoint, Mockito.times(10)).sendPartialString(
+ verify(remoteEndpoint, times(10)).sendPartialString(
messageCaptor.capture(), isLastCaptor.capture());
final List<String> allMessages = messageCaptor.getAllValues();
final List<Boolean> isLastFlags = isLastCaptor.getAllValues();
- Assert.assertTrue(allMessages.stream().allMatch(s -> s.length() == webSocketTestSessionState.maxFragmentSize));
- Assert.assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
- Assert.assertTrue(isLastFlags.get(9));
+ assertTrue(allMessages.stream().allMatch(s -> s.length() == webSocketTestSessionState.maxFragmentSize));
+ assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
+ assertTrue(isLastFlags.get(9));
}
@Test
public void sendDataMessageWithEnabledFragAndLargeMessage2() throws IOException {
final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
- final Session session = Mockito.mock(Session.class);
- final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
- Mockito.when(session.isOpen()).thenReturn(true);
- Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+ final Session session = mock(Session.class);
+ final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+ when(session.isOpen()).thenReturn(true);
+ when(session.getRemote()).thenReturn(remoteEndpoint);
webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
// there should be 10 fragments, the last fragment should be the shortest one
webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
final ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
final ArgumentCaptor<Boolean> isLastCaptor = ArgumentCaptor.forClass(Boolean.class);
- Mockito.verify(remoteEndpoint, Mockito.times(10)).sendPartialString(
+ verify(remoteEndpoint, times(10)).sendPartialString(
messageCaptor.capture(), isLastCaptor.capture());
final List<String> allMessages = messageCaptor.getAllValues();
final List<Boolean> isLastFlags = isLastCaptor.getAllValues();
- Assert.assertTrue(allMessages.subList(0, 9).stream().allMatch(s ->
+ assertTrue(allMessages.subList(0, 9).stream().allMatch(s ->
s.length() == webSocketTestSessionState.maxFragmentSize));
- Assert.assertEquals(50, allMessages.get(9).length());
- Assert.assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
- Assert.assertTrue(isLastFlags.get(9));
+ assertEquals(50, allMessages.get(9).length());
+ assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
+ assertTrue(isLastFlags.get(9));
}
private static String generateRandomStringOfLength(final int length) {