def test_properties(self): connection = mock() connection.logger = 'logger' connection.synchronous = False c = Channel(connection, 'id', {}) c._closed = 'yes' c._close_info = 'ithappened' c._active = 'record' assert_equals(connection, c.connection) assert_equals('id', c.channel_id) assert_equals('logger', c.logger) assert_equals('yes', c.closed) assert_equals('ithappened', c.close_info) assert_equals('record', c.active) assert_false(c.synchronous) c._closed = False assert_equals(None, c.close_info) connection.synchronous = False c = Channel(connection, 'id', {}, synchronous=True) assert_true(c.synchronous) connection.synchronous = True c = Channel(connection, 'id', {}) assert_true(c.synchronous) connection.synchronous = True c = Channel(connection, 'id', {}, synchronous=False) assert_true(c.synchronous)
def test_init(self): connection = mock() c = Channel(connection, 'id', self._CLASS_MAP) assert_equals(connection, c._connection) assert_equals('id', c._channel_id) assert_true(isinstance(c.channel, ChannelClass)) assert_true(isinstance(c.exchange, ExchangeClass)) assert_true(isinstance(c.queue, QueueClass)) assert_true(isinstance(c.basic, BasicClass)) assert_true(isinstance(c.tx, TransactionClass)) assert_false(c._synchronous) assert_equals(c._class_map[20], c.channel) assert_equals(c._class_map[40], c.exchange) assert_equals(c._class_map[50], c.queue) assert_equals(c._class_map[60], c.basic) assert_equals(c._class_map[90], c.tx) assert_equals(deque([]), c._pending_events) assert_equals(deque([]), c._frame_buffer) assert_equals(set([]), c._open_listeners) assert_equals(set([]), c._close_listeners) assert_false(c._closed) assert_equals( { 'reply_code': 0, 'reply_text': 'first connect', 'class_id': 0, 'method_id': 0 }, c._close_info) assert_true(c._active) c = Channel(connection, 'id', self._CLASS_MAP, synchronous=True) assert_true(c._synchronous)
def test_clear_synchronous_cb_when_pending_cb_doesnt_match_but_isnt_in_list(self): c = Channel(None,None,{}) stub( c._flush_pending_events ) c._pending_events = deque(['foo', 'bar']) assertRaises( ChannelError, c.clear_synchronous_cb, 'bar' ) assertEquals( deque(['foo','bar']), c._pending_events )
def test_closed_cb_without_final_frame(self): c = Channel( 'connection', None, { 20: ChannelClass, 40: ExchangeClass, 50: QueueClass, 60: BasicClass, 90: TransactionClass, }) c._pending_events = 'foo' c._frame_buffer = 'foo' for val in c._class_map.values(): expect(val._cleanup) expect(c._notify_close_listeners) c._closed_cb() assert_equals(deque([]), c._pending_events) assert_equals(deque([]), c._frame_buffer) assert_equals(None, c._connection) assert_false(hasattr(c, 'channel')) assert_false(hasattr(c, 'exchange')) assert_false(hasattr(c, 'queue')) assert_false(hasattr(c, 'basic')) assert_false(hasattr(c, 'tx')) assert_equals(None, c._class_map) assert_equals(set(), c._close_listeners)
def test_send_frame_when_not_closed_no_flow_control_no_pending_events(self): conn = mock() c = Channel(conn, 32, {}) expect( conn.send_frame ).args('frame') c.send_frame( 'frame' )
def channel(self, channel_id=None, synchronous=False): """ Fetch a Channel object identified by the numeric channel_id, or create that object if it doesn't already exist. If channel_id is not None but no channel exists for that id, will raise InvalidChannel. If there are already too many channels open, will raise TooManyChannels. If synchronous=True, then the channel will act synchronous in all cases where a protocol method supports `nowait=False`, or where there is an implied callback in the protocol. """ if channel_id is None: # adjust for channel 0 if len(self._channels) - 1 >= self._channel_max: raise Connection.TooManyChannels( "%d channels already open, max %d", len(self._channels) - 1, self._channel_max) channel_id = self._next_channel_id() while channel_id in self._channels: channel_id = self._next_channel_id() elif channel_id in self._channels: return self._channels[channel_id] else: raise Connection.InvalidChannel( "%s is not a valid channel id", channel_id) # Call open() here so that ConnectionChannel doesn't have it called. # Could also solve this other ways, but it's a HACK regardless. rval = Channel( self, channel_id, self._class_map, synchronous=synchronous) self._channels[channel_id] = rval rval.add_close_listener(self._channel_closed) rval.open() return rval
def test_process_frames_drops_non_close_methods_when_emergency_closing( self): c = Channel(mock(), None, self._CLASS_MAP) c._emergency_close_pending = True c._connection = mock() c._connection.logger = mock() f0 = MethodFrame(1, 30, 40) f1 = HeaderFrame(1, 30, 0, 0) f2 = ContentFrame(1, "payload") f3_basic_close = MethodFrame(1, 20, 40) f4_basic_close_ok = MethodFrame(1, 20, 41) f5 = MethodFrame(1, 90, 11) c._frame_buffer = deque( [f0, f1, f2, f3_basic_close, f4_basic_close_ok, f5]) expect(c.dispatch).args(f0).times(0) expect(c.dispatch).args(f1).times(0) expect(c.dispatch).args(f2).times(0) expect(c.dispatch).args(f3_basic_close).times(1) expect(c.dispatch).args(f4_basic_close_ok).times(1) expect(c.dispatch).args(f5).times(0) expect(c.logger.warn).times(4) c.process_frames() assert_equals(0, len(c._frame_buffer))
def test_process_frames_passes_through_exception_from_close_listener(self): class MyError(Exception): pass connection = mock() ch = Channel(connection, channel_id=1, class_map={20: ChannelClass}) rframe = mock(channel_id=ch.channel_id, class_id=20, method_id=40) ch._frame_buffer = deque([rframe]) on_channel_closed = mock() ch.add_close_listener(on_channel_closed) expect(rframe.args.read_short).returns('rcode') expect(rframe.args.read_shortstr).returns('reason') expect(rframe.args.read_short).returns('cid') expect(rframe.args.read_short).returns('mid') expect(connection.send_frame).once() expect(on_channel_closed).args(ch).raises(MyError) expect(ch.logger.exception).args( 'Closing on failed dispatch of frame %.255s', rframe) with assert_raises(MyError): ch.process_frames()
def test_init(self): c = Channel( 'connection', 'id', { 20: ChannelClass, 40: ExchangeClass, 50: QueueClass, 60: BasicClass, 90: TransactionClass, }) self.assertEquals('connection', c._connection) self.assertEquals('id', c._channel_id) self.assertTrue(isinstance(c.channel, ChannelClass)) self.assertTrue(isinstance(c.exchange, ExchangeClass)) self.assertTrue(isinstance(c.queue, QueueClass)) self.assertTrue(isinstance(c.basic, BasicClass)) self.assertTrue(isinstance(c.tx, TransactionClass)) self.assertEquals(c._class_map[20], c.channel) self.assertEquals(c._class_map[40], c.exchange) self.assertEquals(c._class_map[50], c.queue) self.assertEquals(c._class_map[60], c.basic) self.assertEquals(c._class_map[90], c.tx) self.assertEquals(deque([]), c._pending_events) self.assertEquals(deque([]), c._frame_buffer) assert_equals(set([]), c._open_listeners) assert_equals(set([]), c._close_listeners) assert_false(c._closed) assert_equals( { 'reply_code': 0, 'reply_text': 'first connect', 'class_id': 0, 'method_id': 0 }, c._close_info) assert_true(c._active)
def test_send_frame_when_closed_for_no_reason(self): conn = mock() c = Channel(conn, 32, {}) c._closed = True c._close_info = {'reply_code': 42, 'reply_text': ''} assertRaises(ChannelClosed, c.send_frame, 'frame')
def test_next_frame_with_a_frame(self): c = Channel(None, None, {}) ch_id, c_id, m_id = 0, 1, 2 f0 = MethodFrame(ch_id, c_id, m_id) f1 = MethodFrame(ch_id, c_id, m_id) c._frame_buffer = deque([f0, f1]) assertEquals(c.next_frame(), f0)
def channel(self, channel_id=None): """ Fetch a Channel object identified by the numeric channel_id, or create that object if it doesn't already exist. If channel_id is not None but no channel exists for that id, will raise InvalidChannel. If there are already too many channels open, will raise TooManyChannels. """ if channel_id is None: # adjust for channel 0 if len(self._channels) - 1 >= self._channel_max: raise Connection.TooManyChannels( "%d channels already open, max %d", len(self._channels) - 1, self._channel_max) channel_id = self._next_channel_id() while channel_id in self._channels: channel_id = self._next_channel_id() elif channel_id in self._channels: return self._channels[channel_id] else: raise Connection.InvalidChannel("%s is not a valid channel id", channel_id) # Call open() here so that ConnectionChannel doesn't have it called. Could # also solve this other ways, but it's a HACK regardless. rval = Channel(self, channel_id, self._class_map) self._channels[channel_id] = rval rval.add_close_listener(self._channel_closed) rval.open() return rval
def test_send_frame_when_not_closed_no_flow_control_pending_event(self): conn = mock() c = Channel(conn, 32, {}) c._pending_events.append('cb') c.send_frame('frame') self.assertEquals(deque(['cb', 'frame']), c._pending_events)
def test_publish_synchronous(self): c = Channel(None, None, {}) expect(mock(c, 'tx').select) expect(mock(c, 'basic').publish).args('arg1', 'arg2', foo='bar') expect(c.tx.commit).args(cb='a_cb') c.publish_synchronous('arg1', 'arg2', foo='bar', cb='a_cb')
def test_close_with_args(self): c = Channel(None, None, {}) expect(mock(c, 'channel').close).args(1, 'two', 3, 4) expect(c.channel.close).args(1, 'two', 3, 4) c.close(1, 'two', 3, 4) c.close(reply_code=1, reply_text='two', class_id=3, method_id=4)
def test_clear_synchronous_cb_when_pending_cb_doesnt_match_but_isnt_in_list(self): c = Channel(None,None,{}) c._pending_events = deque(['foo']) expect( c._flush_pending_events ) assert_equals( 'bar', c.clear_synchronous_cb('bar') ) assertEquals( deque(['foo']), c._pending_events )
def test_clear_synchronous_cb_when_pending_cb_matches(self): c = Channel(None, None) c._pending_events = ['foo'] expect(c._flush_pending_events) c.clear_synchronous_cb('foo') assertEquals([], c._pending_events)
def test_clear_synchronous_cb_when_pending_cb_matches(self): c = Channel(None, None, {}) c._pending_events = deque(['foo']) expect(c._flush_pending_events) assert_equals('foo', c.clear_synchronous_cb('foo')) assertEquals(deque([]), c._pending_events)
def test_add_synchronous_cb_when_transport_asynchronous(self): conn = mock() conn.synchronous = False c = Channel(conn, None, {}) assertEquals(deque([]), c._pending_events) c.add_synchronous_cb('foo') assertEquals(deque(['foo']), c._pending_events)
def test_notify_close_listeners(self): c = Channel(None, None, {}) cb1 = mock() cb2 = mock() c._close_listeners = set([cb1, cb2]) expect(cb1).args(c) expect(cb2).args(c) c._notify_close_listeners()
def test_requeue_frames(self): c = Channel(None, None, {}) ch_id, c_id, m_id = 0, 1, 2 f = [MethodFrame(ch_id, c_id, m_id) for i in xrange(4)] c._frame_buffer = deque(f[:2]) c.requeue_frames(f[2:]) assertEquals(c._frame_buffer, deque([f[i] for i in [3, 2, 0, 1]]))
def test_clear_synchronous_cb_when_pending_cb_doesnt_match_but_isnt_in_list( self): c = Channel(None, None) c._pending_events = ['foo'] expect(c._flush_pending_events) c.clear_synchronous_cb('bar') assertEquals(['foo'], c._pending_events)
def test_closed_cb_with_final_frame(self): conn = mock() c = Channel(conn, None, {}) expect(conn.send_frame).args('final') for val in c._class_map.values(): expect(val._cleanup) c._closed_cb('final')
def test_process_frames_stops_when_frameunderflow_raised(self): c = Channel(None, None, {}) f0 = MethodFrame('ch_id', 'c_id', 'm_id') f1 = MethodFrame('ch_id', 'c_id', 'm_id') c._frame_buffer = deque([f0, f1]) expect(c.dispatch).args(f0).raises(ProtocolClass.FrameUnderflow) c.process_frames() assertEquals(f1, c._frame_buffer[0])
def test_process_frames_stops_when_buffer_is_empty(self): c = Channel(None, None) f0 = MethodFrame('ch_id', 'c_id', 'm_id') f1 = MethodFrame('ch_id', 'c_id', 'm_id') c._frame_buffer = deque([f0, f1]) expect(c.dispatch).args(f0) expect(c.dispatch).args(f1) c.process_frames()
def test_process_frames_with_one_frame(self): conn = mock() conn.logger = mock() c = Channel(conn, None) ch_id, c_id, m_id = 0, 20, 2 f = MethodFrame(ch_id, c_id, m_id) c._frame_buffer = deque([f]) expect(c.logger.error).args(ignore(), ignore(), exc_info=ignore()) expect(c.close).args(ignore(), ignore()) c.process_frames()
def test_dispatch(self): c = Channel(None, None, {}) frame = mock() frame.class_id = 32 klass = mock() c._class_map[32] = klass expect(klass.dispatch).args(frame) c.dispatch(frame) frame.class_id = 33 assert_raises(Channel.InvalidClass, c.dispatch, frame)
def test_flush_pending_events_flushes_all_leading_frames(self): conn = mock() c = Channel(conn, 42, {}) f1 = MethodFrame(1, 2, 3) f2 = MethodFrame(1, 2, 3) f3 = MethodFrame(1, 2, 3) c._pending_events = deque([f1, f2, 'cb', f3]) expect(conn.send_frame).args(f1) expect(conn.send_frame).args(f2) c._flush_pending_events() assertEquals(deque(['cb', f3]), c._pending_events)
def test_process_frames_logs_and_closes_when_dispatch_error_raised(self): c = Channel(None, None, {}) c._connection = mock() c._connection.logger = mock() f0 = MethodFrame(20, 30, 40) f1 = MethodFrame('ch_id', 'c_id', 'm_id') c._frame_buffer = deque([f0, f1]) expect(c.dispatch).args(f0).raises(RuntimeError("zomg it broked")) expect(c.close).args(500, 'Failed to dispatch %s' % (str(f0))) assert_raises(RuntimeError, c.process_frames) assertEquals(f1, c._frame_buffer[0])
def test_process_frames_logs_and_closes_when_systemexit_raised(self): c = Channel(None, None, {}) c._connection = mock() c._connection.logger = mock() f0 = MethodFrame(20, 30, 40) f1 = MethodFrame('ch_id', 'c_id', 'm_id') c._frame_buffer = deque([f0, f1]) expect(c.dispatch).args(f0).raises(SystemExit()) stub(c.close) assert_raises(SystemExit, c.process_frames) assertEquals(f1, c._frame_buffer[0])