def test_no_error_for_diaspora_entities_on_activitypub_recipients( self, mock_logger, mock_send, diasporacomment): key = get_dummy_private_key() diasporacomment.outbound_doc = diasporacomment.to_xml() recipients = [{ "endpoint": "https://example.com/receive/public", "public": True, "protocol": "diaspora", "fid": "", }, { "endpoint": "https://example.net/inbox", "fid": "https://example.net/foobar", "public": True, "protocol": "activitypub", }] author = UserType( private_key=key, id="*****@*****.**", handle="*****@*****.**", ) handle_send(diasporacomment, author, recipients) # Ensure first call is a public diaspora payload args, kwargs = mock_send.call_args_list[0] assert args[0] == "https://example.com/receive/public" # Should only be one call assert mock_send.call_count == 1 # Ensure no error logged assert mock_logger.call_count == 0
def setUpTestData(cls): super().setUpTestData() author = UserFactory() Profile.objects.filter(id=author.profile.id).update(rsa_private_key=get_dummy_private_key().exportKey()) cls.limited_content = ContentFactory(visibility=Visibility.LIMITED, author=author.profile) cls.public_content = ContentFactory(visibility=Visibility.PUBLIC, author=author.profile) cls.remote_content = ContentFactory(visibility=Visibility.PUBLIC)
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.profile = cls.user.profile cls.remote_profile = ProfileFactory( rsa_public_key=get_dummy_private_key().publickey().exportKey(), )
def test_build(self): env = MagicEnvelope( message="<status_message><foo>bar</foo></status_message>", private_key=get_dummy_private_key(), author_handle="*****@*****.**") doc = env.build() assert isinstance(doc, _Element)
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.profile = cls.user.profile cls.remote_profile = ProfileFactory( rsa_public_key=get_dummy_private_key().publickey().exportKey(), )
def test_calls_handle_create_payload(self, mock_send, diasporapost): key = get_dummy_private_key() recipients = [ ("diaspora://[email protected]/profile/xyz", key.publickey()), ("diaspora://foo@localhost/profile/abc", None), "diaspora://[email protected]/profile/zzz", "diaspora://[email protected]/profile/qwerty", # Same host twice to ensure one delivery only per host # for public payloads ] mock_author = Mock(private_key=key, handle="*****@*****.**") handle_send(diasporapost, mock_author, recipients) # Ensure first call is a private payload args, kwargs = mock_send.call_args_list[0] assert args[0] == "https://127.0.0.1/receive/users/xyz" assert "aes_key" in args[1] assert "encrypted_magic_envelope" in args[1] assert kwargs['headers'] == {'Content-Type': 'application/json'} # Ensure public payloads and recipients, one per unique host args1, kwargs1 = mock_send.call_args_list[1] args2, kwargs2 = mock_send.call_args_list[2] public_endpoints = {args1[0], args2[0]} assert public_endpoints == { "https://example.net/receive/public", "https://localhost/receive/public" } assert args1[1].startswith("<me:env xmlns:me=") assert args2[1].startswith("<me:env xmlns:me=") assert kwargs1['headers'] == { 'Content-Type': 'application/magic-envelope+xml' } assert kwargs2['headers'] == { 'Content-Type': 'application/magic-envelope+xml' }
def setUpTestData(cls): super().setUpTestData() cls.limited_content = ContentFactory(visibility=Visibility.LIMITED) author = UserFactory() author.profile.rsa_private_key = get_dummy_private_key().exportKey() author.profile.save() cls.public_content = ContentFactory(visibility=Visibility.PUBLIC, author=author.profile) cls.profile = author.profile
def test_signing_like_works(self): entity = DiasporaLike(guid="guid", target_guid="target_guid", handle="handle") entity.sign(get_dummy_private_key()) assert entity.signature == "apkcOn6marHfo0rHiOnQq+qqspxxWOJNklQKQjoJUHmXDNRnBp8aPoLKqVOznsTEpEIhM1p5/8mPilgY" \ "yVFHepi/m744DFQByx7hVkMhGFiZWtJx1tTWSl1d7H85FTlE0DyPwiRYVTrG3vQD3Dr+b08WiOEzG+ii" \ "Q0t+vWGl8cgSS0/34mvvqX+HKUdmun2vQ50bPckNLoj3hDI6HcmZ8qFf/xx8y1BbE0zx5rTo7yOlWq8Y" \ "sC28oRHqHpIzOfhkIHyt+hOjO/mpuZLd7qOPfIySnGW6hM1iKewoJVDuVMN5w5VB46ETRum8JpvTQO8i" \ "DPB+ZqbqcEasfm2CQIxVLA=="
def setUpTestData(cls): super().setUpTestData() cls.limited_content = ContentFactory(visibility=Visibility.LIMITED) author = UserFactory() author.profile.rsa_private_key = get_dummy_private_key().exportKey() author.profile.save() cls.public_content = ContentFactory(visibility=Visibility.PUBLIC, author=author.profile) cls.profile = author.profile
def test_encrypt(self): private_key = get_dummy_private_key() public_key = private_key.publickey() encrypted = EncryptedPayload.encrypt("<spam>eggs</spam>", public_key) assert "aes_key" in encrypted assert "encrypted_magic_envelope" in encrypted # See we can decrypt it too decrypted = EncryptedPayload.decrypt(encrypted, private_key) assert etree.tostring(decrypted).decode("utf-8") == "<spam>eggs</spam>"
def setUpTestData(cls): super().setUpTestData() author = UserFactory() Profile.objects.filter(id=author.profile.id).update( rsa_private_key=get_dummy_private_key().exportKey().decode("utf-8") ) cls.limited_content = ContentFactory(visibility=Visibility.LIMITED, author=author.profile) cls.public_content = ContentFactory(visibility=Visibility.PUBLIC, author=author.profile) cls.remote_content = ContentFactory(visibility=Visibility.PUBLIC, guid=uuid.uuid4())
def setUpTestData(cls): super().setUpTestData() author = UserFactory() author.profile.rsa_private_key = get_dummy_private_key().exportKey() author.profile.save() cls.public_content = ContentFactory(visibility=Visibility.PUBLIC, author=author.profile) cls.remote_reply = ContentFactory(parent=cls.public_content, author=ProfileFactory()) cls.reply = ContentFactory(parent=cls.public_content)
def setUpTestData(cls): super().setUpTestData() author = UserFactory() author.profile.rsa_private_key = get_dummy_private_key().exportKey() author.profile.save() cls.public_content = PublicContentFactory(author=author.profile) cls.remote_reply = PublicContentFactory(parent=cls.public_content, author=ProfileFactory()) cls.reply = PublicContentFactory(parent=cls.public_content) cls.share = PublicContentFactory(share_of=cls.public_content) cls.share_reply = PublicContentFactory(parent=cls.share)
def test_signing_comment_works(self, mock_format_dt): entity = DiasporaComment( raw_content="raw_content", guid="guid", target_guid="target_guid", handle="handle", created_at="created_at", ) entity.sign(get_dummy_private_key()) assert entity.signature == "OWvW/Yxw4uCnx0WDn0n5/B4uhyZ8Pr6h3FZaw8J7PCXyPluOfYXFoHO21bykP8c2aVnuJNHe+lmeAkUC" \ "/kHnl4yxk/jqe3uroW842OWvsyDRQ11vHxhIqNMjiepFPkZmXX3vqrYYh5FrC/tUsZrEc8hHoOIHXFR2" \ "kGD0gPV+4EEG6pbMNNZ+SBVun0hvruX8iKQVnBdc/+zUI9+T/MZmLyqTq/CvuPxDyHzQPSHi68N9rJyr" \ "4Xa1K+R33Xq8eHHxs8LVNRqzaHGeD3DX8yBu/vP9TYmZsiWlymbuGwLCa4Yfv/VS1hQZovhg6YTxV4CR" \ "v4ToGL+CAJ7UHEugRRBwDw=="
def setUpTestData(cls): super().setUpTestData() author = UserFactory() Profile.objects.filter(id=author.profile.id).update( rsa_private_key=get_dummy_private_key().exportKey().decode("utf-8") ) cls.public_content = ContentFactory(author=author.profile, visibility=Visibility.PUBLIC) cls.remote_content = ContentFactory(visibility=Visibility.PUBLIC) cls.remote_reply = ContentFactory(parent=cls.public_content, author=ProfileFactory()) cls.reply = ContentFactory(parent=cls.public_content, author=author.profile) cls.reply2 = ContentFactory(parent=cls.remote_content, author=author.profile)
def test_build_send_uses_outbound_doc(self, mock_me): protocol = self.init_protocol() outbound_doc = etree.fromstring("<xml>foo</xml>") entity = Mock(outbound_doc=outbound_doc) from_user = UserType( id="*****@*****.**", private_key=get_dummy_private_key(), handle="*****@*****.**", ) protocol.build_send(entity, from_user) mock_me.assert_called_once_with( b"<xml>foo</xml>", private_key=from_user.private_key, author_handle="*****@*****.**", )
def test_render(self): env = MagicEnvelope( message="<status_message><foo>bar</foo></status_message>", private_key=get_dummy_private_key(), author_handle="*****@*****.**") env.build() output = env.render() assert output == '<me:env xmlns:me="http://salmon-protocol.org/ns/magic-env"><me:encoding>base64url' \ '</me:encoding><me:alg>RSA-SHA256</me:alg><me:data type="application/xml">' \ 'PHN0YXR1c19tZXNzYWdlPjxmb28-YmFyPC9mb28-PC9zdGF0dXNfbWVzc2FnZT4=</me:data>' \ '<me:sig key_id="Zm9vYmFyQGV4YW1wbGUuY29t">Cmk08MR4Tp8r9eVybD1hORcR_8NLRVxAu0biOfJbk' \ 'I1xLx1c480zJ720cpVyKaF9CxVjW3lvlvRz5YbswMv0izPzfHpXoWTXH-4UPrXaGYyJnrNvqEB2UWn4iHK' \ 'J2Rerto8sJY2b95qbXD6Nq75EoBNub5P7DYc16ENhp38YwBRnrBEvNOewddpOpEBVobyNB7no_QR8c_xkX' \ 'ie-hUDFNwI0z7vax9HkaBFbvEmzFPMZAAdWyjxeGiWiqY0t2ZdZRCPTezy66X6Q0qc4I8kfT-Mt1ctjGmNM' \ 'oJ4Lgu-PrO5hSRT4QBAVyxaog5w-B0PIPuC-mUW5SZLsnX3_ZuwJww==</me:sig></me:env>' env2 = MagicEnvelope( message="<status_message><foo>bar</foo></status_message>", private_key=get_dummy_private_key(), author_handle="*****@*****.**") output2 = env2.render() assert output2 == output
def test_signing_request(): key = get_dummy_private_key() auth = get_http_authentication(key, "dummy_key_id") assert auth.algorithm == 'rsa-sha256' assert auth.headers == [ '(request-target)', 'user-agent', 'host', 'date', ] assert auth.key == key.exportKey() assert auth.key_id == 'dummy_key_id'
def test_build_signature(self): env = MagicEnvelope( message="<status_message><foo>bar</foo></status_message>", private_key=get_dummy_private_key(), author_handle="*****@*****.**") env.create_payload() signature, key_id = env._build_signature() assert signature == b'Cmk08MR4Tp8r9eVybD1hORcR_8NLRVxAu0biOfJbkI1xLx1c480zJ720cpVyKaF9CxVjW3lvlvRz' \ b'5YbswMv0izPzfHpXoWTXH-4UPrXaGYyJnrNvqEB2UWn4iHKJ2Rerto8sJY2b95qbXD6Nq75EoBNu' \ b'b5P7DYc16ENhp38YwBRnrBEvNOewddpOpEBVobyNB7no_QR8c_xkXie-hUDFNwI0z7vax9HkaBFb' \ b'vEmzFPMZAAdWyjxeGiWiqY0t2ZdZRCPTezy66X6Q0qc4I8kfT-Mt1ctjGmNMoJ4Lgu-PrO5hSRT4' \ b'QBAVyxaog5w-B0PIPuC-mUW5SZLsnX3_ZuwJww==' assert key_id == b"Zm9vYmFyQGV4YW1wbGUuY29t"
def setUpTestData(cls): super().setUpTestData() cls.create_local_and_remote_user() Profile.objects.filter(id=cls.profile.id).update( rsa_private_key=get_dummy_private_key().exportKey().decode("utf-8") ) cls.content = ContentFactory(author=cls.remote_profile, visibility=Visibility.PUBLIC) cls.limited_content = ContentFactory(author=cls.remote_profile, visibility=Visibility.LIMITED) cls.share = ContentFactory(share_of=cls.content, author=cls.profile, visibility=Visibility.PUBLIC) cls.limited_share = ContentFactory( share_of=cls.limited_content, author=cls.profile, visibility=Visibility.LIMITED ) cls.local_content = LocalContentFactory(visibility=Visibility.PUBLIC) cls.local_share = ContentFactory(share_of=cls.local_content, author=cls.profile, visibility=Visibility.PUBLIC)
def setUpTestData(cls): super().setUpTestData() author = UserFactory() private_key = get_dummy_private_key().exportKey().decode("utf-8") Profile.objects.filter(id=author.profile.id).update(rsa_private_key=private_key) author.profile.refresh_from_db() cls.public_content = ContentFactory(author=author.profile, visibility=Visibility.PUBLIC) cls.remote_content = ContentFactory(visibility=Visibility.PUBLIC) cls.remote_profile = ProfileFactory(with_key=True) cls.remote_reply = ContentFactory(parent=cls.public_content, author=cls.remote_profile) cls.reply = ContentFactory(parent=cls.public_content, author=author.profile) cls.reply2 = ContentFactory(parent=cls.remote_content, author=author.profile) cls.limited_content = LimitedContentFactory(author=cls.remote_profile) cls.limited_reply = LimitedContentFactory(author=author.profile, parent=cls.limited_content)
def setUpTestData(cls): super().setUpTestData() author = UserFactory() author.profile.rsa_private_key = get_dummy_private_key().exportKey() author.profile.save() cls.public_content = PublicContentFactory(author=author.profile) cls.remote_reply = PublicContentFactory(parent=cls.public_content, author=ProfileFactory()) cls.reply = PublicContentFactory(parent=cls.public_content) cls.share = PublicContentFactory(share_of=cls.public_content) cls.share_reply = PublicContentFactory(parent=cls.share) cls.limited_content = LimitedContentFactory(author=author.profile) cls.limited_reply = LimitedContentFactory(parent=cls.limited_content) cls.remote_limited_reply = LimitedContentFactory(parent=cls.limited_content) cls.limited_content.limited_visibilities.set((cls.limited_reply.author, cls.remote_limited_reply.author))
def setUpTestData(cls): super().setUpTestData() cls.create_local_and_remote_user() Profile.objects.filter(id=cls.profile.id).update( rsa_private_key=get_dummy_private_key().exportKey().decode("utf-8") ) cls.profile.refresh_from_db() cls.content = ContentFactory(author=cls.remote_profile, visibility=Visibility.PUBLIC) cls.limited_content = ContentFactory(author=cls.remote_profile, visibility=Visibility.LIMITED) cls.share = ContentFactory(share_of=cls.content, author=cls.profile, visibility=Visibility.PUBLIC) cls.limited_share = ContentFactory( share_of=cls.limited_content, author=cls.profile, visibility=Visibility.LIMITED ) cls.local_content = LocalContentFactory(visibility=Visibility.PUBLIC) cls.local_share = ContentFactory(share_of=cls.local_content, author=cls.profile, visibility=Visibility.PUBLIC)
def test_build_send_does_right_calls(self, mock_me): mock_render = Mock(return_value="rendered") mock_me_instance = Mock(render=mock_render) mock_me.return_value = mock_me_instance protocol = Protocol() entity = DiasporaPost() private_key = get_dummy_private_key() outbound_entity = get_outbound_entity(entity, private_key) data = protocol.build_send(outbound_entity, from_user=Mock( private_key=private_key, handle="johnny@localhost", )) mock_me.assert_called_once_with( etree.tostring(entity.to_xml()), private_key=private_key, author_handle="johnny@localhost", ) mock_render.assert_called_once_with() assert data == "rendered"
def setUpTestData(cls): super().setUpTestData() author = UserFactory() private_key = get_dummy_private_key().exportKey().decode("utf-8") Profile.objects.filter(id=author.profile.id).update(rsa_private_key=private_key) author.profile.refresh_from_db() cls.public_content = ContentFactory(author=author.profile, visibility=Visibility.PUBLIC) cls.remote_content = ContentFactory(visibility=Visibility.PUBLIC) cls.remote_profile = ProfileFactory(with_key=True) cls.remote_reply = ContentFactory(parent=cls.public_content, author=cls.remote_profile) cls.reply = ContentFactory(parent=cls.public_content, author=author.profile) cls.reply2 = ContentFactory(parent=cls.remote_content, author=author.profile) cls.limited_content = LimitedContentFactory(author=cls.remote_profile) cls.limited_local_content = LimitedContentFactory(author=author.profile) cls.limited_reply = LimitedContentFactory(author=author.profile, parent=cls.limited_content) cls.limited_local_reply = LimitedContentFactory(author=author.profile, parent=cls.limited_local_content) cls.limited_local_reply.limited_visibilities.add(cls.remote_profile)
def test_signing_comment_works(self, mock_format_dt): entity = DiasporaComment( raw_content="raw_content", created_at="created_at", actor_id="handle", handle="handle", id="guid", guid="guid", target_id="target_guid", target_guid="target_guid", root_target_id="target_guid", root_target_guid="target_guid", ) entity.sign(get_dummy_private_key()) assert entity.signature == "XZYggFdQHOicguZ0ReVJkYiK5othHgBgAtwnSmm4NR31qeLa76Ur/i2B5Xi9dtopDlNS8EbFy+MLJ1ds" \ "ovDjPsVC1nLZrL57y0v+HtwJas6hQqNbvmEyr1q6X+0p1i93eINzt/7bxcP5uEGxy8J4ItsJzbDVLlC5" \ "3ZtIg7pmhR0ltqNqBHrgL8WDokfGKFlXqANchbD+Xeyv2COGbI78LwplVdYjHW1+jefjpYhMCxayIvMv" \ "WS8TV1hMTqUz+zSqoCHU04RgjjGW8e8vINDblQwMfEMeJ5T6OP5RiU3zCqDc3uL2zxHHh9IGC+clVuhP" \ "HTv8tHUHNLgc2vIzRtGh6w=="
def test_build_send_does_right_calls__private_payload(self, mock_encrypt, mock_me): mock_render = Mock(return_value="rendered") mock_me_instance = Mock(render=mock_render) mock_me.return_value = mock_me_instance protocol = Protocol() entity = DiasporaPost() entity.validate = Mock() private_key = get_dummy_private_key() outbound_entity = get_outbound_entity(entity, private_key) data = protocol.build_send(outbound_entity, to_user_key="public key", from_user=UserType( private_key=private_key, id="johnny@localhost", handle="johnny@localhost", )) mock_me.assert_called_once_with( etree.tostring(entity.to_xml()), private_key=private_key, author_handle="johnny@localhost", ) mock_render.assert_called_once_with() mock_encrypt.assert_called_once_with( "rendered", "public key", ) assert data == "encrypted"
def test_survives_sending_share_if_diaspora_payload_cannot_be_created( self, mock_send, share): key = get_dummy_private_key() share.target_handle = None # Ensure diaspora payload fails recipients = [{ "endpoint": "https://example.com/receive/public", "public": True, "protocol": "diaspora", "fid": "", }, { "endpoint": "https://example.tld/receive/public", "public": True, "protocol": "diaspora", "fid": "", }, { "endpoint": "https://example.net/inbox", "fid": "https://example.net/foobar", "public": True, "protocol": "activitypub", }] author = UserType( private_key=key, id="*****@*****.**", handle="*****@*****.**", ) handle_send(share, author, recipients) # Ensure first call is a public activitypub payload args, kwargs = mock_send.call_args_list[0] assert args[0] == "https://example.net/inbox" assert kwargs['headers'] == { 'Content-Type': 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"', } assert encode_if_text( "https://www.w3.org/ns/activitystreams#Public") in args[1] # Should only be one call assert mock_send.call_count == 1
def test_sign_with_parent(self, mock_validate): entities = message_to_objects(DIASPORA_POST_COMMENT, "*****@*****.**", sender_key_fetcher=Mock()) entity = entities[0] entity.sign_with_parent(get_dummy_private_key()) assert entity.parent_signature == "UTIDiFZqjxfU6ssVlmjz2RwOD/WPmMTFv57qOm0BZvBhF8Ef49Ynse1c2XTtx3rs8DyRMn54" \ "Uw4E0T+3t0Q5SHEQTLtRnOdRXrgNGAnlJ2xRmBWqe6xvvgc4nJ8OnffXhVgI8DBx6YUFRDjJ" \ "fnVQhnqbWr4ZAcpywCyL9IDkap3cTyn6wHo2WFRtq5syTCtMS8RZLXgpVLCeMfHhrXlePIA/" \ "YwMNn0GGi+9qSWXYVFG75cPjcWeY4t5q8EHCQReSSxG4a3HGbc7MigLvHzuhdOWOV8563dYo" \ "/5xS3zlQUt8I3AwXOzHr+57r1egMBHYyXTXsS8gFisj7mH4TsLM+Yw==" assert etree.tostring(entity.outbound_doc) == b'<comment>\n <guid>((guidguidguidguidguidguid))</guid>\n' \ b' <parent_guid>((parent_guidparent_guidparent_guidparent' \ b'_guid))</parent_guid>\n <author_signature>((base64-enco' \ b'ded data))</author_signature>\n <text>((text))</text>\n' \ b' <author>[email protected]</author>\n ' \ b' <author_signature>((signature))</author_signature>\n ' \ b'<parent_author_signature>UTIDiFZqjxfU6ssVlmjz2RwOD/WPmMTFv57' \ b'qOm0BZvBhF8Ef49Ynse1c2XTtx3rs8DyRMn54Uw4E0T+3t0Q5SHEQTLtRnOd' \ b'RXrgNGAnlJ2xRmBWqe6xvvgc4nJ8OnffXhVgI8DBx6YUFRDjJfnVQhnqbWr4' \ b'ZAcpywCyL9IDkap3cTyn6wHo2WFRtq5syTCtMS8RZLXgpVLCeMfHhrXlePIA' \ b'/YwMNn0GGi+9qSWXYVFG75cPjcWeY4t5q8EHCQReSSxG4a3HGbc7MigLvHzu' \ b'hdOWOV8563dYo/5xS3zlQUt8I3AwXOzHr+57r1egMBHYyXTXsS8gFisj7mH4' \ b'TsLM+Yw==</parent_author_signature></comment>'
def __init__(self, nokey=False): if nokey: self.private_key = None else: self.private_key = get_dummy_private_key()
def private_key(): return get_dummy_private_key()
def test_calls_handle_create_payload(self, mock_send, profile): key = get_dummy_private_key() recipients = [ { "endpoint": "https://127.0.0.1/receive/users/1234", "public_key": key.publickey(), "public": False, "protocol": "diaspora", "fid": "", }, { "endpoint": "https://example.com/receive/public", "public": True, "protocol": "diaspora", "fid": "", }, { "endpoint": "https://example.net/receive/public", "public": True, "protocol": "diaspora", "fid": "", }, # Same twice to ensure one delivery only per unique { "endpoint": "https://example.net/receive/public", "public": True, "protocol": "diaspora", "fid": "", }, { "endpoint": "https://example.net/foobar/inbox", "fid": "https://example.net/foobar", "public": False, "protocol": "activitypub", }, { "endpoint": "https://example.net/inbox", "fid": "https://example.net/foobar", "public": True, "protocol": "activitypub", } ] author = UserType( private_key=key, id="*****@*****.**", handle="*****@*****.**", ) handle_send(profile, author, recipients) # Ensure first call is a private diaspora payload args, kwargs = mock_send.call_args_list[0] assert args[0] == "https://127.0.0.1/receive/users/1234" assert "aes_key" in args[1] assert "encrypted_magic_envelope" in args[1] assert kwargs['headers'] == {'Content-Type': 'application/json'} # Ensure second call is a private activitypub payload args, kwargs = mock_send.call_args_list[1] assert args[0] == "https://example.net/foobar/inbox" assert kwargs['headers'] == { 'Content-Type': 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"', } assert encode_if_text( "https://www.w3.org/ns/activitystreams#Public") not in args[1] # Ensure third call is a public activitypub payload args, kwargs = mock_send.call_args_list[2] assert args[0] == "https://example.net/inbox" assert kwargs['headers'] == { 'Content-Type': 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"', } assert encode_if_text( "https://www.w3.org/ns/activitystreams#Public") in args[1] # Ensure diaspora public payloads and recipients, one per unique host args3, kwargs3 = mock_send.call_args_list[3] args4, kwargs4 = mock_send.call_args_list[4] public_endpoints = {args3[0], args4[0]} assert public_endpoints == { "https://example.net/receive/public", "https://example.com/receive/public", } assert args3[1].startswith("<me:env xmlns:me=") assert args4[1].startswith("<me:env xmlns:me=") assert kwargs3['headers'] == { 'Content-Type': 'application/magic-envelope+xml' } assert kwargs4['headers'] == { 'Content-Type': 'application/magic-envelope+xml' } with pytest.raises(IndexError): # noinspection PyStatementEffect mock_send.call_args_list[5]
def test_sign_with_parent__calls_to_xml(self, mock_validate): entity = DiasporaComment() with patch.object(entity, "to_xml") as mock_to_xml: entity.sign_with_parent(get_dummy_private_key()) mock_to_xml.assert_called_once_with()
def get_private_key(identifier: str) -> RsaKey: return get_dummy_private_key()
def test_get_json_payload_magic_envelope(self, mock_decrypt): protocol = Protocol() protocol.user = UserType(id="foobar", private_key=get_dummy_private_key()) protocol.get_json_payload_magic_envelope("payload") mock_decrypt.assert_called_once_with(payload="payload", private_key=get_dummy_private_key())
def test_create_relayable_signature(): doc = etree.XML(XML) signature = create_relayable_signature(get_dummy_private_key(), doc) assert signature == SIGNATURE3