from saluttest import exec_test
from file_transfer_helper import ReceiveFileTest
import constants as cs
class ReceiveFileAndSenderDisconnectWhilePendingTest(ReceiveFileTest):
def accept_file(self):
# The sender of the file disconnects
self.outbound.transport.loseConnection()
self.contact_service.stop()
self.q.expect('dbus-signal', signal='FileTransferStateChanged')
# We can't accept the transfer now
try:
self.ft_channel.AcceptFile(cs.SOCKET_ADDRESS_TYPE_UNIX,
cs.SOCKET_ACCESS_CONTROL_LOCALHOST, "", 0, byte_arrays=True)
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False, "Should raise NotAvailable error"
self.close_channel()
# stop the test
return True
if __name__ == '__main__':
test = ReceiveFileAndSenderDisconnectWhilePendingTest()
exec_test(test.test)
assertEquals('I most certainly dont feel like dancing',
c.children[0])
else:
raise
for child in iq.children:
if child.name == 'message':
check_message(child)
elif child.name == 'error':
check_error(child)
else:
raise
# check we can't call anything any more
call_async(q, chan, 'Fail', ycs.ERROR_TYPE_CANCEL, 'lol', 'whut', 'pear')
q.expect('dbus-error', method='Fail')
call_async(q, chan, 'Reply', {'lol': 'whut'}, '')
q.expect('dbus-error', method='Reply')
call_async(q, chan, 'Request')
q.expect('dbus-error', method='Request')
if __name__ == '__main__':
exec_test(outgoing_reply)
exec_test(outgoing_fail)
exec_test(bad_requests)
exec_test(incoming_reply)
exec_test(incoming_fail)
# cancel the transfer before the receiver accepts it
self.channel.Close()
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_CANCELLED
assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED
self.q.expect('dbus-signal', signal='Closed')
def client_request_file(self):
# Connect HTTP client to the CM and request the file
http = httplib.HTTPConnection(self.host)
# can't retry the file as the transfer was cancelled
try:
http.request('GET', self.filename)
except socket.error, e:
code, msg = e.args
assert errno.errorcode[code] == 'ECONNREFUSED', '%r' % e
except Exception, e:
assert False, 'Should raise a socket error, not: %r' % e
else:
assert False, "Should raise a socket error"
# stop test
return True
if __name__ == '__main__':
test = SendFileAndCancelImmediatelyTest()
exec_test(test.test)
EventPattern('dbus-signal', signal='ConnectionClosed', path=tube2_path),
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'))
conn_id, error, dbus_msg = e1.args
assert conn_id == contact1_tube_conn_id
assert error == CANCELLED
conn_id, error, dbus_msg = e2.args
assert conn_id == contact2_tube_conn_id
assert error == CONNECTION_LOST
call_async(q, contact2_tube, 'Close')
q.expect_many(
EventPattern('dbus-return', method='Close'),
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'))
conn.Disconnect()
conn2.Disconnect()
# cleanup
try:
os.remove(server_socket_address)
except OSError:
pass # idgaf
if __name__ == '__main__':
# increase timer because Clique takes some time to join an existing muc
exec_test(test, timeout=60)
call_async(q, contact1_tube, 'Close')
_, _, _, dbus_names_e = q.expect_many(
EventPattern('dbus-return', method='Close'),
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'),
EventPattern('dbus-signal',
signal='DBusNamesChanged',
interface=cs.CHANNEL_TYPE_DBUS_TUBE,
path=tube2_path))
# Contact1 is removed from the tube
added, removed = dbus_names_e.args
assert added == {}
assert removed == [contact1_handle_on_conn2]
check_dbus_names(contact2_tube, [conn2_self_handle])
call_async(q, contact2_tube, 'Close')
q.expect_many(EventPattern('dbus-return', method='Close'),
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'))
conn.Disconnect()
conn2.Disconnect()
if __name__ == '__main__':
# increase timer because Clique takes some time to join an existing muc
exec_test(test, timeout=60)
import time
PUBLISHED_NAME="test-register"
FIRST_NAME="lastname"
LAST_NAME="lastname"
def test(q, bus, conn):
AvahiListener(q).listen_for_service("_presence._tcp")
conn.Connect()
e = q.expect('service-added',
name=PUBLISHED_NAME + "@" + avahitest.get_host_name())
service = e.service
service.resolve()
e = q.expect('service-resolved', service = service)
for (key, val) in { "1st": FIRST_NAME,
"last": LAST_NAME,
"status": "avail",
"txtvers": "1" }.iteritems():
v = txt_get_key(e.txt, key)
assert v == val, (key, val, v)
if __name__ == '__main__':
exec_test(test, { "published-name": PUBLISHED_NAME,
"first-name": FIRST_NAME,
"last-name": LAST_NAME })
expect_close(q, text_path)
# the following are basically the same as assert_[not_]on_bus()
# but they look pretty.
# methods on the text channel should fail
call_async(q, text_chan.Properties, 'GetAll', cs.CHANNEL_TYPE_TEXT)
q.expect('dbus-error', method='GetAll')
# but methods on the tube should pass
call_async(q, tube_chan.Properties, 'GetAll', cs.CHANNEL_TYPE_STREAM_TUBE)
q.expect('dbus-return', method='GetAll')
if __name__ == '__main__':
# request tube, assert no text appears
exec_test(tube_no_text)
# request tube, request text (no presence), assert both appear
exec_test(tube_then_text)
# request tube & text, close text, assert tube doesn't close
exec_test(tube_remains_text_closes)
# request text, close text, assert unavailable presence
exec_test(normally_close_text)
# request tube, close tube, assert unavailable presence
exec_test(text_can_automatically_close)
# request tube & text, close tube, assert text doesn't close
exec_test(text_remains_after_tube)
assertEquals(1, len(c.children))
assertEquals('I most certainly dont feel like dancing',
c.children[0])
else:
raise
for child in iq.children:
if child.name == 'message':
check_message(child)
elif child.name == 'error':
check_error(child)
else:
raise
# check we can't call anything any more
call_async(q, chan, 'Fail', ycs.ERROR_TYPE_CANCEL, 'lol', 'whut', 'pear')
q.expect('dbus-error', method='Fail')
call_async(q, chan, 'Reply', {'lol':'whut'}, '')
q.expect('dbus-error', method='Reply')
call_async(q, chan, 'Request')
q.expect('dbus-error', method='Request')
if __name__ == '__main__':
exec_test(outgoing_reply)
exec_test(outgoing_fail)
exec_test(bad_requests)
exec_test(incoming_reply)
exec_test(incoming_fail)
def test(q, bus, conn):
AvahiListener(q).listen_for_service("_presence._tcp")
conn.Connect()
e = q.expect('service-added',
name=PUBLISHED_NAME + "@" + avahitest.get_host_name())
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
for (key, val) in {
"1st": FIRST_NAME,
"last": LAST_NAME,
"status": "avail",
"txtvers": "1"
}.iteritems():
v = txt_get_key(e.txt, key)
assert v == val, (key, val, v)
if __name__ == '__main__':
exec_test(
test, {
"published-name": PUBLISHED_NAME,
"first-name": FIRST_NAME,
"last-name": LAST_NAME
})
act_prop_iface = dbus.Interface(conn, cs.ACTIVITY_PROPERTIES)
act_properties = act_prop_iface.GetProperties(activity_handle)
assert act_properties['private'] == False
assert act_properties['color'] == activity_txt['color']
assert act_properties['name'] == activity_txt['name']
assert act_properties['type'] == activity_txt['type']
room_channel = conn.RequestChannel(CHANNEL_TYPE_TEXT,
HT_ROOM, activity_handle, True)
q.expect('dbus-signal', signal='MembersChanged', path=room_channel,
args = [u'', [1L], [], [], [], 1L, 0L])
# Make it public that we joined the activity
q.unforbid_events([forbiden_event])
buddy_info_iface = dbus.Interface(conn, cs.BUDDY_INFO)
buddy_info_iface.SetActivities([(ACTIVITY_ID, activity_handle)])
q.expect('service-added',
name = ACTIVITY_ID + ":" + TESTSUITE_PUBLISHED_NAME +
"@" + get_host_name())
buddy_info_iface.SetActivities([])
q.expect('service-removed',
name = ACTIVITY_ID + ":" + TESTSUITE_PUBLISHED_NAME +
"@" + get_host_name())
if __name__ == '__main__':
exec_test(test, { "published-name": TESTSUITE_PUBLISHED_NAME}, timeout=15)
