def test(q, bus, mc):
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
}, signature='sv')
empathy_bus = dbus.bus.BusConnection()
empathy_bus.set_exit_on_disconnect(False) # we'll disconnect later
kopete_bus = dbus.bus.BusConnection()
q.attach_to_bus(empathy_bus)
q.attach_to_bus(kopete_bus)
# Two clients want to observe, approve and handle channels
empathy = SimulatedClient(q, empathy_bus, 'Empathy',
observe=[text_fixed_properties], approve=[text_fixed_properties],
handle=[text_fixed_properties], bypass_approval=False)
kopete = SimulatedClient(q, kopete_bus, 'Kopete',
observe=[text_fixed_properties], approve=[text_fixed_properties],
handle=[text_fixed_properties], bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [empathy, kopete])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
# Both Observers are told about the new channel
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert k.args == e.args
# Both Observers indicate that they are ready to proceed
q.dbus_return(k.message, bus=empathy_bus, signature='')
q.dbus_return(e.message, bus=kopete_bus, signature='')
# The Approvers are next
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
)
assert e.args == [[(chan.object_path, channel_properties)],
cdo_path, cdo_properties]
assert k.args == e.args
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Both Approvers now have a flashing icon or something, trying to get the
# user's attention
# Using an invalid Handler name should fail
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.The.Moon.On.A.Stick')
q.expect('dbus-error', method='HandleWith')
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.the moon on a stick')
q.expect('dbus-error', method='HandleWith')
# The user responds to Empathy first
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Empathy')
# Empathy is asked to handle the channels
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Empathy accepts the channels
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWith'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal', interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# Approve another channel using HandleWithTime()
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'lucien'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'lucien')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'lucien'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'lucien')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
# Both Observers are told about the new channel
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert k.args == e.args
# Both Observers indicate that they are ready to proceed
q.dbus_return(k.message, bus=empathy_bus, signature='')
q.dbus_return(e.message, bus=kopete_bus, signature='')
# The Approvers are next
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
)
assert e.args == [[(chan.object_path, channel_properties)],
cdo_path, cdo_properties]
assert k.args == e.args
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Both Approvers now have a flashing icon or something, trying to get the
# user's attention
# The user responds to Empathy first
call_async(q, cdo_iface, 'HandleWithTime',
cs.tp_name_prefix + '.Client.Empathy', 13)
# Empathy is asked to handle the channels
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
account_path, conn_path, channels, requests, action_time, info = e.args
assert action_time == 13
# Empathy accepts the channels
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWithTime'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal', interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# From now on, it is an error to get HandleChannels (because we're
# testing Claim())
forbidden = [
EventPattern('dbus-method-call', method='HandleChannels'),
]
q.forbid_events(forbidden)
# Another channel
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'mercutio'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'mercutio')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'mercutio'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'mercutio')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
claimed_chan = SimulatedChannel(conn, channel_properties)
claimed_chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
# Both Observers are told about the new channel
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == claimed_chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert k.args == e.args
# Both Observers indicate that they are ready to proceed
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.dbus_return(e.message, bus=empathy_bus, signature='')
# The Approvers are next
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
)
assert e.args == [[(claimed_chan.object_path, channel_properties)],
cdo_path, cdo_properties]
assert k.args == e.args
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Both Approvers now have a flashing icon or something, trying to get the
# user's attention
# The user responds to Empathy first, and Empathy decides it wants the
# channel for itself
empathy_cdo = empathy_bus.get_object(cdo.bus_name, cdo.object_path)
empathy_cdo_iface = dbus.Interface(empathy_cdo, cs.CDO)
call_async(q, empathy_cdo_iface, 'Claim')
q.expect_many(
EventPattern('dbus-signal', path=cdo_path, signal='Finished'),
EventPattern('dbus-signal', path=cs.CD_PATH,
signal='DispatchOperationFinished', args=[cdo_path]),
EventPattern('dbus-return', method='Claim'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# A third channel
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'benvolio'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'benvolio')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'benvolio'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'benvolio')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
third_chan = SimulatedChannel(conn, channel_properties)
third_chan.announce()
# third_chan should not be closed
q.unforbid_events(forbidden)
forbidden.append(EventPattern('dbus-method-call', method='Close',
path=third_chan.object_path))
q.forbid_events(forbidden)
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
)
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.dbus_return(e.message, bus=empathy_bus, signature='')
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
)
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Kopete closes this one
kopete_cdo = kopete_bus.get_object(cdo.bus_name, cdo.object_path)
kopete_cdo_iface = dbus.Interface(kopete_cdo, cs.CDO)
call_async(q, kopete_cdo_iface, 'Claim')
q.expect_many(
EventPattern('dbus-signal', path=cdo_path, signal='Finished'),
EventPattern('dbus-signal', path=cs.CD_PATH,
signal='DispatchOperationFinished', args=[cdo_path]),
EventPattern('dbus-return', method='Claim'),
)
# Empathy crashes
empathy.release_name()
e = q.expect('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e:
e.args[0] == empathy.bus_name and e.args[2] == ''),
)
empathy_unique_name = e.args[1]
empathy_bus.flush()
empathy_bus.close()
# In response, the channels that were being handled by Empathy are closed.
# Kopete's channel is *not* closed.
q.expect_many(
EventPattern('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e:
e.args[0] == empathy_unique_name and e.args[2] == '')),
EventPattern('dbus-method-call',
path=chan.object_path, method='Close'),
EventPattern('dbus-method-call',
path=claimed_chan.object_path, method='Close'),
)
sync_dbus(bus, q, mc)
q.unforbid_events(forbidden)
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary(
{
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
},
signature='sv')
# Empathy is an Observers who will crash
empathy_bus = dbus.bus.BusConnection()
empathy_bus.set_exit_on_disconnect(False) # we'll disconnect later
# Kopete is an Approver, Handler and will not crash
kopete_bus = dbus.bus.BusConnection()
q.attach_to_bus(empathy_bus)
q.attach_to_bus(kopete_bus)
# Two clients want to observe, approve and handle channels
empathy = SimulatedClient(q,
empathy_bus,
'Empathy',
observe=[text_fixed_properties],
approve=[],
handle=[],
wants_recovery=True)
kopete = SimulatedClient(q,
kopete_bus,
'Kopete',
observe=[],
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [empathy, kopete])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
# The Observer (Empathy) is told about the new channel
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
# Empathy indicates that it is ready to proceed
q.dbus_return(e.message, bus=empathy_bus, signature='')
# The Approver (Kopete) is next
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False)
assert k.args == [[(chan.object_path, channel_properties)], cdo_path,
cdo_properties]
q.dbus_return(k.message, bus=kopete_bus, signature='')
# The user responds to Kopete
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Kopete')
# Kopete is asked to handle the channels
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
# Kopete accepts the channels
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWith'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal',
interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# Another channel: this one will remain unapproved
channel2_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel2_properties[cs.CHANNEL + '.TargetID'] = 'mercutio'
channel2_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'mercutio')
channel2_properties[cs.CHANNEL + '.InitiatorID'] = 'mercutio'
channel2_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'mercutio')
channel2_properties[cs.CHANNEL + '.Requested'] = False
channel2_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan2 = SimulatedChannel(conn, channel2_properties)
chan2.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo2_path = e.args[0]
cdo2_properties = e.args[1]
assert cdo2_properties[cs.CDO + '.Account'] == account.object_path
assert cdo2_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo2_path, cdo2_properties)]
cdo2 = bus.get_object(cs.CD, cdo2_path)
cdo2_iface = dbus.Interface(cdo2, cs.CDO)
cdo2_props_iface = dbus.Interface(cdo2, cs.PROPERTIES_IFACE)
assert cdo2_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo2_properties[cs.CDO + '.Interfaces']
assert cdo2_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo2_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo2_props_iface.Get(cs.CDO, 'Channels') == [(chan2.object_path,
channel2_properties)]
assert cdo2_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo2_properties[cs.CDO + '.PossibleHandlers']
# The Observer (Empathy) is told about the new channel
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo2_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan2.object_path, channels
assert channels[0][1] == channel2_properties, channels
# Empathy indicates that it is ready to proceed
q.dbus_return(e.message, bus=empathy_bus, signature='')
# The Approver (Kopete) is next; this time, we don't approve
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False)
assert k.args == [[(chan2.object_path, channel2_properties)], cdo2_path,
cdo2_properties]
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Empathy crashes
empathy.release_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(
lambda e: e.args[0] == empathy.bus_name and e.args[2] == ''),
)
empathy_unique_name = e.args[1]
empathy_bus.flush()
# Empathy gets restarted
empathy.reacquire_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(
lambda e: e.args[0] == empathy.bus_name and e.args[1] == ''),
)
empathy_unique_name = e.args[2]
e1, e2 = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
predicate=lambda e: e.args[2][0][0] == chan.object_path,
handled=False),
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
predicate=lambda e: e.args[2][0][0] == chan2.object_path,
handled=False),
)
assert e1.args[0] == account.object_path, e1.args
assert e1.args[1] == conn.object_path, e1.args
assert e1.args[4] == [], e1.args # no requests satisfied
assert e1.args[5]['recovering'] == 1, e1.args # due to observer recovery
channels = e1.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert e2.args[0] == account.object_path, e2.args
assert e2.args[1] == conn.object_path, e2.args
assert e2.args[4] == [], e2.args # no requests satisfied
assert e2.args[5]['recovering'] == 1, e2.args # due to observer recovery
channels = e2.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan2.object_path, channels
assert channels[0][1] == channel2_properties, channels
# Empathy indicates that it is ready to proceed
q.dbus_return(e1.message, bus=empathy_bus, signature='')
q.dbus_return(e2.message, bus=empathy_bus, signature='')
sync_dbus(bus, q, mc)
def test(q, bus, mc):
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL + '.Type.RespawnObservers'
}, signature='sv')
# Logger is an activatable Observer who will crash
logger_bus = dbus.bus.BusConnection()
logger_bus.set_exit_on_disconnect(False) # we'll disconnect later
# Kopete is an Approver, Handler and will not crash
kopete_bus = dbus.bus.BusConnection()
q.attach_to_bus(logger_bus)
q.attach_to_bus(kopete_bus)
kopete = SimulatedClient(q, kopete_bus, 'Kopete',
observe=[], approve=[text_fixed_properties],
handle=[text_fixed_properties], bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [kopete])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False)
assert k.args == [[(chan.object_path, channel_properties)],
cdo_path, cdo_properties]
q.dbus_return(k.message, bus=kopete_bus, signature='')
# The fake Logger implementation is run
e = q.expect('dbus-signal',
path=cs.tp_path_prefix + '/RegressionTests',
interface=cs.tp_name_prefix + '.RegressionTests',
signal='FakeStartup',
args=[cs.tp_name_prefix + '.Client.Logger'],
)
# We take on its identity to be able to continue with the test
logger = SimulatedClient(q, bus, 'Logger',
observe=[text_fixed_properties])
# Logger is told about the new channel
e = q.expect('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
# Logger indicates that it is ready to proceed
q.dbus_return(e.message, bus=logger_bus, signature='')
# The Approver (Kopete) is next
# The user responds to Kopete
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Kopete')
# Kopete is asked to handle the channels
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Kopete accepts the channels
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWith'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal', interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# Logger crashes
logger.release_name()
e = q.expect('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e:
e.args[0] == logger.bus_name and e.args[2] == ''),
)
logger_unique_name = e.args[1]
logger_bus.flush()
# Logger gets restart request
e = q.expect('dbus-signal',
path=cs.tp_path_prefix + '/RegressionTests',
interface=cs.tp_name_prefix + '.RegressionTests',
signal='FakeStartup',
args=[cs.tp_name_prefix + '.Client.Logger'],
)
# Logger gets restarted
logger.reacquire_name()
e = q.expect('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e:
e.args[0] == logger.bus_name and e.args[1] == ''),
)
logger_unique_name = e.args[2]
e = q.expect('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False)
# FIXME: assert the same things as before, except CDO (which we don't
# have) and account path (which we don't know how to get); also check
# that the recovering observer info key is set
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
assert e.args[5]['recovering'] == 1, e.args # due to observer recovery
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
# Logger indicates that it is ready to proceed
q.dbus_return(e.message, bus=logger_bus, signature='')
sync_dbus(bus, q, mc)
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary(
{
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
},
signature='sv')
empathy_bus = dbus.bus.BusConnection()
empathy_bus.set_exit_on_disconnect(False) # we'll disconnect later
kopete_bus = dbus.bus.BusConnection()
q.attach_to_bus(empathy_bus)
q.attach_to_bus(kopete_bus)
# Two clients want to observe, approve and handle channels
empathy = SimulatedClient(q,
empathy_bus,
'Empathy',
observe=[text_fixed_properties],
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
kopete = SimulatedClient(q,
kopete_bus,
'Kopete',
observe=[text_fixed_properties],
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [empathy, kopete])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [
cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'
], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
# Both Observers are told about the new channel
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert k.args == e.args
# Both Observers indicate that they are ready to proceed
q.dbus_return(k.message, bus=empathy_bus, signature='')
q.dbus_return(e.message, bus=kopete_bus, signature='')
# The Approvers are next
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
)
assert e.args == [[(chan.object_path, channel_properties)], cdo_path,
cdo_properties]
assert k.args == e.args
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Both Approvers now have a flashing icon or something, trying to get the
# user's attention
# Using an invalid Handler name should fail
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.The.Moon.On.A.Stick')
q.expect('dbus-error', method='HandleWith')
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.the moon on a stick')
q.expect('dbus-error', method='HandleWith')
# The user responds to Empathy first
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Empathy')
# Empathy is asked to handle the channels
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
# Empathy accepts the channels
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWith'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal',
interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# Approve another channel using HandleWithTime()
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'lucien'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'lucien')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'lucien'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'lucien')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [
cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'
], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
# Both Observers are told about the new channel
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert k.args == e.args
# Both Observers indicate that they are ready to proceed
q.dbus_return(k.message, bus=empathy_bus, signature='')
q.dbus_return(e.message, bus=kopete_bus, signature='')
# The Approvers are next
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
)
assert e.args == [[(chan.object_path, channel_properties)], cdo_path,
cdo_properties]
assert k.args == e.args
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Both Approvers now have a flashing icon or something, trying to get the
# user's attention
# The user responds to Empathy first
call_async(q, cdo_iface, 'HandleWithTime',
cs.tp_name_prefix + '.Client.Empathy', 13)
# Empathy is asked to handle the channels
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
account_path, conn_path, channels, requests, action_time, info = e.args
assert action_time == 13
# Empathy accepts the channels
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWithTime'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal',
interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# From now on, it is an error to get HandleChannels (because we're
# testing Claim())
forbidden = [
EventPattern('dbus-method-call', method='HandleChannels'),
]
q.forbid_events(forbidden)
# Another channel
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'mercutio'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'mercutio')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'mercutio'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'mercutio')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
claimed_chan = SimulatedChannel(conn, channel_properties)
claimed_chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [
cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'
], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
# Both Observers are told about the new channel
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == claimed_chan.object_path, channels
assert channels[0][1] == channel_properties, channels
assert k.args == e.args
# Both Observers indicate that they are ready to proceed
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.dbus_return(e.message, bus=empathy_bus, signature='')
# The Approvers are next
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
)
assert e.args == [[(claimed_chan.object_path, channel_properties)],
cdo_path, cdo_properties]
assert k.args == e.args
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Both Approvers now have a flashing icon or something, trying to get the
# user's attention
# The user responds to Empathy first, and Empathy decides it wants the
# channel for itself
empathy_cdo = empathy_bus.get_object(cdo.bus_name, cdo.object_path)
empathy_cdo_iface = dbus.Interface(empathy_cdo, cs.CDO)
call_async(q, empathy_cdo_iface, 'Claim')
q.expect_many(
EventPattern('dbus-signal', path=cdo_path, signal='Finished'),
EventPattern('dbus-signal',
path=cs.CD_PATH,
signal='DispatchOperationFinished',
args=[cdo_path]),
EventPattern('dbus-return', method='Claim'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# A third channel
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'benvolio'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'benvolio')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'benvolio'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'benvolio')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
third_chan = SimulatedChannel(conn, channel_properties)
third_chan.announce()
# third_chan should not be closed
q.unforbid_events(forbidden)
forbidden.append(
EventPattern('dbus-method-call',
method='Close',
path=third_chan.object_path))
q.forbid_events(forbidden)
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
)
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.dbus_return(e.message, bus=empathy_bus, signature='')
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
EventPattern('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
)
q.dbus_return(e.message, bus=empathy_bus, signature='')
q.dbus_return(k.message, bus=kopete_bus, signature='')
# Kopete closes this one
kopete_cdo = kopete_bus.get_object(cdo.bus_name, cdo.object_path)
kopete_cdo_iface = dbus.Interface(kopete_cdo, cs.CDO)
call_async(q, kopete_cdo_iface, 'Claim')
q.expect_many(
EventPattern('dbus-signal', path=cdo_path, signal='Finished'),
EventPattern('dbus-signal',
path=cs.CD_PATH,
signal='DispatchOperationFinished',
args=[cdo_path]),
EventPattern('dbus-return', method='Claim'),
)
# Empathy crashes
empathy.release_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(
lambda e: e.args[0] == empathy.bus_name and e.args[2] == ''),
)
empathy_unique_name = e.args[1]
empathy_bus.flush()
empathy_bus.close()
# In response, the channels that were being handled by Empathy are closed.
# Kopete's channel is *not* closed.
q.expect_many(
EventPattern('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e: e.args[0] == empathy_unique_name and
e.args[2] == '')),
EventPattern('dbus-method-call', path=chan.object_path,
method='Close'),
EventPattern('dbus-method-call',
path=claimed_chan.object_path,
method='Close'),
)
sync_dbus(bus, q, mc)
q.unforbid_events(forbidden)
def test(q, bus, mc):
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
# Two clients want to observe, approve and handle channels. Additionally,
# Kopete recognises an "Urgent" flag on certain incoming channels, and
# wants to bypass approval for them.
empathy = SimulatedClient(q, bus, 'Empathy',
observe=[text_fixed_properties], approve=[text_fixed_properties],
handle=[text_fixed_properties], bypass_approval=False)
kopete = SimulatedClient(q, bus, 'Kopete',
observe=[contact_text_fixed_properties],
approve=[contact_text_fixed_properties],
handle=[contact_text_fixed_properties], bypass_approval=False)
bypass = SimulatedClient(q, bus, 'Kopete.BypassApproval',
observe=[], approve=[],
handle=[urgent_fixed_properties], bypass_approval=True)
# wait for MC to download the properties
expect_client_setup(q, [empathy, kopete, bypass])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# First, a non-urgent channel is created
cdo_iface, chan, channel_properties, observe_events = announce_common(q,
bus, empathy, kopete, account, conn, cd_props, False)
# Both Observers indicate that they are ready to proceed
for e in observe_events:
q.dbus_return(e.message, signature='')
expect_and_exercise_approval(q, bus, chan, channel_properties,
empathy, kopete, cdo_iface, cd_props)
# Now a channel that bypasses approval comes in. During this process,
# we should never be asked to approve anything.
approval = [
EventPattern('dbus-method-call', method='AddDispatchOperation'),
]
q.forbid_events(approval)
cdo_iface, chan, channel_properties, observe_events = announce_common(q,
bus, empathy, kopete, account, conn, cd_props, True)
# Both Observers indicate that they are ready to proceed
for e in observe_events:
q.dbus_return(e.message, signature='')
# Kopete's BypassApproval part is asked to handle the channels
e = q.expect('dbus-method-call',
path=bypass.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Kopete accepts the channels
q.dbus_return(e.message, signature='')
q.unforbid_events(approval)
# Regression test for fd.o #22670
closure = [
EventPattern('dbus-method-call', method='Close'),
]
q.forbid_events(closure)
bypass.release_name()
sync_dbus(bus, q, mc)
q.unforbid_events(closure)
# Bring back that handler
del bypass
bypass = SimulatedClient(q, bus, 'Kopete.BypassApproval',
observe=[], approve=[],
handle=[urgent_fixed_properties], bypass_approval=True)
expect_client_setup(q, [bypass])
# Another channel that bypasses approval comes in, but the handler that
# bypasses approval fails.
cdo_iface, chan, channel_properties, observe_events = announce_common(q,
bus, empathy, kopete, account, conn, cd_props, True)
# Both Observers indicate that they are ready to proceed
for e in observe_events:
q.dbus_return(e.message, signature='')
# Kopete's BypassApproval part is asked to handle the channels
e = q.expect('dbus-method-call',
path=bypass.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Kopete's BypassApproval part fails to accept the channels
q.dbus_raise(e.message, 'com.example.Broken', 'No way')
# MC recovers by running the approvers and doing what they say
expect_and_exercise_approval(q, bus, chan, channel_properties,
empathy, kopete, cdo_iface, cd_props)
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary(
{
cs.TARGET_HANDLE_TYPE: cs.HT_CONTACT,
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_TEXT,
},
signature='sv')
# Logger is a text observer wanting recovery
logger = SimulatedClient(q,
bus,
'LoggerChat',
observe=[text_fixed_properties],
bypass_approval=False,
wants_recovery=True)
# gnome-shell is a text approver and handler
gs = SimulatedClient(q,
bus,
'GnomeShell',
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [logger, gs])
cd = bus.get_object(cs.CD, cs.CD_PATH)
# incoming text channel
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# gnome-shell's approver and logger's observer are notified
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=gs.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False),
)
channels, cdo_path, props = k.args
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
q.dbus_return(e.message, signature='')
q.dbus_return(k.message, signature='')
# gnome-shell claims the channel
call_async(q, cdo_iface, 'Claim')
e = q.expect('dbus-return', method='Claim')
# Logger crash
logger.release_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e: e.args[0] == logger.bus_name and e.args[2] == ''),
)
bus.flush()
# Logger gets restarted
logger.reacquire_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e: e.args[0] == logger.bus_name and e.args[1] == ''),
)
# Logger recovers the channel
e = q.expect('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False)
# gnome-shell which is handling the channel asks to re-ensure it
cd_iface = dbus.Interface(cd, cs.CD)
call_async(q, cd_iface, 'PresentChannel', chan.object_path, 0)
# gnome-shell is asked to re-handle the channel
e = q.expect('dbus-method-call',
path=gs.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
q.dbus_return(e.message, signature='')
q.expect('dbus-return', method='PresentChannel')
chan.close()
def test(q, bus, mc):
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary({
cs.TARGET_HANDLE_TYPE: cs.HT_CONTACT,
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_TEXT,
}, signature='sv')
# Logger is a text observer wanting recovery
logger = SimulatedClient(q, bus, 'LoggerChat',
observe=[text_fixed_properties],
bypass_approval=False,
wants_recovery=True)
# gnome-shell is a text approver and handler
gs = SimulatedClient(q, bus, 'GnomeShell',
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [logger, gs])
cd = bus.get_object(cs.CD, cs.CD_PATH)
# incoming text channel
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# gnome-shell's approver and logger's observer are notified
e, k = q.expect_many(
EventPattern('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False),
EventPattern('dbus-method-call',
path=gs.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False),
)
channels, cdo_path, props = k.args
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
q.dbus_return(e.message, signature='')
q.dbus_return(k.message, signature='')
# gnome-shell claims the channel
call_async(q, cdo_iface, 'Claim')
e = q.expect('dbus-return', method='Claim')
# Logger crash
logger.release_name()
e = q.expect('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e:
e.args[0] == logger.bus_name and e.args[2] == ''),
)
bus.flush()
# Logger gets restarted
logger.reacquire_name()
e = q.expect('dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e:
e.args[0] == logger.bus_name and e.args[1] == ''),
)
# Logger recovers the channel
e = q.expect('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False)
# gnome-shell which is handling the channel asks to re-ensure it
cd_iface = dbus.Interface(cd, cs.CD)
call_async(q, cd_iface, 'PresentChannel',
chan.object_path, 0)
# gnome-shell is asked to re-handle the channel
e = q.expect('dbus-method-call',
path=gs.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
q.dbus_return(e.message, signature='')
q.expect('dbus-return', method='PresentChannel')
chan.close()
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary(
{
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
},
signature='sv')
# We have more than one Client "head" on the same unique name, to test
# fd.o #24645 - we want the same "head" to be reinvoked if at all possible
# This one is first in alphabetical order, is discovered first, and can
# handle all channels, but is not the one we want
empathy_worse_match = SimulatedClient(q,
bus,
'A.Temporary.Handler',
observe=[],
approve=[],
handle=[[]],
bypass_approval=False)
# This is the one we actually want
empathy = SimulatedClient(q,
bus,
'Empathy',
observe=[text_fixed_properties],
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
# this one is a closer match, but not the preferred handler
closer_match = dbus.Dictionary(text_fixed_properties)
closer_match[cs.CHANNEL + '.TargetID'] = 'juliet'
empathy_better_match = SimulatedClient(q,
bus,
'Empathy.BetterMatch',
observe=[],
approve=[],
handle=[closer_match],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q,
[empathy_worse_match, empathy, empathy_better_match])
channel = test_channel_creation(q, bus, account, empathy, conn)
# After the channel has been dispatched, a handler that would normally
# be a closer match turns up. Regardless, we should not redispatch to it.
# For the better client to be treated as if it's in a different process,
# it needs its own D-Bus connection.
closer_match = dbus.Dictionary(text_fixed_properties)
closer_match[cs.CHANNEL + '.TargetID'] = 'juliet'
closer_match[cs.CHANNEL + '.InitiatorID'] = conn.self_ident
better_bus = dbus.bus.BusConnection()
q.attach_to_bus(better_bus)
better = SimulatedClient(q,
better_bus,
'BetterMatch',
observe=[],
approve=[],
handle=[closer_match],
bypass_approval=False)
expect_client_setup(q, [better])
test_channel_redispatch(q, bus, account, empathy, conn, channel)
test_channel_redispatch(q,
bus,
account,
empathy,
conn,
channel,
ungrateful_handler=True)
empathy.release_name()
empathy_better_match.release_name()
empathy_worse_match.release_name()
test_channel_redispatch(q,
bus,
account,
empathy,
conn,
channel,
client_gone=True)
channel.close()
def test(q, bus, mc):
# Two clients want to handle channels: MediaCall is running, and AbiWord
# is activatable.
# this must match the .client file
abi_contact_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_STREAM_TUBE,
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL_TYPE_STREAM_TUBE + '.Service': 'x-abiword',
}, signature='sv')
abi_room_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_STREAM_TUBE,
cs.CHANNEL + '.TargetHandleType': cs.HT_ROOM,
cs.CHANNEL_TYPE_STREAM_TUBE + '.Service': 'x-abiword',
}, signature='sv')
media_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_CALL,
}, signature='sv')
media_call = SimulatedClient(q, bus, 'MediaCall',
observe=[], approve=[], handle=[media_fixed_properties],
cap_tokens=[cs.CHANNEL_TYPE_CALL + '/ice',
cs.CHANNEL_TYPE_CALL + '/audio/speex',
cs.CHANNEL_TYPE_CALL + '/video/theora'],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [media_call])
def check_contact_caps(e):
structs = e.args[0]
filters = {}
tokens = {}
assert len(structs) == 3
for struct in structs:
assert struct[0] not in filters
filters[struct[0]] = sorted(struct[1])
tokens[struct[0]] = sorted(struct[2])
assert media_fixed_properties in filters[cs.CLIENT + '.MediaCall']
assert len(filters[cs.CLIENT + '.MediaCall']) == 1
assert abi_room_fixed_properties in filters[cs.CLIENT + '.AbiWord']
assert abi_contact_fixed_properties in filters[cs.CLIENT + '.AbiWord']
assert len(filters[cs.CLIENT + '.AbiWord']) == 2
assert len(tokens[cs.CLIENT + '.MediaCall']) == 3
assert cs.CHANNEL_TYPE_CALL + '/ice' in \
tokens[cs.CLIENT + '.MediaCall']
assert cs.CHANNEL_TYPE_CALL + '/audio/speex' in \
tokens[cs.CLIENT + '.MediaCall']
assert cs.CHANNEL_TYPE_CALL + '/video/theora' in \
tokens[cs.CLIENT + '.MediaCall']
assert len(tokens[cs.CLIENT + '.AbiWord']) == 2
assert 'com.example.Foo' in tokens[cs.CLIENT + '.AbiWord']
assert 'com.example.Bar' in tokens[cs.CLIENT + '.AbiWord']
return True
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn, before = enable_fakecm_account(q, bus, mc, account, params,
extra_interfaces=[cs.CONN_IFACE_CONTACT_CAPS],
expect_before_connect=[
EventPattern('dbus-method-call', handled=False,
interface=cs.CONN_IFACE_CONTACT_CAPS,
method='UpdateCapabilities',
predicate=check_contact_caps),
])
q.dbus_return(before.message, signature='')
irssi_bus = dbus.bus.BusConnection()
irssi_bus.set_exit_on_disconnect(False) # we'll disconnect later
q.attach_to_bus(irssi_bus)
irssi_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
cs.CHANNEL + '.TargetHandleType': cs.HT_ROOM,
}, signature='sv')
irssi = SimulatedClient(q, irssi_bus, 'Irssi',
observe=[], approve=[], handle=[irssi_fixed_properties],
cap_tokens=[],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [irssi])
e = q.expect('dbus-method-call', handled=False,
interface=cs.CONN_IFACE_CONTACT_CAPS,
method='UpdateCapabilities')
assert len(e.args[0]) == 1
struct = e.args[0][0]
assert struct[0] == cs.CLIENT + '.Irssi'
assert struct[1] == [irssi_fixed_properties]
assert struct[2] == []
# When Irssi exits, the CM is told it has gone
irssi.release_name()
del irssi
irssi_bus.flush()
irssi_bus.close()
e = q.expect('dbus-method-call', handled=False,
interface=cs.CONN_IFACE_CONTACT_CAPS,
method='UpdateCapabilities')
assert len(e.args[0]) == 1
struct = e.args[0][0]
assert struct[0] == cs.CLIENT + '.Irssi'
assert struct[1] == []
assert struct[2] == []
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
# Two clients want to observe, approve and handle channels. Additionally,
# Kopete recognises an "Urgent" flag on certain incoming channels, and
# wants to bypass approval for them.
empathy = SimulatedClient(q,
bus,
'Empathy',
observe=[text_fixed_properties],
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
kopete = SimulatedClient(q,
bus,
'Kopete',
observe=[contact_text_fixed_properties],
approve=[contact_text_fixed_properties],
handle=[contact_text_fixed_properties],
bypass_approval=False)
bypass = SimulatedClient(q,
bus,
'Kopete.BypassApproval',
observe=[],
approve=[],
handle=[urgent_fixed_properties],
bypass_approval=True)
# wait for MC to download the properties
expect_client_setup(q, [empathy, kopete, bypass])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# First, a non-urgent channel is created
cdo_iface, chan, channel_properties, observe_events = announce_common(
q, bus, empathy, kopete, account, conn, cd_props, False)
# Both Observers indicate that they are ready to proceed
for e in observe_events:
q.dbus_return(e.message, signature='')
expect_and_exercise_approval(q, bus, chan, channel_properties, empathy,
kopete, cdo_iface, cd_props)
# Now a channel that bypasses approval comes in. During this process,
# we should never be asked to approve anything.
approval = [
EventPattern('dbus-method-call', method='AddDispatchOperation'),
]
q.forbid_events(approval)
cdo_iface, chan, channel_properties, observe_events = announce_common(
q, bus, empathy, kopete, account, conn, cd_props, True)
# Both Observers indicate that they are ready to proceed
for e in observe_events:
q.dbus_return(e.message, signature='')
# Kopete's BypassApproval part is asked to handle the channels
e = q.expect('dbus-method-call',
path=bypass.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
# Kopete accepts the channels
q.dbus_return(e.message, signature='')
q.unforbid_events(approval)
# Regression test for fd.o #22670
closure = [
EventPattern('dbus-method-call', method='Close'),
]
q.forbid_events(closure)
bypass.release_name()
sync_dbus(bus, q, mc)
q.unforbid_events(closure)
# Bring back that handler
del bypass
bypass = SimulatedClient(q,
bus,
'Kopete.BypassApproval',
observe=[],
approve=[],
handle=[urgent_fixed_properties],
bypass_approval=True)
expect_client_setup(q, [bypass])
# Another channel that bypasses approval comes in, but the handler that
# bypasses approval fails.
cdo_iface, chan, channel_properties, observe_events = announce_common(
q, bus, empathy, kopete, account, conn, cd_props, True)
# Both Observers indicate that they are ready to proceed
for e in observe_events:
q.dbus_return(e.message, signature='')
# Kopete's BypassApproval part is asked to handle the channels
e = q.expect('dbus-method-call',
path=bypass.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
# Kopete's BypassApproval part fails to accept the channels
q.dbus_raise(e.message, 'com.example.Broken', 'No way')
# MC recovers by running the approvers and doing what they say
expect_and_exercise_approval(q, bus, chan, channel_properties, empathy,
kopete, cdo_iface, cd_props)
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary(
{
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL + '.Type.RespawnObservers'
},
signature='sv')
# Logger is an activatable Observer who will crash
logger_bus = dbus.bus.BusConnection()
logger_bus.set_exit_on_disconnect(False) # we'll disconnect later
# Kopete is an Approver, Handler and will not crash
kopete_bus = dbus.bus.BusConnection()
q.attach_to_bus(logger_bus)
q.attach_to_bus(kopete_bus)
kopete = SimulatedClient(q,
kopete_bus,
'Kopete',
observe=[],
approve=[text_fixed_properties],
handle=[text_fixed_properties],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [kopete])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
handlers.sort()
assert handlers == [cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.APPROVER,
method='AddDispatchOperation',
handled=False)
assert k.args == [[(chan.object_path, channel_properties)], cdo_path,
cdo_properties]
q.dbus_return(k.message, bus=kopete_bus, signature='')
# The fake Logger implementation is run
e = q.expect(
'dbus-signal',
path=cs.tp_path_prefix + '/RegressionTests',
interface=cs.tp_name_prefix + '.RegressionTests',
signal='FakeStartup',
args=[cs.tp_name_prefix + '.Client.Logger'],
)
# We take on its identity to be able to continue with the test
logger = SimulatedClient(q, bus, 'Logger', observe=[text_fixed_properties])
# Logger is told about the new channel
e = q.expect('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
# Logger indicates that it is ready to proceed
q.dbus_return(e.message, bus=logger_bus, signature='')
# The Approver (Kopete) is next
# The user responds to Kopete
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Kopete')
# Kopete is asked to handle the channels
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.HANDLER,
method='HandleChannels',
handled=False)
# Kopete accepts the channels
q.dbus_return(k.message, bus=kopete_bus, signature='')
q.expect_many(
EventPattern('dbus-return', method='HandleWith'),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal',
interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# Logger crashes
logger.release_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e: e.args[0] == logger.bus_name and e.args[2] == ''),
)
logger_unique_name = e.args[1]
logger_bus.flush()
# Logger gets restart request
e = q.expect(
'dbus-signal',
path=cs.tp_path_prefix + '/RegressionTests',
interface=cs.tp_name_prefix + '.RegressionTests',
signal='FakeStartup',
args=[cs.tp_name_prefix + '.Client.Logger'],
)
# Logger gets restarted
logger.reacquire_name()
e = q.expect(
'dbus-signal',
signal='NameOwnerChanged',
predicate=(lambda e: e.args[0] == logger.bus_name and e.args[1] == ''),
)
logger_unique_name = e.args[2]
e = q.expect('dbus-method-call',
path=logger.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False)
# FIXME: assert the same things as before, except CDO (which we don't
# have) and account path (which we don't know how to get); also check
# that the recovering observer info key is set
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
assert e.args[5]['recovering'] == 1, e.args # due to observer recovery
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
# Logger indicates that it is ready to proceed
q.dbus_return(e.message, bus=logger_bus, signature='')
sync_dbus(bus, q, mc)
def test(q, bus, mc):
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
}, signature='sv')
# We have more than one Client "head" on the same unique name, to test
# fd.o #24645 - we want the same "head" to be reinvoked if at all possible
# This one is first in alphabetical order, is discovered first, and can
# handle all channels, but is not the one we want
empathy_worse_match = SimulatedClient(q, bus, 'A.Temporary.Handler',
observe=[], approve=[],
handle=[[]], bypass_approval=False)
# This is the one we actually want
empathy = SimulatedClient(q, bus, 'Empathy',
observe=[text_fixed_properties], approve=[text_fixed_properties],
handle=[text_fixed_properties], bypass_approval=False)
# this one is a closer match, but not the preferred handler
closer_match = dbus.Dictionary(text_fixed_properties)
closer_match[cs.CHANNEL + '.TargetID'] = 'juliet'
empathy_better_match = SimulatedClient(q, bus, 'Empathy.BetterMatch',
observe=[], approve=[],
handle=[closer_match], bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [empathy_worse_match, empathy,
empathy_better_match])
channel = test_channel_creation(q, bus, account, empathy, conn)
# After the channel has been dispatched, a handler that would normally
# be a closer match turns up. Regardless, we should not redispatch to it.
# For the better client to be treated as if it's in a different process,
# it needs its own D-Bus connection.
closer_match = dbus.Dictionary(text_fixed_properties)
closer_match[cs.CHANNEL + '.TargetID'] = 'juliet'
closer_match[cs.CHANNEL + '.InitiatorID'] = conn.self_ident
better_bus = dbus.bus.BusConnection()
q.attach_to_bus(better_bus)
better = SimulatedClient(q, better_bus, 'BetterMatch',
observe=[], approve=[],
handle=[closer_match], bypass_approval=False)
expect_client_setup(q, [better])
test_channel_redispatch(q, bus, account, empathy, conn, channel)
test_channel_redispatch(q, bus, account, empathy, conn, channel,
ungrateful_handler=True)
empathy.release_name()
empathy_better_match.release_name()
empathy_worse_match.release_name()
test_channel_redispatch(q, bus, account, empathy, conn, channel,
client_gone=True)
channel.close()