class TestWeakMethodSlot(object):
def setup_method(self, method):
class MyObject(object):
def __init__(self):
self.called = False
def slot(self, **kwargs):
self.called = True
self.obj_ref = MyObject()
self.slot = Slot(self.obj_ref.slot, weak=True)
self.signal = Signal()
self.signal.connect(self.slot)
def test_alive(self):
assert self.slot.is_alive
def test_call(self):
self.signal.emit(testing=1234)
assert self.obj_ref.called
def test_gc(self):
self.obj_ref = None
assert not self.slot.is_alive
self.signal.emit(testing=1234)
class TestWeakMethodSlot(object):
def setup_method(self, method):
class MyObject(object):
def __init__(self):
self.called = False
def slot(self, **kwargs):
self.called = True
self.obj_ref = MyObject()
self.slot = Slot(self.obj_ref.slot, weak=True)
self.signal = Signal()
self.signal.connect(self.slot)
def test_alive(self):
assert self.slot.is_alive
def test_call(self):
self.signal.emit(testing=1234)
assert self.obj_ref.called
def test_gc(self):
self.obj_ref = None
assert not self.slot.is_alive
self.signal.emit(testing=1234)
class TestSignalConnect(object):
def setup_method(self, method):
self.signal = Signal()
def test_connect_with_kwargs(self):
def cb(**kwargs):
pass
self.signal.connect(cb)
def test_connect_without_kwargs(self):
def cb():
pass
with pytest.raises(SlotMustAcceptKeywords):
self.signal.connect(cb)
class TestSignalConnect(object):
def setup_method(self, method):
self.signal = Signal()
def test_connect_with_kwargs(self):
def cb(**kwargs):
pass
self.signal.connect(cb)
def test_connect_without_kwargs(self):
def cb():
pass
with pytest.raises(SlotMustAcceptKeywords):
self.signal.connect(cb)
class TestException(object):
def setup_method(self, method):
self.signal = Signal(threadsafe=False)
self.seen_exception = False
def failing_slot(**args):
raise MyTestError('die!')
self.signal.connect(failing_slot)
def test_emit_exception(self):
try:
self.signal.emit()
except MyTestError:
self.seen_exception = True
assert self.seen_exception
class TestException(object):
def setup_method(self, method):
self.signal = Signal(threadsafe=False)
self.seen_exception = False
def failing_slot(**args):
raise MyTestError('die!')
self.signal.connect(failing_slot)
def test_emit_exception(self):
try:
self.signal.emit()
except MyTestError:
self.seen_exception = True
assert self.seen_exception
def test_semaphore(self, inspect):
slot = mock.Mock()
slot.side_effect = lambda **k: time.sleep(.3)
signal = Signal('tost')
signal.connect(slot)
x = Task.get_or_create(signal, dict(some_kwarg='foo'))
y = Task.get_or_create(signal, dict(some_kwarg='foo'))
eventlet.spawn(x)
time.sleep(.1)
eventlet.spawn(y)
time.sleep(.1)
assert slot.call_count == 1
time.sleep(.4)
assert slot.call_count == 2
def test_semaphore(self, inspect):
slot = mock.Mock()
slot.side_effect = lambda **k: time.sleep(.3)
signal = Signal('tost')
signal.connect(slot)
x = Task.get_or_create(signal, dict(some_kwarg='foo'))
y = Task.get_or_create(signal, dict(some_kwarg='foo'))
eventlet.spawn(x)
time.sleep(.1)
eventlet.spawn(y)
time.sleep(.1)
assert slot.call_count == 1
time.sleep(.4)
assert slot.call_count == 2
class TestSignal(object):
def setup_method(self, method):
self.signal_a = Signal(threadsafe=True)
self.signal_b = Signal(args=['foo'])
self.slot_a = mock.Mock(spec=lambda **kwargs: None)
self.slot_a.return_value = None
self.slot_b = mock.Mock(spec=lambda **kwargs: None)
self.slot_b.return_value = None
def test_is_connected(self, inspect):
self.signal_a.connect(self.slot_a)
assert self.signal_a.is_connected(self.slot_a)
assert not self.signal_a.is_connected(self.slot_b)
assert not self.signal_b.is_connected(self.slot_a)
assert not self.signal_b.is_connected(self.slot_b)
def test_emit_one_slot(self, inspect):
self.signal_a.connect(self.slot_a)
self.signal_a.emit()
self.slot_a.assert_called_once_with()
assert self.slot_b.call_count == 0
def test_emit_two_slots(self, inspect):
self.signal_a.connect(self.slot_a)
self.signal_a.connect(self.slot_b)
self.signal_a.emit()
self.slot_a.assert_called_once_with()
self.slot_b.assert_called_once_with()
def test_emit_one_slot_with_arguments(self, inspect):
self.signal_b.connect(self.slot_a)
self.signal_b.emit(foo='bar')
self.slot_a.assert_called_once_with(foo='bar')
assert self.slot_b.call_count == 0
def test_emit_two_slots_with_arguments(self, inspect):
self.signal_b.connect(self.slot_a)
self.signal_b.connect(self.slot_b)
self.signal_b.emit(foo='bar')
self.slot_a.assert_called_once_with(foo='bar')
self.slot_b.assert_called_once_with(foo='bar')
def test_reconnect_does_not_duplicate(self, inspect):
self.signal_a.connect(self.slot_a)
self.signal_a.connect(self.slot_a)
self.signal_a.emit()
self.slot_a.assert_called_once_with()
def test_disconnect_does_not_fail_on_not_connected_slot(self, inspect):
self.signal_a.disconnect(self.slot_b)
class WAEventHandler(object):
def __init__(self, conn):
self.connecting = Signal()
self.connected = Signal()
self.sleeping = Signal()
self.disconnected = Signal()
self.reconnecting = Signal()
'''(remote)'''
self.typing = Signal()
'''(remote)'''
self.typingPaused = Signal()
'''(remote)'''
self.available = Signal()
'''(remote)'''
self.unavailable = Signal()
self.messageSent = Signal()
self.messageDelivered = Signal()
'''(fmsg)'''
self.messageReceived = Signal()
'''messageReceived with fmsg.author'''
self.groupMessageReceived = Signal()
'''
(fmsg)
-> media_type: image, audio, video, location, vcard
-> data
image:
-> url
-> preview
audio, video:
-> url
location:
-> latitude
-> longitude
-> preview
vcard:
-> contact (vcard format)
'''
self.mediaReceived = Signal()
'''mediaReceived with fmsg.author'''
self.groupMediaReceived = Signal()
'''(group, author, subject)'''
self.newGroupSubject = Signal()
'''(group, who)'''
self.groupAdd = Signal()
'''(group, who)'''
self.groupRemove = Signal()
''' (groups: [{subject, id, owner}]) '''
self.groupsReceived = Signal()
self.groupListReceived = Signal()
self.lastSeenUpdated = Signal()
self.sendTyping = Signal()
self.sendPaused = Signal()
self.getLastOnline = Signal()
self.disconnectRequested = Signal()
self.disconnectRequested.connect(self.onDisconnectRequested)
self.loginFailed = Signal()
self.loginSuccess = Signal()
self.connectionError = Signal()
self.conn = conn
self.sendTyping.connect(self.conn.sendTyping)
self.sendPaused.connect(self.conn.sendPaused)
self.getLastOnline.connect(self.conn.getLastOnline)
self.startPingTimer()
def onDirty(self, categories):
'''Receive groups??'''
pass
def onAccountChanged(self, account_kind, expire):
pass
def onRelayRequest(
self,
pin,
timeoutSeconds,
idx,
):
pass
def sendPing(self):
self.startPingTimer()
self.conn.sendPing()
def startPingTimer(self):
self.pingTimer = threading.Timer(180, self.sendPing)
self.pingTimer.start()
def onDisconnectRequested(self):
self.pingTimer.cancel()
def onPing(self, idx):
self.conn.sendPong(idx)
def networkAvailable(self):
pass
def networkDisconnected(self):
self.sleeping.emit()
def networkUnavailable(self):
self.disconnected.emit()
def onUnavailable(self):
self.conn.sendUnavailable()
def conversationOpened(self, jid):
pass
def onAvailable(self):
self.conn.sendAvailable()
def message_received(self, fmsg):
if hasattr(fmsg, 'type'):
if fmsg.type == "chat":
if fmsg.remote.endswith('@g.us'):
self.groupMessageReceived.emit(fmsg)
else:
self.messageReceived.emit(fmsg)
elif fmsg.type == "media":
if fmsg.remote.endswith('@g.us'):
self.groupMediaReceived.emit(fmsg)
else:
self.mediaReceived.emit(fmsg)
if fmsg.wants_receipt:
self.conn.sendMessageReceived(fmsg)
def subjectReceiptRequested(self, to, idx):
self.conn.sendSubjectReceived(to, idx)
def presence_available_received(self, remote):
if remote == self.conn.jid:
return
self.available.emit(remote)
def presence_unavailable_received(self, remote):
if remote == self.conn.jid:
return
self.unavailable.emit(remote)
def typing_received(self, remote):
self.typing.emit(remote)
def paused_received(self, remote):
self.typingPaused.emit(remote)
def message_error(self, fmsg, errorCode):
pass
def message_status_update(self, fmsg):
pass
class TestSignal(object):
def setup_method(self, method):
self.signal_a = Signal(threadsafe=True)
self.signal_b = Signal(args=['foo'])
self.slot_a = mock.Mock(spec=lambda **kwargs: None)
self.slot_a.return_value = None
self.slot_b = mock.Mock(spec=lambda **kwargs: None)
self.slot_b.return_value = None
def test_is_connected(self, inspect):
self.signal_a.connect(self.slot_a)
assert self.signal_a.is_connected(self.slot_a)
assert not self.signal_a.is_connected(self.slot_b)
assert not self.signal_b.is_connected(self.slot_a)
assert not self.signal_b.is_connected(self.slot_b)
def test_emit_one_slot(self, inspect):
self.signal_a.connect(self.slot_a)
self.signal_a.emit()
self.slot_a.assert_called_once_with()
assert self.slot_b.call_count == 0
def test_emit_two_slots(self, inspect):
self.signal_a.connect(self.slot_a)
self.signal_a.connect(self.slot_b)
self.signal_a.emit()
self.slot_a.assert_called_once_with()
self.slot_b.assert_called_once_with()
def test_emit_one_slot_with_arguments(self, inspect):
self.signal_b.connect(self.slot_a)
self.signal_b.emit(foo='bar')
self.slot_a.assert_called_once_with(foo='bar')
assert self.slot_b.call_count == 0
def test_emit_two_slots_with_arguments(self, inspect):
self.signal_b.connect(self.slot_a)
self.signal_b.connect(self.slot_b)
self.signal_b.emit(foo='bar')
self.slot_a.assert_called_once_with(foo='bar')
self.slot_b.assert_called_once_with(foo='bar')
def test_reconnect_does_not_duplicate(self, inspect):
self.signal_a.connect(self.slot_a)
self.signal_a.connect(self.slot_a)
self.signal_a.emit()
self.slot_a.assert_called_once_with()
def test_disconnect_does_not_fail_on_not_connected_slot(self, inspect):
self.signal_a.disconnect(self.slot_b)
class WAEventHandler(object):
def __init__(self, conn):
self.connecting = Signal()
self.connected = Signal()
self.sleeping = Signal()
self.disconnected = Signal()
self.reconnecting = Signal()
'''(remote)'''
self.typing = Signal()
'''(remote)'''
self.typingPaused = Signal()
'''(remote)'''
self.available = Signal()
'''(remote)'''
self.unavailable = Signal()
self.messageSent = Signal()
self.messageDelivered = Signal()
'''(fmsg)'''
self.messageReceived = Signal()
'''messageReceived with fmsg.author'''
self.groupMessageReceived = Signal()
'''
(fmsg)
-> media_type: image, audio, video, location, vcard
-> data
image:
-> url
-> preview
audio, video:
-> url
location:
-> latitude
-> longitude
-> preview
vcard:
-> contact (vcard format)
'''
self.mediaReceived = Signal()
'''mediaReceived with fmsg.author'''
self.groupMediaReceived = Signal()
'''(group, author, subject)'''
self.newGroupSubject = Signal()
'''(group, who)'''
self.groupAdd = Signal()
'''(group, who)'''
self.groupRemove = Signal()
''' (groups: [{subject, id, owner}]) '''
self.groupsReceived = Signal()
self.groupListReceived = Signal()
self.lastSeenUpdated = Signal()
self.sendTyping = Signal()
self.sendPaused = Signal()
self.getLastOnline = Signal()
self.disconnectRequested = Signal()
self.disconnectRequested.connect(self.onDisconnectRequested)
self.loginFailed = Signal()
self.loginSuccess = Signal()
self.connectionError = Signal()
self.conn = conn
self.sendTyping.connect(self.conn.sendTyping)
self.sendPaused.connect(self.conn.sendPaused)
self.getLastOnline.connect(self.conn.getLastOnline)
self.startPingTimer()
def onDirty(self, categories):
'''Receive groups??'''
pass
def onAccountChanged(self, account_kind, expire):
pass
def onRelayRequest(
self,
pin,
timeoutSeconds,
idx,
):
pass
def sendPing(self):
self.startPingTimer()
self.conn.sendPing()
def startPingTimer(self):
self.pingTimer = threading.Timer(180, self.sendPing)
self.pingTimer.start()
def onDisconnectRequested(self):
self.pingTimer.cancel()
def onPing(self, idx):
self.conn.sendPong(idx)
def networkAvailable(self):
pass
def networkDisconnected(self):
self.sleeping.emit()
def networkUnavailable(self):
self.disconnected.emit()
def onUnavailable(self):
self.conn.sendUnavailable()
def conversationOpened(self, jid):
pass
def onAvailable(self):
self.conn.sendAvailable()
def message_received(self, fmsg):
if hasattr(fmsg, 'type'):
if fmsg.type == "chat":
if fmsg.remote.endswith('@g.us'):
self.groupMessageReceived.emit(fmsg)
else:
self.messageReceived.emit(fmsg)
elif fmsg.type == "media":
if fmsg.remote.endswith('@g.us'):
self.groupMediaReceived.emit(fmsg)
else:
self.mediaReceived.emit(fmsg)
if fmsg.wants_receipt:
self.conn.sendMessageReceived(fmsg)
def subjectReceiptRequested(self, to, idx):
self.conn.sendSubjectReceived(to, idx)
def presence_available_received(self, remote):
if remote == self.conn.jid:
return
self.available.emit(remote)
def presence_unavailable_received(self, remote):
if remote == self.conn.jid:
return
self.unavailable.emit(remote)
def typing_received(self, remote):
self.typing.emit(remote)
def paused_received(self, remote):
self.typingPaused.emit(remote)
def message_error(self, fmsg, errorCode):
pass
def message_status_update(self, fmsg):
pass
