def test_init(self): iq = disco_xso.InfoQuery() self.assertIsNone(iq.captured_events) self.assertFalse(iq.features) self.assertFalse(iq.identities) self.assertIsNone(iq.node) iq = disco_xso.InfoQuery(node="foobar", features=(1, 2), identities=(3, )) self.assertIsNone(iq.captured_events) self.assertSetEqual({1, 2}, iq.features) self.assertIsInstance(iq.identities, xso_model.XSOList) self.assertSequenceEqual([3], iq.identities) self.assertEqual("foobar", iq.node)
def test_query_info_transparent_deduplication_when_cancelled(self): to = structs.JID.fromstr("[email protected]/res1") response = disco_xso.InfoQuery() with unittest.mock.patch.object( self.s, "send_and_decode_info_query", new=CoroutineMock()) as send_and_decode: response = {} send_and_decode.return_value = response send_and_decode.delay = 0.1 q1 = asyncio. async (self.s.query_info(to)) q2 = asyncio. async (self.s.query_info(to)) run_coroutine(asyncio.sleep(0.05)) q1.cancel() result = run_coroutine(q2) self.assertIs(result, response) self.assertSequenceEqual([ unittest.mock.call(to, None), unittest.mock.call(to, None), ], send_and_decode.mock_calls)
def test_check_for_pep(self): disco_info = disco_xso.InfoQuery() disco_info.identities.append( disco_xso.Identity(type_="pep", category="pubsub")) with unittest.mock.patch.object(self.disco_client, "query_info", new=CoroutineMock()): self.disco_client.query_info.return_value = disco_info # run twice, the second call must not query again but use the # cache run_coroutine(self.s._check_for_pep()) run_coroutine(self.s._check_for_pep()) self.assertEqual(1, len(self.disco_client.query_info.mock_calls)) self.disco_client.query_info.assert_called_with(TEST_FROM.bare()) # this should wipe the cache and recheck with disco mock_reason = unittest.mock.Mock() self.s.handle_stream_destroyed(mock_reason) with unittest.mock.patch.object(self.disco_client, "query_info", new=CoroutineMock()): self.disco_client.query_info.return_value = disco_info # run twice, the second call must not query again but use the # cache run_coroutine(self.s._check_for_pep()) run_coroutine(self.s._check_for_pep()) self.assertEqual(1, len(self.disco_client.query_info.mock_calls)) self.disco_client.query_info.assert_called_with(TEST_FROM.bare())
def test_check_for_pep_failure(self): with unittest.mock.patch.object( self.disco_client, "query_info", new=CoroutineMock()) as query_info_mock: self.disco_client.query_info.return_value = disco_xso.InfoQuery() with self.assertRaises(RuntimeError): run_coroutine(self.s._check_for_pep()) query_info_mock.assert_called_once_with(TEST_FROM.bare())
def test_check_for_pep(self): disco_info = disco_xso.InfoQuery() disco_info.identities.append( disco_xso.Identity(type_="pep", category="pubsub")) with unittest.mock.patch.object( self.disco_client, "query_info", new=CoroutineMock()) as query_info_mock: query_info_mock.return_value = disco_info run_coroutine(self.s._check_for_pep()) query_info_mock.assert_called_once_with(TEST_FROM.bare())
def test_check_for_blocking_failure(self): disco_info = disco_xso.InfoQuery() with unittest.mock.patch.object(self.disco, "query_info", new=CoroutineMock()): self.disco.query_info.return_value = disco_info with self.assertRaises(RuntimeError): run_coroutine(self.s._check_for_blocking()) self.disco.query_info.assert_called_with( TEST_FROM.replace(localpart=None, resource=None))
def test_check_for_blocking(self): disco_info = disco_xso.InfoQuery() disco_info.features.add(namespaces.xep0191) with unittest.mock.patch.object(self.disco, "query_info", new=CoroutineMock()): self.disco.query_info.return_value = disco_info run_coroutine(self.s._check_for_blocking()) self.disco.query_info.assert_called_with( TEST_FROM.replace(localpart=None, resource=None))
def test_set_info_cache(self): to = structs.JID.fromstr("[email protected]/res1") response = disco_xso.ItemsQuery() self.s.set_info_cache(to, None, response) other_response = disco_xso.InfoQuery() self.cc.stream.send_iq_and_wait_for_reply.return_value = \ other_response result = run_coroutine(self.s.query_info(to, node=None)) self.assertIs(result, response) self.assertFalse(self.cc.stream.mock_calls)
def test_select_common_hashes_not_supported(self): with unittest.mock.patch.object(self.disco_client, "query_info", new=CoroutineMock()) as query_info: query_info.return_value = disco_xso.InfoQuery( features=('urn:xmpp:hash-function-text-names:md5', )) with self.assertRaisesRegex( RuntimeError, "Remote does not support the urn:xmpp:hashes:2 feature."): res = run_coroutine( self.s.select_common_hashes( unittest.mock.sentinel.other_jid)) self.assertSequenceEqual(query_info.mock_calls, [ unittest.mock.call(unittest.mock.sentinel.other_jid), ])
def test_check_for_pep_failure(self): with unittest.mock.patch.object(self.disco_client, "query_info", new=CoroutineMock()): self.disco_client.query_info.return_value = disco_xso.InfoQuery() # run twice, the second call must not query again but use the # cache with self.assertRaises(NotImplementedError): run_coroutine(self.s._check_for_pep()) with self.assertRaises(NotImplementedError): run_coroutine(self.s._check_for_pep()) self.assertEqual(1, len(self.disco_client.query_info.mock_calls)) self.disco_client.query_info.assert_called_with(TEST_FROM.bare())
def setUp(self): self.cc = make_connected_client() self.s = disco_service.Service(self.cc) self.cc.reset_mock() self.request_iq = stanza.IQ( "get", from_=structs.JID.fromstr("[email protected]/res1"), to=structs.JID.fromstr("[email protected]/res2")) self.request_iq.autoset_id() self.request_iq.payload = disco_xso.InfoQuery() self.request_items_iq = stanza.IQ( "get", from_=structs.JID.fromstr("[email protected]/res1"), to=structs.JID.fromstr("[email protected]/res2")) self.request_items_iq.autoset_id() self.request_items_iq.payload = disco_xso.ItemsQuery()
def test_select_common_hashes_empty_intersection(self): with unittest.mock.patch.object(self.disco_client, "query_info", new=CoroutineMock()) as query_info: query_info.return_value = disco_xso.InfoQuery(features=( 'urn:xmpp:hashes:2', 'urn:xmpp:hash-function-text-names:md5', )) res = run_coroutine( self.s.select_common_hashes(unittest.mock.sentinel.other_jid)) self.assertSequenceEqual(query_info.mock_calls, [ unittest.mock.call(unittest.mock.sentinel.other_jid), ]) self.assertEqual( res, set(), )
def test_query_info_deduplicate_requests(self): to = structs.JID.fromstr("[email protected]/res1") response = disco_xso.InfoQuery() with unittest.mock.patch.object( self.s, "send_and_decode_info_query", new=CoroutineMock()) as send_and_decode: response = {} send_and_decode.return_value = response result = run_coroutine( asyncio.gather( self.s.query_info(to, timeout=10), self.s.query_info(to, timeout=10), )) self.assertIs(result[0], response) self.assertIs(result[1], response) self.assertSequenceEqual([ unittest.mock.call(to, None), ], send_and_decode.mock_calls)
def test_send_and_decode_info_query(self): to = structs.JID.fromstr("[email protected]/res1") node = "foobar" response = disco_xso.InfoQuery() self.cc.stream.send_iq_and_wait_for_reply.return_value = response result = run_coroutine(self.s.send_and_decode_info_query(to, node)) self.assertEqual(result, response) self.assertEqual( 1, len(self.cc.stream.send_iq_and_wait_for_reply.mock_calls)) call, = self.cc.stream.send_iq_and_wait_for_reply.mock_calls # call[1] are args request_iq, = call[1] self.assertEqual(to, request_iq.to) self.assertEqual("get", request_iq.type_) self.assertIsInstance(request_iq.payload, disco_xso.InfoQuery) self.assertFalse(request_iq.payload.features) self.assertFalse(request_iq.payload.identities) self.assertIs(request_iq.payload.node, node)
def test__set_captured_events(self): data = object() iq = disco_xso.InfoQuery() iq._set_captured_events(data) self.assertIs(iq.captured_events, data)
def test_to_dict_emits_forms_with_identical_type(self): q = disco_xso.InfoQuery() q.identities.extend([ disco_xso.Identity(category="client", type_="pc", name="foobar"), disco_xso.Identity(category="client", type_="pc", name="baz", lang=structs.LanguageTag.fromstr("en-GB")), ]) q.features.update([ "foo", "bar", "baz", ]) f = forms_xso.Data(type_=forms_xso.DataType.FORM) f.fields.extend([ forms_xso.Field(type_=forms_xso.FieldType.HIDDEN, var="FORM_TYPE", values=[ "fnord", ]), forms_xso.Field(type_=forms_xso.FieldType.TEXT_SINGLE, var="uiae", values=[ "nrtd", "asdf", ]), forms_xso.Field(type_=forms_xso.FieldType.FIXED), ]) q.exts.append(f) f = forms_xso.Data(type_=forms_xso.DataType.FORM) f.fields.extend([ forms_xso.Field(type_=forms_xso.FieldType.HIDDEN, var="FORM_TYPE", values=[ "fnord", ]), ]) q.exts.append(f) self.assertDictEqual( q.to_dict(), { "features": [ "bar", "baz", "foo", ], "identities": [ { "category": "client", "type": "pc", "name": "foobar", }, { "category": "client", "type": "pc", "name": "baz", "lang": "en-gb", }, ], "forms": [{ "FORM_TYPE": [ "fnord", ], "uiae": [ "nrtd", "asdf", ] }, { "FORM_TYPE": [ "fnord", ], }] })
def test_to_dict(self): q = disco_xso.InfoQuery() q.identities.extend([ disco_xso.Identity( category="client", type_="pc", name="foobar" ), disco_xso.Identity( category="client", type_="pc", name="baz", lang=structs.LanguageTag.fromstr("en-GB") ), ]) q.features.update( [ "foo", "bar", "baz", ] ) f = forms_xso.Data() f.fields.extend([ forms_xso.Field(type_="hidden", var="FORM_TYPE", values=[ "fnord", ]), forms_xso.Field(type_="text-single", var="uiae", values=[ "nrtd", "asdf", ]), forms_xso.Field(type_="fixed"), ]) q.exts.append(f) self.assertDictEqual( q.to_dict(), { "features": [ "bar", "baz", "foo", ], "identities": [ { "category": "client", "type": "pc", "name": "foobar", }, { "category": "client", "type": "pc", "name": "baz", "lang": "en-gb", }, ], "forms": [ { "FORM_TYPE": [ "fnord", ], "uiae": [ "nrtd", "asdf", ] } ] } )