# stop the test
return True
class SendFileAndDisconnect (SendFileTest):
def __init__(self, file, address_type,
access_control, acces_control_param):
FileTransferTest.__init__(self, file, address_type,
access_control, acces_control_param)
self._actions = [self.connect, self.set_ft_caps,
self.check_ft_available, None,
self.wait_for_ft_caps, None,
self.request_ft_channel, self.provide_file, None,
self.send_file, self.wait_for_completion,
self.disconnect, None,
self.close_channel, self.done]
def disconnect(self):
self.conn.Disconnect()
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndDisconnect, \
ReceiveFileAndSenderDisconnectWhileTransfering)
def request_ft_channel(self):
request = { cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_FILE_TRANSFER,
cs.TARGET_HANDLE_TYPE: cs.HT_CONTACT,
cs.TARGET_HANDLE: self.handle,
cs.FT_CONTENT_TYPE: self.file.content_type,
cs.FT_FILENAME: self.file.name,
cs.FT_SIZE: self.file.size,
cs.FT_CONTENT_HASH_TYPE: self.file.hash_type,
cs.FT_CONTENT_HASH: self.file.hash,
cs.FT_DESCRIPTION: self.file.description,
cs.FT_DATE: self.file.date,
cs.FT_INITIAL_OFFSET: 0,
cs.FT_SERVICE_NAME: self.service_name,
cs.FT_METADATA: dbus.Dictionary(self.metadata, signature='sas')}
call_async(self.q, self.conn.Requests, 'CreateChannel', request)
# no support for metadata, soz
self.q.expect('dbus-error', method='CreateChannel', name=cs.NOT_CAPABLE)
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileNoMetadata, True)
exec_file_transfer_test(ReceiveFileNoMetadata, True)
exec_file_transfer_test(SendFileOddMetadata, True)
exec_file_transfer_test(ReceiveFileOddMetadata, True)
exec_file_transfer_test(SendFileBadProps, True)
exec_file_transfer_test(SendFileBadContact, True)
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest
from config import FILE_TRANSFER_ENABLED
if not FILE_TRANSFER_ENABLED:
print("NOTE: built with --disable-file-transfer")
raise SystemExit(77)
class ReceiveFileAndDisconnectTest(ReceiveFileTest):
def receive_file(self):
s = self.create_socket()
s.connect(self.address)
# return True so the test will be ended and the connection
# disconnected
return True
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileAndDisconnectTest)
def client_accept_file(self):
# state is still Pending as remote didn't accept the transfer yet
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, "State")
assert state == cs.FT_STATE_PENDING
SendFileTest.client_accept_file(self)
# Remote accepted the transfer
e = self.q.expect("dbus-signal", signal="FileTransferStateChanged")
state, reason = e.args
assert state == cs.FT_STATE_ACCEPTED, state
assert reason == cs.FT_STATE_CHANGE_REASON_NONE
def provide_file(self):
SendFileTest.provide_file(self)
e = self.q.expect("dbus-signal", signal="InitialOffsetDefined")
offset = e.args[0]
assert offset == self.file.offset
# Channel is open. We can start to send the file
e = self.q.expect("dbus-signal", signal="FileTransferStateChanged")
state, reason = e.args
assert state == cs.FT_STATE_OPEN
assert reason == cs.FT_STATE_CHANGE_REASON_REQUESTED
if __name__ == "__main__":
exec_file_transfer_test(SendFileTransferWaitToProvideTest)
# get data from bytestream
data = ''
while len(data) < to_receive:
data += self.bytestream.get_data()
assert data == self.file.data[self.file.offset:]
if self.completed:
# FileTransferStateChanged has already been received
waiting = []
else:
waiting = [EventPattern('dbus-signal', signal='FileTransferStateChanged')]
events = self.bytestream.wait_bytestream_closed(waiting)
# If not all the bytes transferred have been announced using
# TransferredBytesChanged, wait for them
while self.count < to_receive:
self.q.expect('dbus-signal', signal='TransferredBytesChanged')
assert self.count == to_receive
if len(waiting) > 1:
state, reason = events[0].args
assert state == cs.FT_STATE_COMPLETED
assert reason == cs.FT_STATE_CHANGE_REASON_NONE
if __name__ == '__main__':
exec_file_transfer_test(SendFileSendBeforeAccept)
path = self.channel.object_path,
args=[cs.FT_STATE_CANCELLED, \
cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED])
self.close_channel()
# stop the test
return True
class SendFileAndDisconnect(SendFileTest):
def __init__(self, file, address_type, access_control,
acces_control_param):
FileTransferTest.__init__(self, file, address_type, access_control,
acces_control_param)
self._actions = [
self.connect, self.set_ft_caps, self.check_ft_available, None,
self.wait_for_ft_caps, None, self.request_ft_channel,
self.provide_file, None, self.send_file, self.wait_for_completion,
self.disconnect, None, self.close_channel, self.done
]
def disconnect(self):
self.conn.Disconnect()
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndDisconnect, \
ReceiveFileAndSenderDisconnectWhileTransfering)
while len(data) < to_receive:
data += self.bytestream.get_data()
assert data == self.file.data[self.file.offset:]
if self.completed:
# FileTransferStateChanged has already been received
waiting = []
else:
waiting = [
EventPattern('dbus-signal', signal='FileTransferStateChanged')
]
events = self.bytestream.wait_bytestream_closed(waiting)
# If not all the bytes transferred have been announced using
# TransferredBytesChanged, wait for them
while self.count < to_receive:
self.q.expect('dbus-signal', signal='TransferredBytesChanged')
assert self.count == to_receive
if len(waiting) > 1:
state, reason = events[0].args
assert state == cs.FT_STATE_COMPLETED
assert reason == cs.FT_STATE_CHANGE_REASON_NONE
if __name__ == '__main__':
exec_file_transfer_test(SendFileSendBeforeAccept)
import constants as cs
from file_transfer_helper import SendFileTest, ReceiveFileTest, \
exec_file_transfer_test
from config import JINGLE_FILE_TRANSFER_ENABLED
if not JINGLE_FILE_TRANSFER_ENABLED:
print "NOTE: built with --disable-file-transfer or --disable-voip"
raise SystemExit(77)
class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest):
def receive_file(self):
# Connect to Gabble's socket
s = self.create_socket()
s.connect(self.address)
# for some reason the socket is closed
s.close()
self.q.expect('dbus-signal',
signal='FileTransferStateChanged',
args=[
cs.FT_STATE_CANCELLED,
cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR
])
if __name__ == '__main__':
exec_file_transfer_test(SendFileTest, ReceiveFileAndCancelWhileReceiving)
from file_transfer_helper import SendFileTest, ReceiveFileTest, \
exec_file_transfer_test
from config import JINGLE_FILE_TRANSFER_ENABLED
if not JINGLE_FILE_TRANSFER_ENABLED:
print "NOTE: built with --disable-file-transfer or --disable-voip"
raise SystemExit(77)
class ReceiveFileAndDisconnectTest(ReceiveFileTest):
def receive_file(self):
s = self.create_socket()
s.connect(self.address)
# return True so the test will be ended and the connection
# disconnected
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileTest, ReceiveFileAndDisconnectTest)
reply['id'] = self.iq['id']
error = reply.addElement((None, 'error'))
error['code'] = '403'
error['type'] = 'cancel'
error.addElement((ns.STANZA, 'forbidden'))
error.addElement((ns.STANZA, 'text'), content='Offer Declined')
self.stream.send(reply)
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_CANCELLED, state
assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED
transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'TransferredBytes')
# no byte has been transferred as the file was declined
assert transferred == 0
# try to provide the file, assert that this finishes the test (e.g.
# couldn't go further because of ipv6) or that it raises
# cs.NOT_AVAILABLE
try:
assert self.provide_file()
except dbus.DBusException as e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
# stop test
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileDeclinedTest)
# URI is not set
assertNoURI(self.ft_channel)
ReceiveFileTest.accept_file(self)
def close_channel(self):
# Still no URI
assertNoURI(self.ft_channel)
ReceiveFileTest.close_channel(self)
class SendFileNoURI(SendFileTest):
def request_ft_channel(self):
SendFileTest.request_ft_channel(self, False)
def close_channel(self):
# Still no URI
assertNoURI(self.ft_channel)
SendFileTest.close_channel(self)
if __name__ == '__main__':
# We don't define an URI before accepting the file and try to set it after
exec_file_transfer_test(SetURIAfterAccepting, True)
# Don't define any URI when receiving a file
exec_file_transfer_test(ReceiveFileTestNoURI, True)
# Don't define any URI when sending a file
exec_file_transfer_test(SendFileNoURI, True)
raise SystemExit(77)
print("FIXME: test is not stable enough.\n" +
" https://bugs.freedesktop.org/show_bug.cgi?id=49595")
raise SystemExit(77)
class SendFileBeforeAccept(SendFileTest):
def __init__(self, file, address_type,
access_control, acces_control_param):
FileTransferTest.__init__(self, file, address_type,
access_control, acces_control_param)
self._actions = [self.connect, self.set_ft_caps,
self.check_ft_available, None,
self.wait_for_ft_caps, None,
self.request_ft_channel, self.provide_file,
self.set_open, self.send_file, None,
self.wait_for_completion, None,
self.close_channel, self.done]
def set_open(self):
self.open = True
self.offset_defined = True
if __name__ == '__main__':
exec_file_transfer_test(SendFileBeforeAccept, ReceiveFileTest)
if not FILE_TRANSFER_ENABLED:
print("NOTE: built with --disable-file-transfer")
raise SystemExit(77)
class SendFileTransferToUnknownContactTest(SendFileTest):
def __init__(self, bytestream_cls, file, address_type, access_control,
acces_control_param):
SendFileTest.__init__(self, bytestream_cls, file, address_type,
access_control, acces_control_param)
self._actions = [
self.connect, self.check_ft_available, self.my_request_ft_channel
]
def my_request_ft_channel(self):
self.contact_name = 'jean@localhost'
self.handle = self.conn.get_contact_handle_sync(self.contact_name)
try:
self.request_ft_channel()
except dbus.DBusException as e:
assert e.get_dbus_name() == cs.OFFLINE
else:
assert False
if __name__ == '__main__':
exec_file_transfer_test(SendFileTransferToUnknownContactTest)
from file_transfer_helper import SendFileTest, exec_file_transfer_test
from config import FILE_TRANSFER_ENABLED
if not FILE_TRANSFER_ENABLED:
print("NOTE: built with --disable-file-transfer")
raise SystemExit(77)
class SendFileAndCancelImmediatelyTest(SendFileTest):
def provide_file(self):
SendFileTest.provide_file(self)
# 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')
# XEP-0096 doesn't have a way to inform receiver we cancelled the
# transfer...
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndCancelImmediatelyTest)
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False
self.close_channel()
# stop the test
return True
class SendFileAndDisconnect(SendFileTest):
def __init__(self, file, address_type, access_control,
acces_control_param):
FileTransferTest.__init__(self, file, address_type, access_control,
acces_control_param)
self._actions = [
self.connect, self.set_ft_caps, self.check_ft_available, None,
self.wait_for_ft_caps, None, self.request_ft_channel,
self.provide_file, self.disconnect, None, self.close_channel,
self.done
]
def disconnect(self):
self.conn.Disconnect()
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndDisconnect, \
ReceiveFileAndSenderDisconnectWhilePendingTest)
if not JINGLE_FILE_TRANSFER_ENABLED:
print("NOTE: built with --disable-file-transfer or --disable-voip")
raise SystemExit(77)
print("FIXME: test is not stable enough.\n" +
" https://bugs.freedesktop.org/show_bug.cgi?id=49595")
raise SystemExit(77)
class SendFileBeforeAccept(SendFileTest):
def __init__(self, file, address_type, access_control,
acces_control_param):
FileTransferTest.__init__(self, file, address_type, access_control,
acces_control_param)
self._actions = [
self.connect, self.set_ft_caps, self.check_ft_available, None,
self.wait_for_ft_caps, None, self.request_ft_channel,
self.provide_file, self.set_open, self.send_file, None,
self.wait_for_completion, None, self.close_channel, self.done
]
def set_open(self):
self.open = True
self.offset_defined = True
if __name__ == '__main__':
exec_file_transfer_test(SendFileBeforeAccept, ReceiveFileTest)
raise SystemExit(77)
class SendFileAndWaitToProvide(SendFileTest):
def __init__(self, file, address_type, access_control,
acces_control_param):
FileTransferTest.__init__(self, file, address_type, access_control,
acces_control_param)
self._actions = [
self.connect, self.set_ft_caps, self.check_ft_available, None,
self.wait_for_ft_caps, None, self.request_ft_channel,
self.check_pending_state, None, self.check_accepted_state,
self.provide_file, self.send_file, self.wait_for_completion, None,
self.close_channel, self.done
]
def check_pending_state(self):
# state is still Pending as remote didn't accept the transfer yet
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_PENDING
def check_accepted_state(self):
# Remote accepted the transfer
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_ACCEPTED, state
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndWaitToProvide, ReceiveFileTest)
import dbus
import constants as cs
from file_transfer_helper import SendFileTest, exec_file_transfer_test
class SendFileTransferToUnknownContactTest(SendFileTest):
def __init__(self, bytestream_cls, file, address_type, access_control, acces_control_param):
SendFileTest.__init__(self, bytestream_cls, file, address_type, access_control, acces_control_param)
self._actions = [self.connect, self.check_ft_available, self.my_request_ft_channel]
def my_request_ft_channel(self):
self.contact_name = 'jean@localhost'
self.handle = self.conn.RequestHandles(cs.HT_CONTACT, [self.contact_name])[0]
try:
self.request_ft_channel()
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.OFFLINE
else:
assert False
if __name__ == '__main__':
exec_file_transfer_test(SendFileTransferToUnknownContactTest)
import constants as cs
from file_transfer_helper import SendFileTest, exec_file_transfer_test
from config import FILE_TRANSFER_ENABLED
if not FILE_TRANSFER_ENABLED:
print "NOTE: built with --disable-file-transfer"
raise SystemExit(77)
class SendFileAndCancelImmediatelyTest(SendFileTest):
def provide_file(self):
SendFileTest.provide_file(self)
# 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')
# XEP-0096 doesn't have a way to inform receiver we cancelled the
# transfer...
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndCancelImmediatelyTest)
self.request_ft_channel, self.provide_file, None,
self.check_declined, self.close_channel, self.done]
def check_declined(self):
state_event = self.q.expect('dbus-signal',
signal='FileTransferStateChanged',
path=self.channel.object_path)
state, reason = state_event.args
assert state == cs.FT_STATE_CANCELLED
assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED
transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER,
'TransferredBytes')
# no byte has been transferred as the file was declined
assert transferred == 0
# try to provide the file
try:
self.provide_file()
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False
if __name__ == '__main__':
exec_file_transfer_test(SendFileDeclined, ReceiveFileDecline)
import constants as cs
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest
class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest):
def receive_file(self):
# Connect to Gabble's socket
s = self.create_socket()
s.connect(self.address)
# for some reason the socket is closed
s.close()
# we receive one more byte from the sender
self.bytestream.send_data(self.file.data[2:3])
self.q.expect('dbus-signal', signal='FileTransferStateChanged',
args=[cs.FT_STATE_CANCELLED, cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR])
self.channel.Close()
self.q.expect('dbus-signal', signal='Closed')
return True
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileAndCancelWhileReceiving)
access_control, acces_control_param):
FileTransferTest.__init__(self, file, address_type,
access_control, acces_control_param)
self._actions = [self.connect, self.set_ft_caps,
self.check_ft_available, None,
self.wait_for_ft_caps, None,
self.request_ft_channel, self.provide_file, None,
self.close_and_check, None,
self.close_channel, self.done]
def close_and_check(self):
self.channel.Close()
state_event, _ = self.q.expect_many(
EventPattern('dbus-signal', signal='FileTransferStateChanged',
path=self.channel.object_path),
EventPattern('dbus-signal', signal='Closed',
path=self.channel.object_path))
state, reason = state_event.args
assert state == cs.FT_STATE_CANCELLED
assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndClose, ReceiveFileStopped)
# -*- coding: utf-8 -*-
from file_transfer_helper import SendFileTest, ReceiveFileTest, \
exec_file_transfer_test, File
from config import JINGLE_FILE_TRANSFER_ENABLED
if not JINGLE_FILE_TRANSFER_ENABLED:
print("NOTE: built with --disable-file-transfer or --disable-voip")
raise SystemExit(77)
print(
"FIXME: test is not working now and I have no idea how it was supposed to work.\n"
+ " Needs porting to normal Jingle Session from google session.")
raise SystemExit(77)
if __name__ == '__main__':
file = File()
file.offset = 5
file.name = "The greek foo δοκιμή.txt"
exec_file_transfer_test(SendFileTest, ReceiveFileTest, file)
reply['id'] = self.iq['id']
error = reply.addElement((None, 'error'))
error['code'] = '403'
error['type'] = 'cancel'
forbidden = error.addElement((ns.STANZA, 'forbidden'))
text = error.addElement((ns.STANZA, 'text'), content='Offer Declined')
self.stream.send(reply)
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_CANCELLED, state
assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED
transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'TransferredBytes')
# no byte has been transferred as the file was declined
assert transferred == 0
# try to provide the file, assert that this finishes the test (e.g.
# couldn't go further because of ipv6) or that it raises
# cs.NOT_AVAILABLE
try:
assert self.provide_file()
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
# stop test
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileDeclinedTest)
access_control, acces_control_param):
FileTransferTest.__init__(self, file, address_type,
access_control, acces_control_param)
self._actions = [self.connect, self.set_ft_caps,
self.check_ft_available, None,
self.wait_for_ft_caps, None,
self.request_ft_channel, self.provide_file, None,
self.close_and_check, None,
self.close_channel, self.done]
def close_and_check(self):
self.channel.Close()
state_event, _ = self.q.expect_many(
EventPattern('dbus-signal', signal='FileTransferStateChanged',
path=self.channel.object_path),
EventPattern('dbus-signal', signal='Closed',
path=self.channel.object_path))
state, reason = state_event.args
assert state == cs.FT_STATE_CANCELLED
assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndClose, ReceiveFileStopped)
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest
from config import FILE_TRANSFER_ENABLED
if not FILE_TRANSFER_ENABLED:
print "NOTE: built with --disable-file-transfer"
raise SystemExit(77)
class ReceiveFileAndDisconnectTest(ReceiveFileTest):
def receive_file(self):
s = self.create_socket()
s.connect(self.address)
# return True so the test will be ended and the connection
# disconnected
return True
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileAndDisconnectTest)
from file_transfer_helper import SendFileTest, ReceiveFileTest, \
exec_file_transfer_test
from config import JINGLE_FILE_TRANSFER_ENABLED
if not JINGLE_FILE_TRANSFER_ENABLED:
print "NOTE: built with --disable-file-transfer or --disable-voip"
raise SystemExit(77)
class ReceiveFileAndDisconnectTest(ReceiveFileTest):
def receive_file(self):
s = self.create_socket()
s.connect(self.address)
# return True so the test will be ended and the connection
# disconnected
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileTest, ReceiveFileAndDisconnectTest)
self.file.offset,
byte_arrays=True)
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False
if SendFileTest.provide_file(self):
return True
# state is still Pending as remote didn't accept the transfer yet
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_PENDING
def client_accept_file(self):
SendFileTest.client_accept_file(self)
e = self.q.expect('dbus-signal', signal='InitialOffsetDefined')
offset = e.args[0]
assert offset == self.file.offset
# Channel is open. We can start to send the file
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_OPEN
assert reason == cs.FT_STATE_CHANGE_REASON_NONE
if __name__ == '__main__':
exec_file_transfer_test(SendFileTransferProvideImmediately)
self.request_ft_channel, self.provide_file, None,
self.check_declined, self.close_channel, self.done]
def check_declined(self):
state_event = self.q.expect('dbus-signal',
signal='FileTransferStateChanged',
path=self.channel.object_path)
state, reason = state_event.args
assert state == cs.FT_STATE_CANCELLED
assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED
transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER,
'TransferredBytes')
# no byte has been transferred as the file was declined
assert transferred == 0
# try to provide the file
try:
self.provide_file()
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False
if __name__ == '__main__':
exec_file_transfer_test(SendFileDeclined, ReceiveFileDecline)
import constants as cs
from file_transfer_helper import SendFileTest, ReceiveFileTest, \
exec_file_transfer_test
class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest):
def receive_file(self):
# Connect to Gabble's socket
s = self.create_socket()
s.connect(self.address)
# for some reason the socket is closed
s.close()
self.q.expect('dbus-signal', signal='FileTransferStateChanged',
args=[cs.FT_STATE_CANCELLED, cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR])
if __name__ == '__main__':
exec_file_transfer_test(SendFileTest, ReceiveFileAndCancelWhileReceiving)
cs.TARGET_HANDLE: self.handle,
cs.FT_CONTENT_TYPE: self.file.content_type,
cs.FT_FILENAME: self.file.name,
cs.FT_SIZE: self.file.size,
cs.FT_CONTENT_HASH_TYPE: self.file.hash_type,
cs.FT_CONTENT_HASH: self.file.hash,
cs.FT_DESCRIPTION: self.file.description,
cs.FT_DATE: self.file.date,
cs.FT_INITIAL_OFFSET: 0,
cs.FT_SERVICE_NAME: self.service_name,
cs.FT_METADATA: dbus.Dictionary(self.metadata, signature='sas')
}
call_async(self.q, self.conn.Requests, 'CreateChannel', request)
# no support for metadata, soz
self.q.expect('dbus-error',
method='CreateChannel',
name=cs.NOT_CAPABLE)
return True
if __name__ == '__main__':
exec_file_transfer_test(SendFileNoMetadata, True)
exec_file_transfer_test(ReceiveFileNoMetadata, True)
exec_file_transfer_test(SendFileOddMetadata, True)
exec_file_transfer_test(ReceiveFileOddMetadata, True)
exec_file_transfer_test(SendFileBadProps, True)
exec_file_transfer_test(SendFileBadContact, True)
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest
from config import FILE_TRANSFER_ENABLED
if not FILE_TRANSFER_ENABLED:
print "NOTE: built with --disable-file-transfer"
raise SystemExit(77)
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileTest)
def accept_file(self):
# The sender of the file disconnects
presence = domish.Element(('jabber:client', 'presence'))
presence['from'] = self.contact_full_jid
presence['to'] = 'test@localhost/Resource'
presence['type'] = 'unavailable'
self.stream.send(presence)
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_REMOTE_STOPPED
# We can't accept the transfer now
try:
# IPv4 is always guaranteed to be available
self.ft_channel.AcceptFile(cs.SOCKET_ADDRESS_TYPE_IPV4,
cs.SOCKET_ACCESS_CONTROL_LOCALHOST, "", 0)
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False
self.close_channel()
# stop the test
return True
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileAndSenderDisconnectWhilePendingTest)
from servicetest import EventPattern
from twisted.words.xish import xpath
import constants as cs
from file_transfer_helper import ReceiveFileTest, exec_file_transfer_test
class ReceiveFileDeclineTest(ReceiveFileTest):
def accept_file(self):
# decline FT
self.channel.Close()
state_event, iq_event = self.q.expect_many(
EventPattern('dbus-signal', signal='FileTransferStateChanged'),
EventPattern('stream-iq', iq_type='error'))
error_node = xpath.queryForNodes('/iq/error', iq_event.stanza)[0]
assert error_node['code'] == '403'
state, reason = state_event.args
assert state == cs.FT_STATE_CANCELLED
assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED
self.q.expect('dbus-signal', signal='Closed')
# stop test
return True
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileDeclineTest)
class SendFileAndWaitToProvide (SendFileTest):
def __init__(self, file, address_type,
access_control, acces_control_param):
FileTransferTest.__init__(self, file, address_type,
access_control, acces_control_param)
self._actions = [self.connect, self.set_ft_caps,
self.check_ft_available, None,
self.wait_for_ft_caps, None,
self.request_ft_channel, self.check_pending_state, None,
self.check_accepted_state, self.provide_file,
self.send_file, self.wait_for_completion, None,
self.close_channel, self.done]
def check_pending_state(self):
# state is still Pending as remote didn't accept the transfer yet
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_PENDING
def check_accepted_state(self):
# Remote accepted the transfer
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_ACCEPTED, state
if __name__ == '__main__':
exec_file_transfer_test(SendFileAndWaitToProvide, ReceiveFileTest)
print("NOTE: built with --disable-file-transfer")
raise SystemExit(77)
class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest):
def receive_file(self):
# Connect to Gabble's socket
s = self.create_socket()
s.connect(self.address)
# for some reason the socket is closed
s.close()
# we receive one more byte from the sender
self.bytestream.send_data(self.file.data[2:3])
self.q.expect('dbus-signal',
signal='FileTransferStateChanged',
args=[
cs.FT_STATE_CANCELLED,
cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR
])
self.channel.Close()
self.q.expect('dbus-signal', signal='Closed')
return True
if __name__ == '__main__':
exec_file_transfer_test(ReceiveFileAndCancelWhileReceiving)
# -*- coding: utf-8 -*-
from file_transfer_helper import SendFileTest, ReceiveFileTest, \
exec_file_transfer_test, File
if __name__ == '__main__':
file = File()
file.offset = 5
file.name = "The greek foo δοκιμή.txt"
exec_file_transfer_test(SendFileTest, ReceiveFileTest, file)
self.ft_channel.AcceptFile(self.address_type,
self.access_control, self.access_control_param, self.file.offset,
byte_arrays=True)
except dbus.DBusException, e:
assert e.get_dbus_name() == cs.NOT_AVAILABLE
else:
assert False
if SendFileTest.provide_file(self):
return True
# state is still Pending as remote didn't accept the transfer yet
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_PENDING
def client_accept_file(self):
SendFileTest.client_accept_file(self)
e = self.q.expect('dbus-signal', signal='InitialOffsetDefined')
offset = e.args[0]
assert offset == self.file.offset
# Channel is open. We can start to send the file
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_OPEN
assert reason == cs.FT_STATE_CHANGE_REASON_NONE
if __name__ == '__main__':
exec_file_transfer_test(SendFileTransferProvideImmediately)
# URI is not set
assertNoURI(self.ft_channel)
ReceiveFileTest.accept_file(self)
def close_channel(self):
# Still no URI
assertNoURI(self.ft_channel)
ReceiveFileTest.close_channel(self)
class SendFileNoURI(SendFileTest):
def request_ft_channel(self):
SendFileTest.request_ft_channel(self, False)
def close_channel(self):
# Still no URI
assertNoURI(self.ft_channel)
SendFileTest.close_channel(self)
if __name__ == '__main__':
# We don't define an URI before accepting the file and try to set it after
exec_file_transfer_test(SetURIAfterAccepting, True)
# Don't define any URI when receiving a file
exec_file_transfer_test(ReceiveFileTestNoURI, True)
# Don't define any URI when sending a file
exec_file_transfer_test(SendFileNoURI, True)
def client_accept_file(self):
# state is still Pending as remote didn't accept the transfer yet
state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State')
assert state == cs.FT_STATE_PENDING
SendFileTest.client_accept_file(self)
# Remote accepted the transfer
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_ACCEPTED, state
assert reason == cs.FT_STATE_CHANGE_REASON_NONE
def provide_file(self):
if SendFileTest.provide_file(self):
return True
e = self.q.expect('dbus-signal', signal='InitialOffsetDefined')
offset = e.args[0]
assert offset == self.file.offset
# Channel is open. We can start to send the file
e = self.q.expect('dbus-signal', signal='FileTransferStateChanged')
state, reason = e.args
assert state == cs.FT_STATE_OPEN
assert reason == cs.FT_STATE_CHANGE_REASON_REQUESTED
if __name__ == '__main__':
exec_file_transfer_test(SendFileTransferWaitToProvideTest)
