private ConnectionContext prepareConnectionContext() {
ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID);
when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
return mockedConnectionContext;
}
@Test
public void testOnPublished() {
final ConnectionContext auxiliaryConnectionContext = addDummyAuxiliaryConnectionContext();
ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
when(auxiliaryConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
deviceContext.onPublished();
verify(mockedAuxConnectionAdapter).setPacketInFiltering(eq(false));
verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
}
@Test
public void registerServiceTest() {
final RpcContext mockedRpcContext = mock(RpcContext.class);
final DeviceContext mockedDeviceContext = mock(DeviceContext.class);
final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
final FeaturesReply mockedFeatures = mock(FeaturesReply.class);
when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeatures);
final BigInteger mockedDataPathId = mock(BigInteger.class);
when(mockedFeatures.getDatapathId()).thenReturn(mockedDataPathId);
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedConnectionContext);
MdSalRegistratorUtils.registerServices(mockedRpcContext, mockedDeviceContext);
verify(mockedRpcContext, times(NUMBER_OF_RPC_SERVICE_REGISTRATION))
.registerRpcServiceImplementation(any(RpcService.class.getClass()), any(RpcService.class));
}
@Test
public void testClose() {
ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
InetSocketAddress mockRemoteAddress = mock(InetSocketAddress.class);
when(mockedConnectionAdapter.getRemoteAddress()).thenReturn(mockRemoteAddress);
when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
NodeId dummyNodeId = new NodeId("dummyNodeId");
when(deviceState.getNodeId()).thenReturn(dummyNodeId);
ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
deviceContext.addAuxiliaryConenctionContext(mockedAuxiliaryConnectionContext);
DeviceContextClosedHandler mockedDeviceContextClosedHandler =
mock(DeviceContextClosedHandler.class);
deviceContext.addDeviceContextClosedHandler(mockedDeviceContextClosedHandler);
deviceContext.close();
verify(connectionContext).closeConnection(eq(false));
verify(deviceState).setValid(eq(false));
verify(txChainManager).close();
verify(mockedAuxiliaryConnectionContext).closeConnection(eq(false));
}
@Before
public void setUp() {
final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture =
Futures.immediateCheckedFuture(Optional.<Node>absent());
Mockito.when(rTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent))
.thenReturn(noExistNodeFuture);
Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
Mockito.when(dataBroker.createTransactionChain(Mockito.any(TransactionChainManager.class)))
.thenReturn(txChainFactory);
Mockito.when(deviceState.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply =
SettableFuture.create();
Mockito.when(requestContext.getFuture()).thenReturn(settableFuture);
Mockito.doAnswer(
new Answer<Object>() {
@SuppressWarnings("unchecked")
@Override
public Object answer(final InvocationOnMock invocation) {
settableFuture.set((RpcResult<GetAsyncReply>) invocation.getArguments()[0]);
return null;
}
})
.when(requestContext)
.setResult(any(RpcResult.class));
Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
Mockito.doAnswer(
new Answer<Object>() {
@SuppressWarnings("unchecked")
@Override
public Object answer(final InvocationOnMock invocation) {
settableFutureMultiReply.set(
(RpcResult<MultipartReply>) invocation.getArguments()[0]);
return null;
}
})
.when(requestContextMultiReply)
.setResult(any(RpcResult.class));
Mockito.when(txChainFactory.newWriteOnlyTransaction()).thenReturn(wTx);
Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
Mockito.when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider);
Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
Mockito.when(deviceState.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
Mockito.when(
messageTranslatorPacketReceived.translate(
any(Object.class), any(DeviceContext.class), any(Object.class)))
.thenReturn(mock(PacketReceived.class));
Mockito.when(
messageTranslatorFlowCapableNodeConnector.translate(
any(Object.class), any(DeviceContext.class), any(Object.class)))
.thenReturn(mock(FlowCapableNodeConnector.class));
Mockito.when(
translatorLibrary.lookupTranslator(
eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PacketIn.class.getName()))))
.thenReturn(messageTranslatorPacketReceived);
Mockito.when(
translatorLibrary.lookupTranslator(
eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PortGrouping.class.getName()))))
.thenReturn(messageTranslatorFlowCapableNodeConnector);
deviceContext =
new DeviceContextImpl(
connectionContext,
deviceState,
dataBroker,
timer,
messageIntelligenceAgency,
outboundQueueProvider,
translatorLibrary,
txChainManager);
xid = new Xid(atomicLong.incrementAndGet());
xidMulti = new Xid(atomicLong.incrementAndGet());
}