def test_listener_removal_on_emit():
"""Test that a listener removed during an emit is called inside the current
emit cycle.
"""
call_me = Mock()
ee = EventEmitter()
def should_remove():
ee.remove_listener('remove', call_me)
ee.on('remove', should_remove)
ee.on('remove', call_me)
ee.emit('remove')
call_me.assert_called_once()
call_me.reset_mock()
# Also test with the listeners added in the opposite order
ee = EventEmitter()
ee.on('remove', call_me)
ee.on('remove', should_remove)
ee.emit('remove')
call_me.assert_called_once()
def __init__(self):
self.oauth_client_id = "DE45CD61"
self.session = requests.Session()
self._captchaGid = -1
self.chatState = ChatState.Offline
self.event = EventEmitter()
self.session.cookies.set("Steam_Language", "english")
self.session.cookies.set("timezoneOffset", "0,0")
self.session.cookies.set("mobileClientVersion", "0 (2.1.3)")
self.session.cookies.set("mobileClient", "android")
self.jarLoaded = False
self._timers = []
self._cache = {}
self.chatFriends = {}
self._mobileHeaders = {
"X-Requested-With": "com.valvesoftware.android.steam.community",
"referer":
"https://steamcommunity.com/mobilelogin?oauth_client_id=DE45CD61&oauth_scope=read_profile%20write_profile%20read_client%20write_client",
"user-agent":
"Mozilla/5.0 (Linux; U; Android 4.1.1; en-us; Google Nexus 4 - 4.1.1 - API 16 - 768x1280 Build/JRO03S) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30",
"accept":
"text/javascript, text/html, application/xml, text/xml, */*"
}
def test_asyncio_error():
"""Test that event_emitters can handle errors when wrapping coroutines as
used with asyncio.
"""
loop = new_event_loop()
ee = EventEmitter(loop=loop)
should_call = Future(loop=loop)
@ee.on('event')
async def event_handler():
raise PyeeTestException()
@ee.on('error')
def handle_error(exc):
should_call.set_result(exc)
async def create_timeout(loop=loop):
await sleep(0.1, loop=loop)
if not should_call.done():
raise Exception('should_call timed out!')
return should_call.cancel()
timeout = create_timeout(loop=loop)
@should_call.add_done_callback
def _done(result):
assert isinstance(result, PyeeTestError)
ee.emit('event')
loop.run_until_complete(gather(should_call, timeout, loop=loop))
loop.close()
def __init__(self, host, logLevel='INFO', loop=None):
self.host = host
self.logger = CustomLogger('BfxWebsocket', logLevel=logLevel)
self.loop = loop or asyncio.get_event_loop()
self.events = EventEmitter(
scheduler=asyncio.ensure_future, loop=self.loop)
self.ws = None
def __init__(self, packet, packet_sender):
print 'Init PendingPacket'
self.ee = EventEmitter()
self._packet_sender = packet_sender
self._packet = packet
def __init__(self,fps=24):
self.emitter = EventEmitter()
self.fps = fps
self.cap = cv2.VideoCapture(0)
self.thread = threading.Thread(target=self.run)
self.thread.daemon = True
self.thread.start()
def test_properties_preserved():
"""Test that the properties of decorated functions are preserved."""
call_me = Mock()
call_me_also = Mock()
ee = EventEmitter()
@ee.on('always')
def always_event_handler():
"""An event handler."""
call_me()
@ee.once('once')
def once_event_handler():
"""Another event handler."""
call_me_also()
assert always_event_handler.__doc__ == 'An event handler.'
assert once_event_handler.__doc__ == 'Another event handler.'
always_event_handler()
call_me.assert_called_once()
once_event_handler()
call_me_also.assert_called_once()
call_me_also.reset_mock()
# Calling the event handler directly doesn't clear the handler
ee.emit('once')
call_me_also.assert_called_once()
def test_listener_removal():
"""Removing listeners removes the correct listener from an event."""
ee = EventEmitter()
# Some functions to pass to the EE
def first():
return 1
ee.on('event', first)
@ee.on('event')
def second():
return 2
@ee.on('event')
def third():
return 3
def fourth():
return 4
ee.on('event', fourth)
assert ee._events['event'] == [first, second, third, fourth]
ee.remove_listener('event', second)
assert ee._events['event'] == [first, third, fourth]
ee.remove_listener('event', first)
assert ee._events['event'] == [third, fourth]
ee.remove_all_listeners('event')
assert ee._events['event'] == []
def setup_emitters(self):
self.log.debug('Setting up emitters')
self.ee = EventEmitter()
@self._rudp_connection._sender.ee.on('timeout')
def on_timeout(data): # pylint: disable=unused-variable
self.log.debug('Node Sender Timed Out')
# self.transport.dht.remove_peer(self.guid)
@self._rudp_connection.ee.on('data')
def handle_recv(msg): # pylint: disable=unused-variable
self.log.debug('Got the whole message: %s', msg.get('payload'))
payload = msg.get('payload')
if payload[:1] == '{':
try:
payload = json.loads(msg.get('payload'))
self.transport.listener.on_raw_message(payload)
return
except Exception as e:
self.log.debug('Problem with serializing: %s', e)
else:
try:
payload = msg.get('payload').decode('hex')
self.transport.listener.on_raw_message(payload)
except Exception as e:
self.log.debug('not yet %s', e)
self.transport.listener.on_raw_message(msg.get('payload'))
async def test_asyncio_error(event_loop):
"""Test that event_emitters can handle errors when wrapping coroutines as
used with asyncio.
"""
ee = EventEmitter(loop=event_loop)
should_call = Future(loop=event_loop)
@ee.on('event')
async def event_handler():
raise PyeeTestError()
@ee.on('error')
def handle_error(exc):
assert isinstance(exc, PyeeTestError)
should_call.set_result(exc)
async def create_timeout(loop=event_loop):
await sleep(0.1, loop=event_loop)
if not should_call.done():
raise Exception('should_call timed out!')
return should_call.cancel()
timeout = create_timeout(loop=event_loop)
ee.emit('event')
result = await should_call
assert isinstance(result, PyeeTestError)
def test_listeners():
"""`listeners()` returns a copied list of listeners."""
call_me = Mock()
ee = EventEmitter()
@ee.on('event')
def event_handler():
pass
@ee.once('event')
def once_handler():
pass
listeners = ee.listeners('event')
assert listeners[0] == event_handler
assert listeners[1] == once_handler
# listeners is a copy, you can't mutate the innards this way
listeners[0] = call_me
ee.emit('event')
call_me.assert_not_called()
async def test_asyncio_emit(event_loop):
"""Test that event_emitters can handle wrapping coroutines as used with
asyncio.
"""
ee = EventEmitter(loop=event_loop)
should_call = Future(loop=event_loop)
@ee.on('event')
async def event_handler():
should_call.set_result(True)
async def create_timeout(loop=event_loop):
await sleep(0.1, loop=event_loop)
if not should_call.done():
raise Exception('should_call timed out!')
return should_call.cancel()
timeout = create_timeout(loop=event_loop)
ee.emit('event')
result = await should_call
assert result == True
def __init__(self, dbName, transactionsDbName, init=True):
"""
Constructor for a blockchain
"""
if init:
# Create genesis block
try:
temp_block = open(dbName, "rb")
temp_block = pickle.load(temp_block)
self.blocks = temp_block
except OSError as e:
self.blocks = []
self.blocks.append(Block.getGenesis())
pickle.dump(self.blocks, open(dbName, "wb"))
try:
temp_transactions = pickle.load(open(transactionsDbName, "rb"))
self.transactions = temp_transactions
except OSError as e:
self.transactions = []
pickle.dump(self.transactions, open(transactionsDbName, "wb"))
self.dbName = dbName
self.transactionsDbName = transactionsDbName
self.ee = EventEmitter()
else:
# Create a blockchain from given files
blockDb = pickle.load(open(dbName, "rb"))
transactionsDb = pickle.load(open(transactionsDbName, "rb"))
self.dbName = dbName
self.transactionsDbName = transactionsDbName
self.blocks = blockDb
self.transactions = transactionsDb
def __init__(self, packet_sender):
# TODO: have this be a DuplexStream instead of an EventEmitter.
# TODO: the Receiver should never send raw packets to the end host. It should
# only be acknowledgement packets. Please see [1]
self.ee = EventEmitter()
self.incoming_messages = {}
self._synced = False
self._next_sequence_number = 0
self._sync_sequence_number = None
self._packets = SortedList()
self._packet_sender = packet_sender
self._closed = False
self._message = ''
self._message_id = None
self._fullmessage = ''
self._message_size = 0
self._waiting = False
self.log = logging.getLogger('%s' % self.__class__.__name__)
self.log.debug('Init Receiver')
def __init__(self, packets):
self.log = logging.getLogger('%s' % self.__class__.__name__)
self.log.info('Init Window')
self.event_emitter = EventEmitter()
self._packets = packets
self._acknowledged = []
def __init__(self, topic, event_emitter=EventEmitter()):
# self.graph = facebook.GraphAPI(Config.PAGE_ACCESS_TOKEN)
logging.debug("initializing video Service!")
event_emitter.on(topic, self.act)
self.stream_url = ''
self.proc = None
logging.debug("creating cam file..")
subprocess.Popen(shlex.split("modprobe bcm2835-v4l2"),
stdout=subprocess.PIPE)
def __init__(self, packet_sender):
self.log = logging.getLogger('%s' % self.__class__.__name__)
self.log.info('Init Sender')
self._packet_sender = packet_sender
self._windows = []
self._sending = None
self._last_sent = 0
self.event_emitter = EventEmitter()
def __init__(self, packet_sender):
print 'Init Connection'
self.ee = EventEmitter()
self._sender = Sender(packet_sender)
self._receiver = Receiver(packet_sender)
@self._receiver.ee.on('data')
def on_data(data):
self.ee.emit('data', data)
def __init__(self, host, logLevel='INFO', loop=None, max_retries=5):
self.host = host
self.logger = CustomLogger('BfxWebsocket', logLevel=logLevel)
self.loop = loop or asyncio.get_event_loop()
self.events = EventEmitter(scheduler=asyncio.ensure_future,
loop=self.loop)
# overide 'error' event to stop it raising an exception
# self.events.on('error', self.on_error)
self.ws = None
self.max_retries = max_retries
self.attempt_retry = True
def test_emit_single_listener_return():
"""Get return value if single and flag set"""
ee = EventEmitter()
retvalue = "123456"
@ee.on("return_something")
def return_something(whattoreturn):
return whattoreturn
ret = ee.emit("return_something", retvalue, capture_return_value=True)
assert ret == retvalue
def getDescription(self, id):
method = 'get description'
payload = {}
payload['id'] = id
msg = self._composeDataStr(method, payload)
responseEmitter = EventEmitter()
responseEmitter.id = msg['request_id']
self._requests.append(responseEmitter)
msgStr = json.dumps(msg)
self._sendData(msgStr)
return responseEmitter
def test_emit_return():
ee = EventEmitter()
# make sure emitting without a callback returns False
nt.assert_false(ee.emit('data'))
# add a callback
ee.on('data')(lambda: None)
# should return True now
nt.assert_true(ee.emit('data'))
def test_proxy_new_listener(proxy_new_listener):
call_me = Mock()
base_ee = EventEmitter()
uplifted_ee = uplift(UpliftedEventEmitter,
base_ee,
proxy_new_listener=proxy_new_listener)
@base_ee.on('new_listener')
def base_new_listener_handler(event, f):
assert event in ('event', 'new_listener')
call_me('base new listener handler', f)
@uplifted_ee.on('new_listener')
def uplifted_new_listener_handler(event, f):
assert event in ('event', 'new_listener')
call_me('uplifted new listener handler', f)
def fresh_base_handler():
pass
def fresh_uplifted_handler():
pass
base_ee.on('event', fresh_base_handler)
uplifted_ee.on('event', fresh_uplifted_handler)
if proxy_new_listener == 'both':
call_me.assert_has_calls([
call('base new listener handler', fresh_base_handler),
call('uplifted new listener handler', fresh_base_handler),
call('uplifted new listener handler', fresh_uplifted_handler),
call('base new listener handler', fresh_uplifted_handler)
])
elif proxy_new_listener == 'neither':
call_me.assert_has_calls([
call('base new listener handler', fresh_base_handler),
call('uplifted new listener handler', fresh_uplifted_handler)
])
elif proxy_new_listener == 'forward':
call_me.assert_has_calls([
call('base new listener handler', fresh_base_handler),
call('uplifted new listener handler', fresh_base_handler),
call('uplifted new listener handler', fresh_uplifted_handler)
])
elif proxy_new_listener == 'backward':
call_me.assert_has_calls([
call('base new listener handler', fresh_base_handler),
call('uplifted new listener handler', fresh_uplifted_handler),
call('base new listener handler', fresh_uplifted_handler)
])
else:
raise Exception('unrecognized proxy_new_listener')
def __init__(self, username, password, **kwargs):
if not username:
raise UsernameMustExist('options.username must exist and may not be null')
if not password:
raise PasswordMustExist('options.password must exist and may not be null')
self.user = SelfUser(username, password)
self.ready = False
self.servers = {}
self._ws = None
self.event = EventEmitter()
self.message_cache = OrderedDict()
self.cache_size = kwargs.get('cache_size')
def __init__(self):
"""Initialize a new instance of Fireplace."""
Device.__init__(self)
self.__emitter = EventEmitter()
self.__timeoutDelay = 0
self.__timeoutDelayMillis = 0
self.__timeoutUnit = time_unit.MINUTES
self.__taskTimer = None
self.__killTimer = None
self.__state = fireplace_state.OFF
self.__emitter.on(EVENT_STATE_CHANGED,
lambda evt: self._internal_state_changed(evt))
def __init__(self, host=client_config.get("host"),
port=client_config.get("port"),
path=client_config.get("route"),
ssl=str2bool(client_config.get("ssl"))):
self.emitter = EventEmitter()
self.scheme = "wss" if ssl else "ws"
self.host = host
self.port = port
self.path = path
self.exp_backoff_counter = 1
self.client = self._create_new_connection()
self.pool = ThreadPool(10)
def getDatapoints(self):
# define request
method = 'get datapoints'
payload = {}
# compose and send
msg = self._composeDataStr(method, payload)
responseEmitter = EventEmitter()
responseEmitter.id = msg['request_id']
self._requests.append(responseEmitter)
msgStr = json.dumps(msg)
self._sendData(msgStr)
return responseEmitter
def test_emit_error():
ee = EventEmitter()
with nt.assert_raises(Exception):
ee.emit('error')
@ee.on('error')
def onError():
pass
# No longer raises and error instead return True indicating handled
nt.assert_true(ee.emit('error'))
def __init__(self, manager, shards, host=None, password=None, port=None):
self.stats = {}
self.ee = EventEmitter()
self._manager = manager
self.shards = shards
self.ready = False
self.ws = None
self.host = host
self.password = password
self.port = port
self.stats = None
self.reconnect_tries = 0
def __init__(self, packet, packet_sender):
self.loop = ioloop.IOLoop.current()
self.event_emitter = EventEmitter()
self._packet_sender = packet_sender
self._packet = packet
self._interval_id = None
self._sending = False
self._sending_count = 0
self.log = logging.getLogger('%s' % self.__class__.__name__)
self.log.info('Init PendingPacket')
