def test(q, bus, conn):
# last value of the "ver" key we resolved. We use it to be sure that the
# modified caps has already be announced.
old_ver = None
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0, 0])
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
ver = txt_get_key(e.txt, "ver")
while ver == old_ver:
# be sure that the announced caps actually changes
e = q.expect('service-resolved', service=service)
ver = txt_get_key(e.txt, "ver")
old_ver = ver
caps = compute_caps_hash(['client/pc//%s' % PACKAGE_STRING],
fixed_features, {})
assertEquals(caps, ver)
test_ft_caps_from_contact(q, bus, conn, service, 'yo@momma')
test_ft_caps_to_contact(q, bus, conn, service)
def _resolve_salut_presence(self):
AvahiListener(self.q).listen_for_service("_presence._tcp")
e = self.q.expect('service-added',
name=self.self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = self.q.expect('service-resolved', service=service)
return str(e.pt), e.port
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
basic_txt = {"txtvers": "1", "status": "avail"}
contact_name = "test-text-channel@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port, basic_txt)
handle = wait_for_contact_in_publish(q, bus, conn, contact_name)
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
xmpp_connection = connect_to_stream(q, contact_name, self_handle_name,
str(e.pt), e.port)
e = q.expect('connection-result')
assert e.succeeded, e.reason
e = q.expect('stream-opened', connection=xmpp_connection)
# connected to salut, now send a messages as composing part
# here be sillyness
parts = OUTGOING_MESSAGE.split(" ")
for x in xrange(1, len(parts)):
message = domish.Element(('', 'message'))
message.addElement('body', content=' '.join(parts[:x]))
event = message.addElement('x', 'jabber:x:event')
event.addElement('composing')
event.addElement('id')
xmpp_connection.send(message)
message = domish.Element(('', 'message'))
message.addElement('body', content=OUTGOING_MESSAGE)
event = message.addElement('x', 'jabber:x:event')
event.addElement('composing')
xmpp_connection.send(message)
e = q.expect('dbus-signal', signal='Received')
assert e.args[2] == handle
assert e.args[5] == OUTGOING_MESSAGE
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal',
signal='StatusChanged',
args=[cs.CONN_STATUS_CONNECTED, cs.CSR_NONE_SPECIFIED])
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
def wait_for_presence_announce():
e = q.expect('service-resolved', service=service)
return txt_get_key(e.txt, 'status'), txt_get_key(e.txt, 'msg')
# initial presence is available
status, msg = wait_for_presence_announce()
assert status == 'avail', status
assert msg is None, msg
statuses = conn.Get(cs.CONN_IFACE_SIMPLE_PRESENCE,
'Statuses',
dbus_interface=dbus.PROPERTIES_IFACE)
assert 'available' in statuses
assert 'dnd' in statuses
assert 'away' in statuses
simple_presence = dbus.Interface(conn, cs.CONN_IFACE_SIMPLE_PRESENCE)
# set your status to away
simple_presence.SetPresence('away', 'At the pub')
status, msg = wait_for_presence_announce()
assert status == 'away', status
assert msg == 'At the pub', msg
# set your status to available without msg
simple_presence.SetPresence('available', '')
status, msg = wait_for_presence_announce()
assert status == 'avail', status
assert msg is None, msg
conn.Disconnect()
q.expect('dbus-signal',
signal='StatusChanged',
args=[cs.CONN_STATUS_DISCONNECTED, cs.CSR_REQUESTED])
def test(q, bus, conn):
# last value of the "ver" key we resolved. We use it to be sure that the
# modified caps has already be announced.
old_ver = None
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
ver = txt_get_key(e.txt, "ver")
while ver == old_ver:
# be sure that the announced caps actually changes
e = q.expect('service-resolved', service=service)
ver = txt_get_key(e.txt, "ver")
old_ver = ver
# We support OOB file transfer
caps = compute_caps_hash(['client/pc//%s' % PACKAGE_STRING],
fixed_features, {})
check_caps_txt(e.txt, caps)
conn_caps_iface = dbus.Interface(conn, cs.CONN_IFACE_CONTACT_CAPS)
# Advertise nothing
conn_caps_iface.UpdateCapabilities([])
service.resolve()
e = q.expect('service-resolved', service=service)
# Announced capa didn't change
caps = compute_caps_hash(['client/pc//%s' % PACKAGE_STRING],
fixed_features, {})
check_caps_txt(e.txt, caps)
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
basic_txt = {"txtvers": "1", "status": "avail"}
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
contact_name = "test-ichat-incoming-msg@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port, basic_txt)
handle = wait_for_contact_in_publish(q, bus, conn, contact_name)
# Create a connection to send msg stanza
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
outbound = connect_to_stream(q, contact_name, self_handle_name, str(e.pt),
e.port, OutgoingXmppiChatStream)
e = q.expect('connection-result')
assert e.succeeded, e.reason
e = q.expect('stream-opened', connection=outbound)
msg = domish.Element((None, 'message'))
msg['to'] = self_handle_name
msg['type'] = 'chat'
boddy = msg.addElement('body', content='hi')
outbound.send(msg)
e = q.expect('dbus-signal', signal='Received')
assert e.args[2] == handle
assert e.args[3] == cs.MT_NORMAL
assert e.args[5] == "hi"
def test(q, bus, conn):
AvahiListener(q).listen_for_service("_presence._tcp")
conn.Connect()
e = q.expect('service-added',
name=PUBLISHED_NAME + "@" + avahitest.get_host_name())
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
for (key, val) in {
"1st": FIRST_NAME,
"last": LAST_NAME,
"status": "avail",
"txtvers": "1"
}.iteritems():
v = txt_get_key(e.txt, key)
assert v == val, (key, val, v)
def setup_incoming_tests(q, bus, conn):
handle, contact_name, listener = setup_tests(q, bus, conn)
self_handle = conn.GetSelfHandle()
self_handle_name = conn.InspectHandles(cs.HT_CONTACT, [self_handle])[0]
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
outbound = connect_to_stream(q, contact_name, self_handle_name, str(e.pt),
e.port)
e = q.expect('connection-result')
assert e.succeeded, e.reason
e = q.expect('stream-opened', connection=outbound)
iq = IQ(None, 'get')
iq['id'] = 'le-loldongs'
iq['from'] = contact_name
iq['to'] = self_handle_name
msg = iq.addElement((ycs.MESSAGE_NS, 'message'))
msg['from-service'] = 'the.from.service'
msg['to-service'] = 'the.to.service'
msg['owl-companions'] = 'the pussy cat'
msg['destination'] = 'sea'
msg['seacraft'] = 'beautiful pea green boat'
lol = msg.addElement((None, 'lol'))
lol['some'] = 'stuff'
lol['to'] = 'fill'
lol['the'] = 'time'
lol.addElement((None, 'look-into-my-eyes'),
content='and tell me how boring writing these tests is')
outbound.send(iq)
e = q.expect('dbus-signal',
signal='NewChannels',
predicate=lambda e: e.args[0][0][1][cs.CHANNEL_TYPE] == ycs.
CHANNEL_IFACE)
path, props = e.args[0][0]
assertEquals(handle, props[cs.INITIATOR_HANDLE])
assertEquals(contact_name, props[cs.INITIATOR_ID])
assertEquals(False, props[cs.REQUESTED])
assertEquals(handle, props[cs.TARGET_HANDLE])
assertEquals(cs.HT_CONTACT, props[cs.TARGET_HANDLE_TYPE])
assertEquals(contact_name, props[cs.TARGET_ID])
assertEquals('the.from.service', props[ycs.INITIATOR_SERVICE])
assertEquals('the.to.service', props[ycs.TARGET_SERVICE])
assertEquals(ycs.REQUEST_TYPE_GET, props[ycs.REQUEST_TYPE])
assertEquals(
{
'destination': 'sea',
'owl-companions': 'the pussy cat',
'seacraft': 'beautiful pea green boat'
}, props[ycs.REQUEST_ATTRIBUTES])
assertEquals('<?xml version="1.0" encoding="UTF-8"?>\n' \
'<message seacraft="beautiful pea green boat" ' \
'from-service="the.from.service" destination="sea" ' \
'owl-companions="the pussy cat" to-service="the.to.service" ' \
'xmlns="urn:ytstenut:message">' \
'<lol to="fill" the="time" some="stuff">' \
'<look-into-my-eyes>and tell me how boring ' \
'writing these tests is</look-into-my-eyes>' \
'</lol></message>\n', props[ycs.REQUEST_BODY])
# finally we have our channel
chan = wrap_channel(bus, conn, path)
# let's check we can't call Request()
call_async(q, chan, 'Request')
q.expect('dbus-error', method='Request')
return chan, outbound, contact_name, self_handle_name
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
basic_txt = {"txtvers": "1", "status": "avail"}
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
contact_name = "test-muc@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
AvahiAnnouncer(contact_name, "_presence._tcp", port, basic_txt)
handle = wait_for_contact_in_publish(q, bus, conn, contact_name)
requests_iface = dbus.Interface(conn, cs.CONN_IFACE_REQUESTS)
# Create a connection to send the muc invite
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
outbound = connect_to_stream(q, contact_name, self_handle_name, str(e.pt),
e.port)
e = q.expect('connection-result')
assert e.succeeded, e.reason
e = q.expect('stream-opened', connection=outbound)
# connected to Salut, now send the muc invite
msg = domish.Element((None, 'message'))
msg['to'] = self_handle_name
msg['from'] = contact_name
msg['type'] = 'normal'
body = msg.addElement('body',
content='You got a Clique chatroom invitation')
invite = msg.addElement((NS_CLIQUE, 'invite'))
invite.addElement('roomname', content='my-room')
invite.addElement('reason', content='Inviting to this room')
# FIXME: we should create a real Clique room and use its IP and port.
# Hardcode values for now. The IP is a multicast address.
invite.addElement('address', content='239.255.71.249')
invite.addElement('port', content='62472')
outbound.send(msg)
e = q.expect('dbus-signal',
signal='NewChannels',
predicate=lambda e: e.args[0][0][1][cs.CHANNEL_TYPE] == cs.
CHANNEL_TYPE_TEXT)
channels = e.args[0]
assert len(channels) == 1
path, props = channels[0]
channel = make_channel_proxy(conn, path, "Channel")
channel_group = make_channel_proxy(conn, path, "Channel.Interface.Group")
# check channel properties
# org.freedesktop.Telepathy.Channel D-Bus properties
assert props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_TEXT
assertContains(cs.CHANNEL_IFACE_GROUP, props[cs.INTERFACES])
assertContains(cs.CHANNEL_IFACE_MESSAGES, props[cs.INTERFACES])
assert props[cs.TARGET_ID] == 'my-room'
assert props[cs.TARGET_HANDLE_TYPE] == HT_ROOM
assert props[cs.REQUESTED] == False
assert props[cs.INITIATOR_HANDLE] == handle
assert props[cs.INITIATOR_ID] == contact_name
# we are added to local pending
e = q.expect('dbus-signal', signal='MembersChanged')
msg, added, removed, lp, rp, actor, reason = e.args
assert msg == 'Inviting to this room'
assert added == []
assert removed == []
assert lp == [self_handle]
assert rp == []
assert actor == handle
assert reason == 4 # invited
# TODO: join the muc, check if we are added to remote-pending and then
# to members. This would need some tweak in Salut and/or the test framework
# as Clique takes too much time to join the room and so the event times
# out.
# TODO: test sending invitations
# FIXME: fd.o #30531: this ought to work, but doesn't
#channel_group.RemoveMembersWithReason([self_handle], "bored now", 0)
channel.Close()
q.expect('dbus-signal', signal='Closed')
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
basic_txt = {"txtvers": "1", "status": "avail"}
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
contact_name = "test-text-channel@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port, basic_txt)
handle = wait_for_contact_in_publish(q, bus, conn, contact_name)
# create a clique room
basic_txt = {"txtvers": "0"}
AvahiAnnouncer("myroom", "_clique._udp", 41377, basic_txt)
# connect a stream
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service=service)
xmpp_connection = connect_to_stream(q, contact_name, self_handle_name,
str(e.pt), e.port)
e = q.expect('connection-result')
assert e.succeeded, e.reason
e = q.expect('stream-opened', connection=xmpp_connection)
# send an invitation
message = domish.Element(('', 'message'))
message['type'] = 'normal'
message.addElement('body', content='You got a Clique chatroom invitation')
invite = message.addElement((NS_CLIQUE, 'invite'))
invite.addElement('roomname', content='myroom')
invite.addElement('reason', content='Inviting to this room')
invite.addElement('address', content='127.0.0.1')
invite.addElement('port', content='41377')
xmpp_connection.send(message)
# group channel is created
e = q.expect('dbus-signal',
signal='NewChannel',
predicate=lambda e: e.args[1] == cs.CHANNEL_TYPE_TEXT and e.
args[2] == cs.HT_ROOM)
path = e.args[0]
channel = make_channel_proxy(conn, path, 'Channel')
props_iface = dbus.Interface(bus.get_object(conn.object.bus_name, path),
dbus.PROPERTIES_IFACE)
q.expect('dbus-signal', signal='MembersChanged', path=path)
lp_members = props_iface.Get(
'org.freedesktop.Telepathy.Channel.Interface.Group',
'LocalPendingMembers')
assert len(lp_members) == 1
added, actor, reason, msg = lp_members[0]
assert added == self_handle
assert actor == handle
assert reason == 4 #invited
assert msg == 'Inviting to this room'
# decline invitation
channel.Close()
q.expect('dbus-signal', signal='Closed')
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
basic_txt = { "txtvers": "1", "status": "avail" }
contact_name = "test-text-channel@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port, basic_txt)
handle = wait_for_contact_in_publish(q, bus, conn, contact_name)
t = conn.Requests.CreateChannel({
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_TEXT,
cs.TARGET_HANDLE_TYPE: cs.HT_CONTACT,
cs.TARGET_HANDLE: handle})[0]
text_channel = make_channel_proxy(conn, t, "Channel.Type.Text")
text_channel.Send(cs.MT_NORMAL, INCOMING_MESSAGE)
e = q.expect('incoming-connection', listener = listener)
incoming = e.connection
e = q.expect('stream-message', connection = incoming)
assert e.message_type == "chat"
body = xpath.queryForNodes("/message/body", e.stanza )
assert map(str, body) == [ INCOMING_MESSAGE ]
# drop the connection
incoming.transport.loseConnection()
# Now send a message to salut
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added', name = self_handle_name,
protocol = avahi.PROTO_INET)
service = e.service
service.resolve()
e = q.expect('service-resolved', service = service)
outbound = connect_to_stream(q, contact_name,
self_handle_name, str(e.pt), e.port)
e = q.expect('connection-result')
assert e.succeeded, e.reason
e = q.expect('stream-opened', connection = outbound)
# connected to salut, now send a message
message = domish.Element(('', 'message'))
message['type'] = "chat"
message.addElement('body', content=OUTGOING_MESSAGE)
e.connection.send(message)
e = q.expect('dbus-signal', signal='Received')
assert e.args[2] == handle
assert e.args[3] == cs.MT_NORMAL
assert e.args[5] == OUTGOING_MESSAGE
def test_ft_caps_from_contact(q, bus, conn, client):
conn_caps_iface = dbus.Interface(conn, cs.CONN_IFACE_CONTACT_CAPS)
conn_contacts_iface = dbus.Interface(conn, cs.CONN_IFACE_CONTACTS)
# send presence with FT capa
ver = compute_caps_hash([], [ns.IQ_OOB], {})
txt_record = {
"txtvers": "1",
"status": "avail",
"node": client,
"ver": ver,
"hash": "sha-1"
}
contact_name = "test-caps-ft@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port,
txt_record)
# this is the first presence, Salut connects to the contact
e = q.expect('incoming-connection', listener=listener)
incoming = e.connection
# Salut looks up our capabilities
event = q.expect('stream-iq',
connection=incoming,
query_ns='http://jabber.org/protocol/disco#info')
query_node = xpath.queryForNodes('/iq/query', event.stanza)[0]
assert query_node.attributes['node'] == \
client + '#' + ver, (query_node.attributes['node'], client, ver)
contact_handle = conn_contacts_iface.GetContactByID(contact_name, [])[0]
# send good reply
result = make_result_iq(event.stanza)
query = result.firstChildElement()
query['node'] = client + '#' + ver
feature = query.addElement('feature')
feature['var'] = ns.IQ_OOB
incoming.send(result)
# FT capa is announced
e = q.expect('dbus-signal',
signal='ContactCapabilitiesChanged',
predicate=lambda e: contact_handle in e.args[0])
caps = e.args[0][contact_handle]
assertContains(ft_caps, caps)
# check the Contacts interface give the same caps
caps_via_contacts_iface = conn_contacts_iface.GetContactAttributes(
[contact_handle], [cs.CONN_IFACE_CONTACT_CAPS], False) \
[contact_handle][cs.CONN_IFACE_CONTACT_CAPS + '/capabilities']
assert caps_via_contacts_iface == caps, caps_via_contacts_iface
# check if Salut announces the OOB capa
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_handle_name = conn.Properties.Get(cs.CONN, "SelfID")
AvahiListener(q).listen_for_service("_presence._tcp")
e = q.expect('service-added',
name=self_handle_name,
protocol=avahi.PROTO_INET)
service = e.service
service.resolve()
receive_presence_and_ask_caps(q, incoming, service, contact_name)
# capa announced without FT
ver = compute_caps_hash([], ["http://telepathy.freedesktop.org/xmpp/pony"],
{})
txt_record = {
"txtvers": "1",
"status": "avail",
"node": client,
"ver": ver,
"hash": "sha-1"
}
contact_name = "test-caps-ft2@" + get_host_name()
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port,
txt_record)
# this is the first presence, Salut connects to the contact
e = q.expect('incoming-connection', listener=listener)
incoming = e.connection
# Salut looks up our capabilities
event = q.expect('stream-iq',
connection=incoming,
query_ns='http://jabber.org/protocol/disco#info')
query_node = xpath.queryForNodes('/iq/query', event.stanza)[0]
assert query_node.attributes['node'] == \
client + '#' + ver, (query_node.attributes['node'], client, ver)
contact_handle = conn_contacts_iface.GetContactByID(contact_name, [])[0]
# send good reply
result = make_result_iq(event.stanza)
query = result.firstChildElement()
query['node'] = client + '#' + ver
feature = query.addElement('feature')
feature['var'] = "http://telepathy.freedesktop.org/xmpp/pony"
incoming.send(result)
# the FT capability is not announced
e = q.expect('dbus-signal', signal='ContactCapabilitiesChanged')
caps = e.args[0][contact_handle]
assertDoesNotContain(ft_caps, caps)
# check the Contacts interface give the same caps
caps_via_contacts_iface = conn_contacts_iface.GetContactAttributes(
[contact_handle], [cs.CONN_IFACE_CONTACT_CAPS], False) \
[contact_handle][cs.CONN_IFACE_CONTACT_CAPS + '/capabilities']
assert caps_via_contacts_iface == caps, caps_via_contacts_iface
# no capabilites announced (assume FT is supported to insure interop)
txt_record = {"txtvers": "1", "status": "avail"}
contact_name = "test-caps-ft-no-capa2@" + get_host_name()
contact_handle = conn_contacts_iface.GetContactByID(contact_name, [])[0]
listener, port = setup_stream_listener(q, contact_name)
announcer = AvahiAnnouncer(contact_name, "_presence._tcp", port,
txt_record)
# FT capa is announced
e = q.expect('dbus-signal',
signal='ContactCapabilitiesChanged',
predicate=lambda e: contact_handle in e.args[0].keys())
caps = e.args[0][contact_handle]
assertContains(ft_caps, caps)
# check the Contacts interface give the same caps
caps_via_contacts_iface = conn_contacts_iface.GetContactAttributes(
[contact_handle], [cs.CONN_IFACE_CONTACT_CAPS], False) \
[contact_handle][cs.CONN_IFACE_CONTACT_CAPS + '/capabilities']
assert caps_via_contacts_iface == caps, caps_via_contacts_iface
def test(q, bus, conn):
conn.Connect()
q.expect('dbus-signal', signal='StatusChanged', args=[0L, 0L])
activity_txt = { "type": "org.laptop.HelloMesh",
"name": "HelloMesh",
"color": "#7b83c1,#260993",
"txtvers": "0",
"activity-id": ACTIVITY_ID,
"room": ACTIVITY_ID
}
# Listen for announcements
l = AvahiListener(q).listen_for_service("_olpc-activity1._udp")
# Assert that the testsuite doesn't announce the activity
service_name = ACTIVITY_ID + ":" + TESTSUITE_PUBLISHED_NAME + "@" + get_host_name()
forbiden_event = EventPattern('service-added', name=service_name)
q.forbid_events([forbiden_event])
contact_name = PUBLISHED_NAME + "@" + get_host_name()
activity_name = ACTIVITY_ID + ":" + PUBLISHED_NAME + "@" + get_host_name()
AvahiAnnouncer(contact_name, "_presence._tcp", 1234, {})
act_hostname = ACTIVITY_ID + ":" + PUBLISHED_NAME + \
"._clique._udp." + get_domain_name()
act_address = "239.253.70.70"
announce_address(act_hostname, act_address)
# FIXME, if we use the same name as the running salut will MembersChanged
# isn't signalled later on, needs to be fixed.
AvahiAnnouncer(ACTIVITY_ID + ":" + PUBLISHED_NAME,
"_clique._udp", 12345, {}, hostname = act_hostname)
AvahiAnnouncer(activity_name, "_olpc-activity1._udp",
0, activity_txt)
# Publish a contact, now get it's handle
handle = wait_for_contact_in_publish(q, bus, conn, contact_name)
# Assert that the remote handles signals it joined the activity
while True:
e = q.expect('dbus-signal', signal = 'ActivitiesChanged')
if e.args[0] == handle and e.args[1] != []:
assert len(e.args[1]) == 1
assert e.args[1][0][0] == ACTIVITY_ID
activity_handle = e.args[1][0][1]
break
act_prop_iface = dbus.Interface(conn, cs.ACTIVITY_PROPERTIES)
act_properties = act_prop_iface.GetProperties(activity_handle)
assert act_properties['private'] == False
assert act_properties['color'] == activity_txt['color']
assert act_properties['name'] == activity_txt['name']
assert act_properties['type'] == activity_txt['type']
room_channel = conn.RequestChannel(CHANNEL_TYPE_TEXT,
HT_ROOM, activity_handle, True)
q.expect('dbus-signal', signal='MembersChanged', path=room_channel,
args = [u'', [1L], [], [], [], 1L, 0L])
# Make it public that we joined the activity
q.unforbid_events([forbiden_event])
buddy_info_iface = dbus.Interface(conn, cs.BUDDY_INFO)
buddy_info_iface.SetActivities([(ACTIVITY_ID, activity_handle)])
q.expect('service-added',
name = ACTIVITY_ID + ":" + TESTSUITE_PUBLISHED_NAME +
"@" + get_host_name())
buddy_info_iface.SetActivities([])
q.expect('service-removed',
name = ACTIVITY_ID + ":" + TESTSUITE_PUBLISHED_NAME +
"@" + get_host_name())