def test_failed_group_join(self):
client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts)
subscription = SubscriptionState('latest')
subscription.subscribe(topics=('topic1', ))
coordinator = GroupCoordinator(client,
subscription,
loop=self.loop,
retry_backoff_ms=10)
@asyncio.coroutine
def do_rebalance():
rebalance = CoordinatorGroupRebalance(
coordinator,
coordinator.group_id,
coordinator.coordinator_id,
subscription.subscription,
coordinator._assignors,
coordinator._session_timeout_ms,
coordinator._retry_backoff_ms,
loop=self.loop)
yield from rebalance.perform_group_join()
yield from client.bootstrap()
yield from self.wait_topic(client, 'topic1')
mocked = mock.MagicMock()
coordinator._client = mocked
# no exception expected, just wait
mocked.send.side_effect = Errors.GroupLoadInProgressError()
yield from do_rebalance()
self.assertEqual(coordinator.need_rejoin(), True)
mocked.send.side_effect = Errors.InvalidGroupIdError()
with self.assertRaises(Errors.InvalidGroupIdError):
yield from do_rebalance()
self.assertEqual(coordinator.need_rejoin(), True)
# no exception expected, member_id should be reseted
coordinator.member_id = 'some_invalid_member_id'
mocked.send.side_effect = Errors.UnknownMemberIdError()
yield from do_rebalance()
self.assertEqual(coordinator.need_rejoin(), True)
self.assertEqual(coordinator.member_id,
JoinGroupRequest.UNKNOWN_MEMBER_ID)
# no exception expected, coordinator_id should be reseted
coordinator.coordinator_id = 'some_id'
mocked.send.side_effect = Errors.GroupCoordinatorNotAvailableError()
yield from do_rebalance()
self.assertEqual(coordinator.need_rejoin(), True)
self.assertEqual(coordinator.coordinator_id, None)
yield from client.close()
def test_failed_sync_group(self):
client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts)
subscription = SubscriptionState('latest')
subscription.subscribe(topics=('topic1', ))
coordinator = GroupCoordinator(client,
subscription,
loop=self.loop,
heartbeat_interval_ms=20000)
@asyncio.coroutine
def do_sync_group():
rebalance = CoordinatorGroupRebalance(
coordinator,
coordinator.group_id,
coordinator.coordinator_id,
subscription.subscription,
coordinator._assignors,
coordinator._session_timeout_ms,
coordinator._retry_backoff_ms,
loop=self.loop)
yield from rebalance._on_join_follower()
with self.assertRaises(GroupCoordinatorNotAvailableError):
yield from do_sync_group()
mocked = mock.MagicMock()
coordinator._client = mocked
coordinator.member_id = 'some_invalid_member_id'
coordinator.coordinator_unknown = asyncio.coroutine(lambda: False)
mocked.send.side_effect = Errors.UnknownMemberIdError()
with self.assertRaises(Errors.UnknownMemberIdError):
yield from do_sync_group()
self.assertEqual(coordinator.member_id,
JoinGroupRequest.UNKNOWN_MEMBER_ID)
mocked.send.side_effect = Errors.NotCoordinatorForGroupError()
coordinator.coordinator_id = 'some_id'
with self.assertRaises(Errors.NotCoordinatorForGroupError):
yield from do_sync_group()
self.assertEqual(coordinator.coordinator_id, None)
mocked.send.side_effect = KafkaError()
with self.assertRaises(KafkaError):
yield from do_sync_group()
# client sends LeaveGroupRequest to group coordinator
# if generation > 0 (means that client is a member of group)
# expecting no exception in this case (error should be ignored in close
# method)
coordinator.generation = 33
yield from coordinator.close()
coordinator._client.poll.reset_mock()
coordinator._send_offset_commit_request.side_effect = [
Future().failure(Errors.RequestTimedOutError),
Future().success('fizzbuzz')]
ret = coordinator.commit_offsets_sync(offsets)
assert ret == 'fizzbuzz'
assert coordinator._client.poll.call_count == 2 # call + retry
@pytest.mark.parametrize(
'api_version,enable,error,task_disable,commit_offsets,warn,exc', [
((0, 8), True, None, False, False, False, False),
((0, 9), False, None, False, False, False, False),
((0, 9), True, Errors.UnknownMemberIdError(), True, True, True, False),
((0, 9), True, Errors.IllegalGenerationError(), True, True, True, False),
((0, 9), True, Errors.RebalanceInProgressError(), True, True, True, False),
((0, 9), True, Exception(), True, True, False, True),
((0, 9), True, None, True, True, False, False),
])
def test_maybe_auto_commit_offsets_sync(mocker, coordinator,
api_version, enable, error, task_disable,
commit_offsets, warn, exc):
auto_commit_task = mocker.patch.object(coordinator, '_auto_commit_task')
commit_sync = mocker.patch.object(coordinator, 'commit_offsets_sync',
side_effect=error)
mock_warn = mocker.patch('kafka.coordinator.consumer.log.warning')
mock_exc = mocker.patch('kafka.coordinator.consumer.log.exception')
coordinator.config['api_version'] = api_version
def mock_commit_offsets(*args, **kwargs):
raise Errors.UnknownMemberIdError()