public async Task SelectPartitionShouldThrowWhenTopicsCollectionIsEmpty()
{
var metadataResponse = await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers();
metadataResponse.Topics.Clear();
var routerProxy = new BrokerRouterProxy(_kernel);
routerProxy.BrokerConn0.MetadataResponseFunction = async() => metadataResponse;
routerProxy.Create().SelectBrokerRouteFromLocalCache(TestTopic);
}
public async Task SelectExactPartitionShouldThrowWhenBrokerCollectionIsEmpty()
{
var metadataResponse = await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers();
metadataResponse.Brokers.Clear();
var routerProxy = new BrokerRouterProxy(_kernel);
routerProxy.BrokerConn0.MetadataResponseFunction = async() => metadataResponse;
var router = routerProxy.Create();
await router.RefreshMissingTopicMetadata(TestTopic);
router.SelectBrokerRouteFromLocalCache(TestTopic, 1);
}
public async Task BrokerRouterUsesFactoryToAddNewBrokers()
{
var router = new BrokerRouter(new Uri("http://localhost:1"), _connectionFactory);
_connection
.SendAsync(Arg.Any <IRequest <MetadataResponse> >(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers());
await router.GetTopicMetadataAsync(TestTopic, CancellationToken.None);
var topics = router.GetTopicMetadata(TestTopic);
_connectionFactory.Received()
.Create(Arg.Is <Endpoint>(e => e.IP.Port == 2), Arg.Any <IConnectionConfiguration>(), Arg.Any <ILog>());
}
public async Task SelectPartitionShouldThrowWhenTopicsCollectionIsEmpty()
{
var metadataResponse = await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers();
metadataResponse.Topics.Clear();
var routerProxy = new BrokerRouterProxy();
#pragma warning disable 1998
routerProxy.Connection1.MetadataResponseFunction = async() => metadataResponse;
#pragma warning restore 1998
Assert.Throws <CachedMetadataException>(() => routerProxy.Create().GetBrokerRoute(TestTopic));
}
public async Task SelectExactPartitionShouldThrowWhenBrokerCollectionIsEmpty()
{
var metadataResponse = await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers();
metadataResponse = new MetadataResponse(topics: metadataResponse.Topics);
var routerProxy = new BrokerRouterProxy();
#pragma warning disable 1998
routerProxy.Connection1.MetadataResponseFunction = async() => metadataResponse;
#pragma warning restore 1998
var router = routerProxy.Create();
await router.GetTopicMetadataAsync(TestTopic, CancellationToken.None);
Assert.Throws <CachedMetadataException>(() => router.GetBrokerRoute(TestTopic, 1));
}
public async Task BrokerRouterUsesFactoryToAddNewBrokers()
{
var router = new BrokerRouter(new KafkaOptions
{
KafkaServerUri = new List <Uri> {
new Uri("http://localhost:1")
},
KafkaConnectionFactory = _mockKafkaConnectionFactory.Object
});
_mockKafkaConnection1.Setup(x => x.SendAsync(It.IsAny <IKafkaRequest <MetadataResponse> >()))
.Returns(() => Task.Run(async() => new List <MetadataResponse> {
await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers()
}));
await router.RefreshMissingTopicMetadata(TestTopic);
var topics = router.GetTopicMetadataFromLocalCache(TestTopic);
_mockKafkaConnectionFactory.Verify(x => x.Create(It.Is <KafkaEndpoint>(e => e.Endpoint.Port == 2), It.IsAny <TimeSpan>(), It.IsAny <IKafkaLog>(), It.IsAny <int>(), It.IsAny <TimeSpan?>(), It.IsAny <StatisticsTrackerOptions>()), Times.Once());
}
public async Task ShouldRecoverUpdateMetadataForNewTopic()
{
var routerProxy = new BrokerRouterProxy(_kernel);
routerProxy._cacheExpiration = TimeSpan.FromMilliseconds(10);
var router = routerProxy.Create();
ProtocolGateway protocolGateway = new ProtocolGateway(router);
var fetchRequest = new FetchRequest();
routerProxy.BrokerConn0.FetchResponseFunction = ShouldReturnValidMessage;
routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers;
int numberOfCall = 1000;
Task[] tasks = new Task[numberOfCall];
for (int i = 0; i < numberOfCall / 2; i++)
{
tasks[i] = protocolGateway.SendProtocolRequest(fetchRequest, BrokerRouterProxy.TestTopic, _partitionId);
}
routerProxy.BrokerConn0.MetadataResponseFunction = async() =>
{
var response = await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers();
response.Topics[0].Name = "test2";
return(response);
};
for (int i = 0; i < numberOfCall / 2; i++)
{
tasks[i + numberOfCall / 2] = protocolGateway.SendProtocolRequest(fetchRequest, "test2", _partitionId);
}
await Task.WhenAll(tasks);
Assert.That(routerProxy.BrokerConn0.FetchRequestCallCount, Is.EqualTo(numberOfCall));
Assert.That(routerProxy.BrokerConn0.MetadataRequestCallCount, Is.EqualTo(2));
}
public async Task ShouldRecoverUpdateMetadataForNewTopic()
{
var routerProxy = new BrokerRouterProxy();
routerProxy.CacheExpiration = TimeSpan.FromMilliseconds(10);
var router = routerProxy.Create();
var fetchRequest = new FetchRequest();
routerProxy.Connection1.FetchResponseFunction = ShouldReturnValidMessage;
routerProxy.Connection1.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers;
int numberOfCall = 1000;
Task[] tasks = new Task[numberOfCall];
for (int i = 0; i < numberOfCall / 2; i++)
{
tasks[i] = router.SendAsync(fetchRequest, BrokerRouterProxy.TestTopic, PartitionId, CancellationToken.None);
}
routerProxy.Connection1.MetadataResponseFunction = async() =>
{
var response = await BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers();
return(new MetadataResponse(response.Brokers, response.Topics.Select(t => new MetadataResponse.Topic("test2", t.ErrorCode, t.Partitions))));
};
for (int i = 0; i < numberOfCall / 2; i++)
{
tasks[i + numberOfCall / 2] = router.SendAsync(fetchRequest, "test2", PartitionId, CancellationToken.None);
}
await Task.WhenAll(tasks);
Assert.That(routerProxy.Connection1.FetchRequestCallCount, Is.EqualTo(numberOfCall));
Assert.That(routerProxy.Connection1.MetadataRequestCallCount, Is.EqualTo(2));
}