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)