def test_publish_avatar_set(self):
# set the cache to indicate the server has PEP
avatar_set = avatar_service.AvatarSet()
avatar_set.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
with unittest.mock.patch.object(self.pep, "publish",
new=CoroutineMock()):
run_coroutine(self.s.publish_avatar_set(avatar_set))
self.assertSequenceEqual(
self.pep.publish.mock_calls,
[
unittest.mock.call(
namespaces.xep0084_data,
unittest.mock.ANY,
id_=avatar_set.png_id
),
unittest.mock.call(
namespaces.xep0084_metadata,
avatar_set.metadata,
id_=avatar_set.png_id
)
],
)
_, args, _ = self.pep.publish.mock_calls[0]
data = args[1]
self.assertTrue(isinstance(data, avatar_xso.Data))
self.assertEqual(data.data, avatar_set.image_bytes)
def test_get_avatar_metadata_with_require_fresh_does_not_crash(self):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
aset.add_avatar_image("image/png",
nbytes=0,
id_="00000000000000000000",
url="http://example.com/avatar")
# construct the proper pubsub response
items = pubsub_xso.Items(namespaces.xep0084_metadata, )
item = pubsub_xso.Item(id_=aset.png_id)
item.registered_payload = aset.metadata
items.items.append(item)
pubsub_result = pubsub_xso.Request(items)
with unittest.mock.patch.object(self.pubsub,
"get_items",
new=CoroutineMock()):
self.pubsub.get_items.return_value = pubsub_result
run_coroutine(
self.s.get_avatar_metadata(TEST_JID1, require_fresh=True))
self.assertSequenceEqual(self.pubsub.get_items.mock_calls, [
unittest.mock.call(
TEST_JID1, namespaces.xep0084_metadata, max_items=1)
])
def test_error_two_items_with_image_data(self):
with self.assertRaisesRegex(
RuntimeError,
"^Only one avatar image may be published directly\.$"):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
aset.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
def test_error_redundant_sha_mismatch(self):
with self.assertRaisesRegex(
RuntimeError,
"^The given id does not match the SHA1 of the image data\.$"):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
id_="00000000000000000000",
image_bytes=TEST_IMAGE)
def test_error_no_image_given(self):
with self.assertRaisesRegex(
RuntimeError,
"^Either the image bytes or an url to retrieve the avatar "):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
id_="00000000000000000000",
nbytes=0)
def test_error_nbytes_missing(self):
with self.assertRaisesRegex(
RuntimeError,
"^Image data length is not given an not inferable "):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
id_="00000000000000000000",
url="http://example.com/avatar")
def test_error_id_missing(self):
with self.assertRaisesRegex(
RuntimeError,
"^The SHA1 of the image data is not given an not inferable "):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
nbytes=1024,
url="http://example.com/avatar")
def test_error_redundant_nbytes_mismatch(self):
with self.assertRaisesRegex(
RuntimeError, "^The given length does not match the length "
"of the image data\.$"):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
nbytes=0,
image_bytes=TEST_IMAGE)
def test_error_image_data_for_something_other_than_png(self):
with self.assertRaisesRegex(
RuntimeError,
"^The image bytes can only be given for image/png data\.$"):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/gif",
nbytes=1024,
id_="00000000000000000000",
image_bytes=TEST_IMAGE)
def test_correct_redundant_information_is_ignored(self):
try:
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
image_bytes=TEST_IMAGE,
nbytes=len(TEST_IMAGE),
id_=TEST_IMAGE_SHA1)
except RuntimeError:
self.fail("raises on correct redundant information")
def test_png_id_is_normalized(self):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png",
image_bytes=TEST_IMAGE,
id_=TEST_IMAGE_SHA1.upper())
self.assertEqual(
aset.metadata.info["image/png"][0].id_,
avatar_service.normalize_id(TEST_IMAGE_SHA1),
)
def test_handle_pubsub_publish(self):
self.assertTrue(aioxmpp.service.is_attrsignal_handler(
avatar_service.AvatarService.avatar_pep,
"on_item_publish",
self.s._handle_pubsub_publish
))
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
aset.add_avatar_image("image/png",
nbytes=0,
id_="00000000000000000000",
url="http://example.com/avatar")
# construct the proper pubsub response
item = pubsub_xso.EventItem(aset.metadata, id_=aset.png_id)
mock_handler = unittest.mock.Mock()
self.s.on_metadata_changed.connect(mock_handler)
self.s._handle_pubsub_publish(
TEST_JID1,
namespaces.xep0084_metadata,
item)
descriptors = self.s._metadata_cache[TEST_JID1]
self.assertEqual(len(descriptors), 2)
png_descr = descriptors
self.assertTrue(isinstance(png_descr[0],
avatar_service.PubsubAvatarDescriptor))
self.assertEqual(png_descr[0].mime_type, "image/png")
self.assertEqual(png_descr[0].id_, TEST_IMAGE_SHA1)
self.assertEqual(png_descr[0].nbytes, len(TEST_IMAGE))
self.assertEqual(png_descr[0].url, None)
self.assertTrue(isinstance(png_descr[0],
avatar_service.PubsubAvatarDescriptor))
self.assertEqual(png_descr[1].mime_type, "image/png")
self.assertEqual(png_descr[1].id_, "00000000000000000000")
self.assertEqual(png_descr[1].nbytes, 0)
self.assertEqual(png_descr[1].url, "http://example.com/avatar")
mock_handler.assert_called_with(TEST_JID1, descriptors)
def test_construction(self):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
aset.add_avatar_image("image/png",
nbytes=0,
id_="0000000000",
url="http://example.com/avatar")
self.assertEqual(
aset.image_bytes,
TEST_IMAGE
)
self.assertEqual(
aset.png_id,
TEST_IMAGE_SHA1,
)
self.assertEqual(
aset.metadata.info["image/png"][0].nbytes,
len(TEST_IMAGE)
)
self.assertEqual(
aset.metadata.info["image/png"][0].id_,
TEST_IMAGE_SHA1,
)
self.assertEqual(
aset.metadata.info["image/png"][1].nbytes,
0,
)
self.assertEqual(
aset.metadata.info["image/png"][1].id_,
"0000000000",
)
self.assertEqual(
aset.metadata.info["image/png"][1].url,
"http://example.com/avatar",
)
def test_publish_avatar_set_synchronize_vcard_pep_raises(self):
avatar_set = avatar_service.AvatarSet()
avatar_set.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
self.s.synchronize_vcard = True
with contextlib.ExitStack() as e:
e.enter_context(unittest.mock.patch.object(self.pep, "publish",
new=CoroutineMock()))
e.enter_context(unittest.mock.patch.object(self.presence_server,
"resend_presence"))
e.enter_context(unittest.mock.patch.object(self.vcard, "get_vcard",
new=CoroutineMock()))
e.enter_context(unittest.mock.patch.object(self.vcard, "set_vcard",
new=CoroutineMock()))
# do not do the vcard operations of pep is available but
# fails
self.pep.publish.side_effect = RuntimeError
self.vcard.get_vcard.return_value = unittest.mock.Mock()
with self.assertRaises(RuntimeError):
run_coroutine(self.s.publish_avatar_set(avatar_set))
self.assertSequenceEqual(
self.presence_server.resend_presence.mock_calls,
[]
)
self.assertSequenceEqual(
self.vcard.get_vcard.mock_calls,
[]
)
self.assertSequenceEqual(
self.vcard.set_vcard.mock_calls,
[]
)
def test_get_avatar_metadata(self):
aset = avatar_service.AvatarSet()
aset.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
aset.add_avatar_image("image/png",
nbytes=0,
id_="00000000000000000000",
url="http://example.com/avatar")
# construct the proper pubsub response
items = pubsub_xso.Items(
namespaces.xep0084_metadata,
)
item = pubsub_xso.Item(id_=aset.png_id)
item.registered_payload = aset.metadata
items.items.append(item)
pubsub_result = pubsub_xso.Request(items)
with unittest.mock.patch.object(self.pubsub, "get_items",
new=CoroutineMock()):
self.pubsub.get_items.return_value = pubsub_result
descriptors = run_coroutine(self.s.get_avatar_metadata(TEST_JID1))
self.assertSequenceEqual(
self.pubsub.get_items.mock_calls,
[
unittest.mock.call(
TEST_JID1,
namespaces.xep0084_metadata,
max_items=1
)
]
)
self.assertEqual(len(descriptors), 2)
png_descr = descriptors
self.assertTrue(isinstance(png_descr[0],
avatar_service.PubsubAvatarDescriptor))
self.assertEqual(png_descr[0].mime_type, "image/png")
self.assertEqual(png_descr[0].id_, TEST_IMAGE_SHA1)
self.assertEqual(png_descr[0].nbytes, len(TEST_IMAGE))
self.assertEqual(png_descr[0].url, None)
self.assertTrue(isinstance(png_descr[0],
avatar_service.PubsubAvatarDescriptor))
self.assertEqual(png_descr[1].mime_type, "image/png")
self.assertEqual(png_descr[1].id_, "00000000000000000000")
self.assertEqual(png_descr[1].nbytes, 0)
self.assertEqual(png_descr[1].url, "http://example.com/avatar")
with unittest.mock.patch.object(self.pubsub, "get_items",
new=CoroutineMock()):
cached_descriptors = run_coroutine(
self.s.get_avatar_metadata(TEST_JID1)
)
self.assertEqual(descriptors, cached_descriptors)
# we must get the descriptors from the cache
self.pubsub.get_items.assert_not_called()
with unittest.mock.patch.object(self.pubsub, "get_items",
new=CoroutineMock()):
self.pubsub.get_items.return_value = pubsub_result
descriptors = run_coroutine(
self.s.get_avatar_metadata(TEST_JID1, require_fresh=True)
)
self.assertSequenceEqual(
self.pubsub.get_items.mock_calls,
[
unittest.mock.call(
TEST_JID1,
namespaces.xep0084_metadata,
max_items=1
)
]
)
def test_publish_avatar_set_synchronize_vcard(self):
avatar_set = avatar_service.AvatarSet()
avatar_set.add_avatar_image("image/png", image_bytes=TEST_IMAGE)
self.assertFalse(self.s.synchronize_vcard)
self.s.synchronize_vcard = True
self.assertTrue(self.s.synchronize_vcard)
with contextlib.ExitStack() as e:
e.enter_context(unittest.mock.patch.object(self.pep, "publish",
new=CoroutineMock()))
e.enter_context(unittest.mock.patch.object(self.presence_server,
"resend_presence"))
e.enter_context(unittest.mock.patch.object(self.vcard, "get_vcard",
new=CoroutineMock()))
e.enter_context(unittest.mock.patch.object(self.vcard, "set_vcard",
new=CoroutineMock()))
self.vcard.get_vcard.return_value = unittest.mock.Mock()
run_coroutine(self.s.publish_avatar_set(avatar_set))
self.assertSequenceEqual(
self.presence_server.resend_presence.mock_calls,
[unittest.mock.call()]
)
self.assertSequenceEqual(
self.vcard.get_vcard.mock_calls,
[
unittest.mock.call(),
unittest.mock.call().set_photo_data("image/png",
TEST_IMAGE),
]
)
self.assertSequenceEqual(
self.vcard.set_vcard.mock_calls,
[
unittest.mock.call(self.vcard.get_vcard.return_value),
]
)
self.assertSequenceEqual(
self.pep.publish.mock_calls,
[
unittest.mock.call(
namespaces.xep0084_data,
unittest.mock.ANY,
id_=avatar_set.png_id
),
unittest.mock.call(
namespaces.xep0084_metadata,
avatar_set.metadata,
id_=avatar_set.png_id
)
],
)
_, args, _ = self.pep.publish.mock_calls[0]
data = args[1]
self.assertTrue(isinstance(data, avatar_xso.Data))
self.assertEqual(data.data, avatar_set.image_bytes)
