Python eventsocket.EventSocket类代码示例

  def test_handle_error_no_handler_and_logger_and_no_err_msg(self):
    sock = EventSocket()
    sock._logger = mock()

    expect(sock._logger.error).args( 'unhandled unknown error', exc_info=True )

    sock._handle_error( 'exception' )

 def test_parent_read_timer_cb_when_read_cb_reset(self):
   sock = EventSocket()
   sock._pending_read_cb_event = 'foo'
   
   sock._parent_read_timer_cb()
   assert_equals( 'error processing socket input buffer', sock._error_msg )
   assert_equals( None, sock._pending_read_cb_event )

  def test_handle_error_with_handler_and_no_err_msg(self):
    sock = EventSocket()
    sock._parent_error_cb = mock()

    expect(sock._parent_error_cb).args( sock, 'unknown error', 'exception' )

    sock._handle_error( 'exception' )

 def test_connect_sets_default_timeout_from_socket(self):
   now = time.time()
   sock = EventSocket()
   expect( time, 'time' ).returns( now )
   sock._sock.settimeout( 8.67 )
   expect( sock._connect_cb ).args( now+8.67, ('localhost',5309), immediate_raise=True )
   sock.connect( ('localhost',5309) )

  def test_handle_error_no_handler_and_no_logger(self):
    sock = EventSocket()
    mock( eventsocket, 'traceback' )

    expect(eventsocket.traceback.print_exc)

    sock._handle_error( 'exception' )

  def test_protected_cb_when_no_error(self):
    sock = EventSocket()
    cb = mock()

    expect( cb ).args( 'arg1', 'arg2', arg3='foo' ).returns( 'result' )

    assert_equals( 'result', 
      sock._protected_cb( cb, 'arg1', 'arg2', arg3='foo' ) )

  def test_connect_sets_timeoutat_from_kwargs(self):
    now = time.time()
    sock = EventSocket()
    expect( time, 'time' ).returns( now )
    expect( sock._connect_cb ).args( now+5.3, ('localhost',5309), immediate_raise=True )
    sock.connect( ('localhost',5309), timeout=5.3 )

    expect( sock._connect_cb ).args( now+5.7, ('localhost',5309), immediate_raise=True )
    sock.connect( ('localhost',5309), timeout_at=now+5.7 )

 def test_set_inactive_timeout_when_turning_off(self):
   sock = EventSocket()
   sock._inactive_event = mock()
   
   expect( sock._inactive_event.delete )
   
   sock.set_inactive_timeout(0)
   assert_equals( None, sock._inactive_event )
   assert_equals( 0, sock._inactive_timeout )

  def test_parent_read_timer_cb(self):
    sock = EventSocket()
    sock._pending_read_cb_event = 'foo'
    sock._parent_read_cb = mock()
    expect( sock._parent_read_cb ).args( sock )

    sock._parent_read_timer_cb()
    assert_equals( 'error processing socket input buffer', sock._error_msg )
    assert_equals( None, sock._pending_read_cb_event )

  def test_connect_cb_when_fail_and_not_immediateraise(self):
    sock = EventSocket()
    mock( sock, '_sock' )
    mock( sock, '_connect_event' )
    
    expect( sock._sock.connect_ex ).args( ('.com', 1234) ).returns( errno.ECONNREFUSED )
    expect( sock._connect_event.delete )
    expect( sock._handle_error ).args( socket.error )

    sock._connect_cb( time.time(), ('.com',1234) )

  def test_connect_cb_when_ealready_and_timeout(self):
    sock = EventSocket()
    mock( sock, '_sock' )
    mock( sock, '_connect_event' ) # assert delete() not called

    timeout_at = time.time()-3
    expect( sock._sock.connect_ex ).args( ('.com', 1234) ).returns( errno.EALREADY )
    expect( sock.close )

    sock._connect_cb( timeout_at, ('.com',1234) )

  def test_connect_cb_when_einprogress_and_notimeout_and_no_pending_connect(self):
    sock = EventSocket()
    mock( sock, '_sock' )
    
    timeout_at = time.time()+3
    expect( sock._sock.connect_ex ).args( ('.com', 1234) ).returns( errno.EINPROGRESS )
    expect( eventsocket.event.timeout ).args( 0.1, sock._connect_cb, timeout_at, ('.com', 1234) ).returns( 'connectev' )

    sock._connect_cb( timeout_at, ('.com',1234) )
    assert_equals( 'connectev', sock._connect_event )

  def test_flag_activity(self):
    sock = EventSocket()
    sock._inactive_event = mock()
    sock._inactive_timeout = 42
    
    expect( sock._inactive_event.delete )
    expect( eventsocket.event.timeout ).args( 42, sock._protected_cb, sock._inactive_cb ).returns( 'doitagain' )

    sock._flag_activity()
    assert_equals( 'doitagain', sock._inactive_event )

  def test_write_when_write_event_and_not_pending(self):
    sock = EventSocket()
    sock._write_event = mock()
    
    expect( sock._write_event.pending ).returns( False )
    expect( sock._write_event.add )
    expect( sock._flag_activity )

    sock.write( 'foo' )
    assert_equals( deque(['foo']), sock._write_buf )

  def test_bind_without_debugging(self):
    sock = EventSocket()
    sock._sock = mock()
    mock(sock, 'getsockname')
    
    expect(sock._sock.bind).args( 'arg1', 'arg2' )
    expect(sock.getsockname).returns( ('foo',1234) )
    expect(eventsocket.event.read).args( sock, sock._protected_cb, sock._accept_cb )

    sock.bind( 'arg1', 'arg2' )