private IHandler CreateHandler(
IMessageQueueFactory messageQueueFactory,
IChaincodeSupportClientFactory chaincodeSupportClientFactory,
IChaincodeStubFactory chaincodeStubFactory = null,
IChaincode chaincode = null
)
{
return(new global::Thinktecture.HyperledgerFabric.Chaincode.NET.Handler.Handler(
chaincode ?? new Mock <IChaincode>().Object,
"example.test",
9999,
chaincodeStubFactory ?? new Mock <IChaincodeStubFactory>().Object,
new Mock <ILogger <global::Thinktecture.HyperledgerFabric.Chaincode.NET.Handler.Handler> >().Object,
messageQueueFactory,
chaincodeSupportClientFactory
));
}
public Handler(
IChaincode chaincode,
string host,
int port,
IChaincodeStubFactory chaincodeStubFactory,
ILogger <Handler> logger,
IMessageQueueFactory messageQueueFactory,
IChaincodeSupportClientFactory chaincodeSupportClientFactory
)
{
_chaincode = chaincode;
_chaincodeStubFactory = chaincodeStubFactory;
_logger = logger;
// TODO: Secure channel?
_client = chaincodeSupportClientFactory.Create(new Channel(host, port, ChannelCredentials.Insecure,
new List <ChannelOption>
{
new ChannelOption("request-timeout", 30000)
}));
_messageQueue = messageQueueFactory.Create(this);
}
CreateHandlerMockWithStreamExpectation(
ChaincodeMessage responseMessage,
IClientStreamWriter <ChaincodeMessage> requestStream = null,
IMessageQueueFactory messageQueueFactory = null,
IChaincodeStubFactory chaincodeStubFactory = null,
IChaincode chaincode = null
)
{
var responseStreamMock = new Mock <IAsyncStreamReader <ChaincodeMessage> >();
responseStreamMock.SetupSequence(m => m.MoveNext(It.IsAny <CancellationToken>()))
.ReturnsAsync(true)
.ReturnsAsync(false);
responseStreamMock.Setup(m => m.Current)
.Returns(responseMessage);
var asyncDuplexStream = new AsyncDuplexStreamingCall <ChaincodeMessage, ChaincodeMessage>(
requestStream ?? new Mock <IClientStreamWriter <ChaincodeMessage> >().Object,
responseStreamMock.Object,
null, null, null, null
);
var chaincodeSupportClientMock = new Mock <ChaincodeSupport.ChaincodeSupportClient>();
chaincodeSupportClientMock.Setup(m => m.Register(null, null, It.IsAny <CancellationToken>()))
.Returns(asyncDuplexStream);
var chaincodeSupportClientFactoryMock = new Mock <IChaincodeSupportClientFactory>();
chaincodeSupportClientFactoryMock.Setup(m => m.Create(It.IsAny <Channel>()))
.Returns(chaincodeSupportClientMock.Object);
var handler = CreateHandler(messageQueueFactory ?? new Mock <IMessageQueueFactory>().Object,
chaincodeSupportClientFactoryMock.Object, chaincodeStubFactory, chaincode);
return(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler);
}
