def test_closeNotConnected(self): reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_closeNotConnected', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. d = c.close() self.assertIsInstance(d, Deferred)
def test_close_disconnected(self): reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_close', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. c.connector.state = 'disconnected' # set connector's state for test dd = c.close() self.assertIsInstance(dd, Deferred) r = self.successResultOf(dd) self.assertIs(r, None)
def test_connectNotify(self): from afkak.protocol import KafkaProtocol reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_connectNotify', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. proto = c.buildProtocol(None) self.assertIsInstance(proto, KafkaProtocol) reactor.advance(1.0) self.assertEqual([], reactor.getDelayedCalls())
def test_disconnect(self): reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_close', 9092, 'clientId') c._connect() # Force a connection attempt conn = c.connector conn.factory = c # MemoryReactor doesn't make this connection. conn.state = 'connected' # set the connector to connected state self.assertIs(conn._disconnected, False) c.disconnect() self.assertIs(conn._disconnected, True)
def test_closeNotifyDuringConnect(self): reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_closeNotify', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. reactor.advance(1.0) self.assertEqual([], reactor.getDelayedCalls()) c.close() c.clientConnectionFailed(c.connector, Failure(UserError())) reactor.advance(1.0) self.assertEqual([], reactor.getDelayedCalls())
def test_connected(self): reactor = MemoryReactorClock() reactor.running = True c = KafkaBrokerClient(reactor, 'test_connect', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. self.assertFalse(c.connected()) # Build the protocol, like a real connector would c.buildProtocol(None) self.assertTrue(c.connected()) reactor.advance(1.0) # Trigger the DelayedCall to _notify
def test_connect(self): reactor = MemoryReactorClock() reactor.running = True c = KafkaBrokerClient(reactor, 'kafka.example.com', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. # Build the protocol, like a real connector would addr = IPv4Address('TCP', '1.2.3.4', 9092) c.buildProtocol(addr) self.assertEqual(("<KafkaBrokerClient kafka.example.com:9092 " "clientId='clientId' connected>"), repr(c))
def test_closeNotify(self): from twisted.internet.error import ConnectionDone reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_closeNotify', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. c.buildProtocol(None) reactor.advance(1.0) self.assertEqual([], reactor.getDelayedCalls()) c.continueTrying = False c.close() c.clientConnectionLost(c.connector, Failure(ConnectionDone())) reactor.advance(1.0) self.assertEqual([], reactor.getDelayedCalls())
def test_close(self): reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_close', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. c.connector.state = 'connected' # set the connector to connected state dd = c.close() self.assertIsInstance(dd, Deferred) self.assertNoResult(dd) f = Failure(ConnectionDone('test_close')) c.clientConnectionLost(c.connector, f) self.assertNoResult(dd) # Advance the clock so the notify() call fires reactor.advance(0.1) r = self.successResultOf(dd) self.assertIs(r, None)
def test_cancelRequestNoReply(self): id2 = 87654 reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_connect', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. # Fake a protocol c.proto = Mock() # now call with 'expectReply=False' c.proto = Mock() request = KafkaCodec.encode_fetch_request(b'testcancelRequest2', id2) d2 = c.makeRequest(id2, request, expectResponse=False) self.assertIsInstance(d2, Deferred) c.proto.sendString.assert_called_once_with(request) # This one we cancel by ID. It should fail due to the # expectResponse=False, since we don't keep the requestID after send self.assertRaises(KeyError, c.cancelRequest, id2)
def test_connectFailNotify(self, ccf): """ Check that if the connection fails to come up that the brokerclient errback's the deferred returned from the '_connect' call. """ reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_connectFailNotify', 9092, 'clientId') # attempt connection c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. conn = c.connector # Claim the connection failed e = ConnectionRefusedError() conn.connectionFailed(e) # Check that the brokerclient called super to reconnect ccf.assert_called_once_with(c, conn, e)
def test_cancelRequest(self): errBackCalled = [False] def _handleCancelErrback(reason): log.debug("_handleCancelErrback: %r", reason) reason.trap(CancelledError) errBackCalled[0] = True id1 = 65432 reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_connect', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. # Fake a protocol c.proto = Mock() request = KafkaCodec.encode_fetch_request(b'testcancelRequest', id1) d = c.makeRequest(id1, request) self.assertIsInstance(d, Deferred) d.addErrback(_handleCancelErrback) c.proto.sendString.assert_called_once_with(request) # Now try to cancel the request d.cancel() self.assertTrue(errBackCalled[0])
def test_delay_reset(self): """ Test that reconnect delay is handled correctly: 1) That initializer values are respected 2) That delay maximum is respected 3) That delay is reset to initial delay on successful connection """ init_delay = last_delay = 0.025 max_delay = 14 reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_delay_reset', 9092, 'clientId', initDelay=init_delay, maxDelay=max_delay) c.jitter = 0 # Eliminate randomness for test # Ensure KBC was initialized correctly self.assertEqual(c.retries, 0) self.assertEqual(c.delay, init_delay) self.assertEqual(c.maxDelay, max_delay) self.assertTrue(c.continueTrying) c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. self.assertTrue(c.connector.connectCalled) # Reset it so we can track future calls c.connector.connectCalled = False # Build the protocol, like a real connector would on successful connect c.buildProtocol(None) # Fake server connection close f = Failure(ConnectionDone('test_delay_reset')) c.clientConnectionLost(c.connector, f) # Now loop failing connection attempts until we get to the max while c.delay < max_delay: # Assert a reconnect wasn't immediately attempted self.assertFalse(c.connector.connectCalled) # Assert the new delay was calculated correctly self.assertEqual(last_delay * c.factor, c.delay) last_delay = c.delay # advance the reactor, but not enough to connect reactor.advance(0.1 * c.delay) # Still no connection self.assertFalse(c.connector.connectCalled) # Should see a connection attempt after this reactor.advance(c.delay) self.assertTrue(c.connector.connectCalled) c.connector.connectCalled = False # Reset again # Claim the connection failed e = ConnectionRefusedError() c.connector.connectionFailed(e) # Assert the delay was calculated correctly self.assertEqual(max_delay, c.delay) self.assertFalse(c.connector.connectCalled) # "run" the reactor, but not enough to connect reactor.advance(0.1 * c.delay) # Still no connection self.assertFalse(c.connector.connectCalled) # Should see a connection attempt after this reactor.advance(c.delay) self.assertTrue(c.connector.connectCalled) # Build the protocol, like a real connector would on successful connect c.buildProtocol(None) # Assert that the delay and retry count were reset self.assertEqual(init_delay, c.delay) self.assertEqual(c.retries, 0)
def test_connectTwice(self): reactor = MemoryReactorClock() c = KafkaBrokerClient(reactor, 'test_connectTwice', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. self.assertRaises(ClientError, c._connect)