public async Task AssignorFoundWhenStrategyExists([Values("type1", "type2")] string strategy)
{
var metadata = new ConsumerProtocolMetadata("mine", strategy);
var router = Substitute.For <IRouter>();
var conn = Substitute.For <IConnection>();
router.GetConnectionAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(_ => Task.FromResult(conn));
router.SyncGroupAsync(Arg.Any <SyncGroupRequest>(), Arg.Any <IRequestContext>(), Arg.Any <IRetry>(), Arg.Any <CancellationToken>())
.Returns(_ => Task.FromResult(new SyncGroupResponse(ErrorCode.NONE, new ConsumerMemberAssignment())));
conn.SendAsync(Arg.Any <JoinGroupRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => Task.FromResult(new JoinGroupResponse(ErrorCode.NONE, 1, metadata.AssignmentStrategy, _.Arg <JoinGroupRequest>().member_id, _.Arg <JoinGroupRequest>().member_id, new [] { new JoinGroupResponse.Member(_.Arg <JoinGroupRequest>().member_id, metadata) })));
conn.SendAsync(Arg.Any <DescribeGroupsRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => Task.FromResult(new DescribeGroupsResponse(null)));
var assignor = Substitute.For <IMembershipAssignor>();
assignor.AssignmentStrategy.ReturnsForAnyArgs(_ => strategy);
var encoders = ConnectionConfiguration.Defaults.Encoders(new ConsumerEncoder(new SimpleAssignor(), assignor));
using (var m = await router.CreateGroupConsumerAsync("group", metadata, ConsumerConfiguration.Default, encoders, CancellationToken.None)) {
var member = (GroupConsumer)m;
await member.SyncGroupAsync(CancellationToken.None);
}
}
public void JoinConsumerGroupResponse(
[Values(
ErrorResponseCode.None,
ErrorResponseCode.OffsetMetadataTooLarge
)] ErrorResponseCode errorCode,
[Values(0, 1, 20000)] int generationId,
[Values("consumer")] string protocol,
[Values("test", "a groupId")] string leaderId,
[Values("", "an existing member")] string memberId,
[Values(1, 10)] int memberCount)
{
var encoder = new ConsumerEncoder();
var members = new List <JoinGroupResponse.Member>();
for (var m = 0; m < memberCount; m++)
{
var userData = new byte[memberCount * 100];
_randomizer.NextBytes(userData);
var metadata = new ConsumerProtocolMetadata(0, new [] { protocol, memberId, leaderId }, userData);
members.Add(new JoinGroupResponse.Member(memberId + m, metadata));
}
var response = new JoinGroupResponse(errorCode, generationId, protocol, leaderId, memberId, members);
response.AssertCanEncodeDecodeResponse(0, encoder);
}
public async Task AssignmentThrowsExceptionWhenStrategyNotFound()
{
var metadata = new ConsumerProtocolMetadata("mine", "unknown");
var router = Substitute.For <IRouter>();
var conn = Substitute.For <IConnection>();
router.GetConnectionAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(_ => Task.FromResult(conn));
conn.SendAsync(Arg.Any <JoinGroupRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => Task.FromResult(new JoinGroupResponse(ErrorCode.NONE, 1, metadata.AssignmentStrategy, _.Arg <JoinGroupRequest>().member_id, _.Arg <JoinGroupRequest>().member_id, new [] { new JoinGroupResponse.Member(_.Arg <JoinGroupRequest>().member_id, metadata) })));
conn.SendAsync(Arg.Any <DescribeGroupsRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => Task.FromResult(new DescribeGroupsResponse(null)));
try {
using (var m = await router.CreateGroupConsumerAsync("group", metadata, CancellationToken.None)) {
var member = (GroupConsumer)m;
await member.SyncGroupAsync(CancellationToken.None);
}
Assert.Fail("Should have thrown exception");
} catch (ArgumentOutOfRangeException ex) when(ex.Message.StartsWith($"Unknown strategy {metadata.AssignmentStrategy} for ProtocolType {ConsumerEncoder.Protocol}"))
{
// not configured here
}
}
public void JoinConsumerGroupRequest(
[Values("test", "a groupId")] string groupId,
[Values(1, 20000)] int sessionTimeout,
[Values("", "an existing member")] string memberId,
[Values("consumer")] string protocolType,
[Values(1, 10)] int protocolsPerRequest)
{
var encoder = new ConsumerEncoder();
var protocols = new List <JoinGroupRequest.GroupProtocol>();
for (var p = 0; p < protocolsPerRequest; p++)
{
var userData = new byte[protocolsPerRequest * 100];
_randomizer.NextBytes(userData);
var metadata = new ConsumerProtocolMetadata(0, new [] { groupId, memberId, protocolType }, userData);
protocols.Add(new JoinGroupRequest.GroupProtocol(protocolType + p, metadata));
}
var request = new JoinGroupRequest(groupId, TimeSpan.FromMilliseconds(sessionTimeout), memberId, protocolType, protocols);
request.AssertCanEncodeDecodeRequest(0, encoder);
}
public async Task AssigmentSucceedsWhenStrategyExists()
{
var metadata = new ConsumerProtocolMetadata("mine");
var router = Substitute.For <IRouter>();
var conn = Substitute.For <IConnection>();
router.GetConnectionAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(_ => Task.FromResult(conn));
router.SyncGroupAsync(Arg.Any <SyncGroupRequest>(), Arg.Any <IRequestContext>(), Arg.Any <IRetry>(), Arg.Any <CancellationToken>())
.Returns(_ => Task.FromResult(new SyncGroupResponse(ErrorCode.NONE, new ConsumerMemberAssignment())));
conn.SendAsync(Arg.Any <JoinGroupRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => Task.FromResult(new JoinGroupResponse(ErrorCode.NONE, 1, metadata.AssignmentStrategy, _.Arg <JoinGroupRequest>().member_id, _.Arg <JoinGroupRequest>().member_id, new [] { new JoinGroupResponse.Member(_.Arg <JoinGroupRequest>().member_id, metadata) })));
conn.SendAsync(Arg.Any <DescribeGroupsRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => Task.FromResult(new DescribeGroupsResponse(null)));
using (var m = await router.CreateGroupConsumerAsync("group", metadata, CancellationToken.None)) {
var member = (GroupConsumer)m;
await member.SyncGroupAsync(CancellationToken.None);
}
}
public void DescribeConsumerGroupsResponse(
[Values(
ErrorResponseCode.None,
ErrorResponseCode.OffsetMetadataTooLarge
)] ErrorResponseCode errorCode,
[Values("test", "a groupId")] string groupId,
[Range(2, 3)] int count,
[Values(KafkaClient.Protocol.DescribeGroupsResponse.Group.States.Stable, KafkaClient.Protocol.DescribeGroupsResponse.Group.States.AwaitingSync)] string state,
[Values("consumer")] string protocolType,
[Values("good", "bad", "ugly")] string protocol)
{
var encoder = new ConsumerEncoder();
var groups = new DescribeGroupsResponse.Group[count];
for (var g = 0; g < count; g++)
{
var members = new List <DescribeGroupsResponse.Member>();
for (var m = 0; m < count; m++)
{
var memberId = "member" + m;
var userData = new byte[count * 100];
_randomizer.NextBytes(userData);
var metadata = new ConsumerProtocolMetadata(0, new [] { protocol, memberId, memberId }, userData);
var topics = new List <TopicPartition>();
for (var t = 0; t < count; t++)
{
topics.Add(new TopicPartition("topic foo" + t, t));
}
var assignment = new ConsumerMemberAssignment(0, topics);
members.Add(new DescribeGroupsResponse.Member(memberId, "client" + m, "host-" + m, metadata, assignment));
}
groups[g] = new DescribeGroupsResponse.Group(errorCode, groupId + g, state, protocolType, protocol, members);
}
var response = new DescribeGroupsResponse(groups);
response.AssertCanEncodeDecodeResponse(0, encoder);
}
public static Task <IGroupConsumer> CreateGroupConsumerAsync(this IRouter router, string groupId, ConsumerProtocolMetadata metadata, IConsumerConfiguration configuration, IImmutableDictionary <string, IMembershipEncoder> encoders, CancellationToken cancellationToken)
{
return(router.CreateGroupConsumerAsync(groupId, ConsumerEncoder.Protocol, metadata, configuration, encoders, cancellationToken));
}
public static Task <IGroupConsumer> CreateGroupConsumerAsync(this IRouter router, string groupId, ConsumerProtocolMetadata metadata, CancellationToken cancellationToken)
{
return(router.CreateGroupConsumerAsync(groupId, ConsumerEncoder.Protocol, metadata, ConsumerConfiguration.Default, ConnectionConfiguration.Defaults.Encoders(), cancellationToken));
}
public static Task <IGroupConsumer> CreateGroupConsumerAsync(this KafkaOptions options, IRouter router, string groupId, ConsumerProtocolMetadata metadata, CancellationToken cancellationToken)
{
return(router.CreateGroupConsumerAsync(groupId, metadata, options.ConsumerConfiguration, options.Encoders, cancellationToken));
}
public static async Task <IGroupConsumer> CreateGroupConsumerAsync(this KafkaOptions options, string groupId, ConsumerProtocolMetadata metadata, CancellationToken cancellationToken)
{
var router = await options.CreateRouterAsync();
var response = await router.JoinGroupAsync(groupId, ConsumerEncoder.Protocol, new [] { metadata }, options.ConsumerConfiguration, cancellationToken);
return(new GroupConsumer(router, groupId, ConsumerEncoder.Protocol, response, options.ConsumerConfiguration, options.Encoders, false));
}
