Esempio n. 1
0
    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)
Esempio n. 2
0
    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'])

        assert_raises(ChannelError, c.clear_synchronous_cb, 'bar')
        assert_equals(deque(['foo', 'bar']), c._pending_events)
Esempio n. 3
0
    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)
Esempio n. 4
0
  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 )
Esempio n. 5
0
 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)
Esempio n. 6
0
    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._channels[channel_id] = rval
        rval.open()
        return rval
Esempio n. 7
0
    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)
Esempio n. 8
0
    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')
        assert_equals(deque(['cb', 'frame']), c._pending_events)
Esempio n. 9
0
    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")
Esempio n. 10
0
    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)
Esempio n. 11
0
    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')
Esempio n. 12
0
  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' )
Esempio n. 13
0
    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': ''}

        assert_raises(ChannelClosed, c.send_frame, 'frame')
Esempio n. 14
0
    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')
Esempio n. 15
0
    def dispatch(self, frame):
        '''
    Override the default dispatch since we don't need the rest of the stack.
    '''
        if frame.type() == HeartbeatFrame.type():
            self.send_heartbeat()

        elif frame.type() == MethodFrame.type():
            if frame.class_id == 10:
                cb = self._method_map.get(frame.method_id)
                if cb:
                    cb(frame)
                else:
                    raise Channel.InvalidMethod(
                        "unsupported method %d on channel %d", frame.method_id,
                        self.channel_id)
            else:
                raise Channel.InvalidClass(
                    "class %d is not supported on channel %d", frame.class_id,
                    self.channel_id)

        else:
            raise Frame.InvalidFrameType(
                "frame type %d is not supported on channel %d", frame.type(),
                self.channel_id)
Esempio n. 16
0
    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)
Esempio n. 17
0
    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')
Esempio n. 18
0
 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])
     assert_equals(c.next_frame(), f0)
Esempio n. 19
0
    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.
        ch = Channel(self, channel_id, self._class_map,
                     synchronous=synchronous)
        self._channels[channel_id] = ch
        ch.add_close_listener(self._channel_closed)
        ch.open()
        return ch
Esempio n. 20
0
  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
Esempio n. 21
0
    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")
Esempio n. 22
0
    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')
Esempio n. 23
0
  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 )
Esempio n. 24
0
 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()
Esempio n. 25
0
    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:])
        assert_equals(c._frame_buffer, deque([f[i] for i in [3, 2, 0, 1]]))
Esempio n. 26
0
  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 )
Esempio n. 27
0
    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)
Esempio n. 28
0
    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'))
        assert_equals(deque([]), c._pending_events)
Esempio n. 29
0
    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]]))
Esempio n. 30
0
  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 )
Esempio n. 31
0
    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'))
        assert_equals(deque(['foo']), c._pending_events)
Esempio n. 32
0
    def test_add_synchronous_cb_when_transport_asynchronous(self):
        conn = mock()
        conn.synchronous = False
        c = Channel(conn, None, {})

        assert_equals(deque([]), c._pending_events)
        c.add_synchronous_cb('foo')
        assert_equals(deque(['foo']), c._pending_events)
Esempio n. 33
0
 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()
Esempio n. 34
0
    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)
Esempio n. 35
0
    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)
Esempio n. 36
0
    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')
Esempio n. 37
0
    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')
Esempio n. 38
0
    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)
Esempio n. 39
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()
Esempio n. 40
0
    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])
Esempio n. 41
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()
Esempio n. 42
0
    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()
        assert_equals(f1, c._frame_buffer[0])
Esempio n. 43
0
  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()
Esempio n. 44
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()
        assert_equals(deque(), c._frame_buffer)
Esempio n. 45
0
    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()
Esempio n. 46
0
    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)
Esempio n. 47
0
    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)
Esempio n. 48
0
    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()
        assert_equals(deque(['cb', f3]), c._pending_events)
Esempio n. 49
0
    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)
Esempio n. 50
0
    def test_process_frames_when_connectionclosed_on_dispatch(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(ConnectionClosed('something darkside'))
        stub(c.close)  # assert not called

        assert_raises(ConnectionClosed, c.process_frames)
Esempio n. 51
0
    def test_process_frames_when_connectionclosed_on_dispatch(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(
            ConnectionClosed('something darkside'))
        stub(c.close)  # assert not called

        assert_raises(ConnectionClosed, c.process_frames)
Esempio n. 52
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)
        assert_equals(f1, c._frame_buffer[0])
Esempio n. 53
0
    def test_process_frames_logs_and_closes_when_dispatch_error_raised_even_when_exception_on_close(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).raises(ValueError())

        assert_raises(RuntimeError, c.process_frames)
        assert_equals(f1, c._frame_buffer[0])
Esempio n. 54
0
    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])
Esempio n. 55
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])
Esempio n. 56
0
    def test_properties(self):
        connection = mock()
        connection.logger = 'logger'

        c = Channel(connection, 'id')
        c.channel = mock()
        c.channel.closed = 'closed'
        c.channel.close_info = 'uwerebad'

        assertEquals(connection, c.connection)
        assertEquals('id', c.channel_id)
        assertEquals('logger', c.logger)
        assertEquals('closed', c.closed)
        assertEquals('uwerebad', c.close_info)
Esempio n. 57
0
 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)
Esempio n. 58
0
  def test_add_synchronous_cb_when_transport_synchronous_and_channel_closes(self):
    conn = mock()
    conn.synchronous = True
    c = Channel(conn,None,{})

    wrapper = mock()
    wrapper._read = True
    wrapper._result = 'done'

    expect( channel.SyncWrapper ).args( 'foo' ).returns( wrapper )
    expect( conn.read_frames )
    expect( conn.read_frames ).side_effect(
      lambda: setattr(c, '_closed', True) )
    
    with assert_raises( ChannelClosed ):
      c.add_synchronous_cb('foo')
Esempio n. 59
0
    def test_process_frames_raises_systemexit_when_close_raises_systemexit(self):
        c = Channel(mock(), 20, {})
        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.logger.exception).args(
            'Closing on failed dispatch of frame %.255s', f0)
        expect(c.close).raises(SystemExit())

        assert_raises(SystemExit, c.process_frames)
        assert_equals(f1, c._frame_buffer[0])
Esempio n. 60
0
    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))