test_fedclient.py 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237
  1. # -*- coding: utf-8 -*-
  2. # Copyright 2018 New Vector Ltd
  3. #
  4. # Licensed under the Apache License, Version 2.0 (the "License");
  5. # you may not use this file except in compliance with the License.
  6. # You may obtain a copy of the License at
  7. #
  8. # http://www.apache.org/licenses/LICENSE-2.0
  9. #
  10. # Unless required by applicable law or agreed to in writing, software
  11. # distributed under the License is distributed on an "AS IS" BASIS,
  12. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. # See the License for the specific language governing permissions and
  14. # limitations under the License.
  15. from mock import Mock
  16. from twisted.internet.defer import TimeoutError
  17. from twisted.internet.error import ConnectingCancelledError, DNSLookupError
  18. from twisted.test.proto_helpers import StringTransport
  19. from twisted.web.client import ResponseNeverReceived
  20. from twisted.web.http import HTTPChannel
  21. from synapse.api.errors import RequestSendFailed
  22. from synapse.http.matrixfederationclient import (
  23. MatrixFederationHttpClient,
  24. MatrixFederationRequest,
  25. )
  26. from tests.server import FakeTransport
  27. from tests.unittest import HomeserverTestCase
  28. class FederationClientTests(HomeserverTestCase):
  29. def make_homeserver(self, reactor, clock):
  30. hs = self.setup_test_homeserver(reactor=reactor, clock=clock)
  31. hs.tls_client_options_factory = None
  32. return hs
  33. def prepare(self, reactor, clock, homeserver):
  34. self.cl = MatrixFederationHttpClient(self.hs)
  35. self.reactor.lookups["testserv"] = "1.2.3.4"
  36. def test_dns_error(self):
  37. """
  38. If the DNS lookup returns an error, it will bubble up.
  39. """
  40. d = self.cl.get_json("testserv2:8008", "foo/bar", timeout=10000)
  41. self.pump()
  42. f = self.failureResultOf(d)
  43. self.assertIsInstance(f.value, RequestSendFailed)
  44. self.assertIsInstance(f.value.inner_exception, DNSLookupError)
  45. def test_client_never_connect(self):
  46. """
  47. If the HTTP request is not connected and is timed out, it'll give a
  48. ConnectingCancelledError or TimeoutError.
  49. """
  50. d = self.cl.get_json("testserv:8008", "foo/bar", timeout=10000)
  51. self.pump()
  52. # Nothing happened yet
  53. self.assertNoResult(d)
  54. # Make sure treq is trying to connect
  55. clients = self.reactor.tcpClients
  56. self.assertEqual(len(clients), 1)
  57. self.assertEqual(clients[0][0], '1.2.3.4')
  58. self.assertEqual(clients[0][1], 8008)
  59. # Deferred is still without a result
  60. self.assertNoResult(d)
  61. # Push by enough to time it out
  62. self.reactor.advance(10.5)
  63. f = self.failureResultOf(d)
  64. self.assertIsInstance(f.value, RequestSendFailed)
  65. self.assertIsInstance(
  66. f.value.inner_exception,
  67. (ConnectingCancelledError, TimeoutError),
  68. )
  69. def test_client_connect_no_response(self):
  70. """
  71. If the HTTP request is connected, but gets no response before being
  72. timed out, it'll give a ResponseNeverReceived.
  73. """
  74. d = self.cl.get_json("testserv:8008", "foo/bar", timeout=10000)
  75. self.pump()
  76. # Nothing happened yet
  77. self.assertNoResult(d)
  78. # Make sure treq is trying to connect
  79. clients = self.reactor.tcpClients
  80. self.assertEqual(len(clients), 1)
  81. self.assertEqual(clients[0][0], '1.2.3.4')
  82. self.assertEqual(clients[0][1], 8008)
  83. conn = Mock()
  84. client = clients[0][2].buildProtocol(None)
  85. client.makeConnection(conn)
  86. # Deferred is still without a result
  87. self.assertNoResult(d)
  88. # Push by enough to time it out
  89. self.reactor.advance(10.5)
  90. f = self.failureResultOf(d)
  91. self.assertIsInstance(f.value, RequestSendFailed)
  92. self.assertIsInstance(f.value.inner_exception, ResponseNeverReceived)
  93. def test_client_gets_headers(self):
  94. """
  95. Once the client gets the headers, _request returns successfully.
  96. """
  97. request = MatrixFederationRequest(
  98. method="GET",
  99. destination="testserv:8008",
  100. path="foo/bar",
  101. )
  102. d = self.cl._send_request(request, timeout=10000)
  103. self.pump()
  104. conn = Mock()
  105. clients = self.reactor.tcpClients
  106. client = clients[0][2].buildProtocol(None)
  107. client.makeConnection(conn)
  108. # Deferred does not have a result
  109. self.assertNoResult(d)
  110. # Send it the HTTP response
  111. client.dataReceived(b"HTTP/1.1 200 OK\r\nServer: Fake\r\n\r\n")
  112. # We should get a successful response
  113. r = self.successResultOf(d)
  114. self.assertEqual(r.code, 200)
  115. def test_client_headers_no_body(self):
  116. """
  117. If the HTTP request is connected, but gets no response before being
  118. timed out, it'll give a ResponseNeverReceived.
  119. """
  120. d = self.cl.post_json("testserv:8008", "foo/bar", timeout=10000)
  121. self.pump()
  122. conn = Mock()
  123. clients = self.reactor.tcpClients
  124. client = clients[0][2].buildProtocol(None)
  125. client.makeConnection(conn)
  126. # Deferred does not have a result
  127. self.assertNoResult(d)
  128. # Send it the HTTP response
  129. client.dataReceived(
  130. (b"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n"
  131. b"Server: Fake\r\n\r\n")
  132. )
  133. # Push by enough to time it out
  134. self.reactor.advance(10.5)
  135. f = self.failureResultOf(d)
  136. self.assertIsInstance(f.value, TimeoutError)
  137. def test_client_sends_body(self):
  138. self.cl.post_json(
  139. "testserv:8008", "foo/bar", timeout=10000,
  140. data={"a": "b"}
  141. )
  142. self.pump()
  143. clients = self.reactor.tcpClients
  144. self.assertEqual(len(clients), 1)
  145. client = clients[0][2].buildProtocol(None)
  146. server = HTTPChannel()
  147. client.makeConnection(FakeTransport(server, self.reactor))
  148. server.makeConnection(FakeTransport(client, self.reactor))
  149. self.pump(0.1)
  150. self.assertEqual(len(server.requests), 1)
  151. request = server.requests[0]
  152. content = request.content.read()
  153. self.assertEqual(content, b'{"a":"b"}')
  154. def test_closes_connection(self):
  155. """Check that the client closes unused HTTP connections"""
  156. d = self.cl.get_json("testserv:8008", "foo/bar")
  157. self.pump()
  158. # there should have been a call to connectTCP
  159. clients = self.reactor.tcpClients
  160. self.assertEqual(len(clients), 1)
  161. (_host, _port, factory, _timeout, _bindAddress) = clients[0]
  162. # complete the connection and wire it up to a fake transport
  163. client = factory.buildProtocol(None)
  164. conn = StringTransport()
  165. client.makeConnection(conn)
  166. # that should have made it send the request to the connection
  167. self.assertRegex(conn.value(), b"^GET /foo/bar")
  168. # Send the HTTP response
  169. client.dataReceived(
  170. b"HTTP/1.1 200 OK\r\n"
  171. b"Content-Type: application/json\r\n"
  172. b"Content-Length: 2\r\n"
  173. b"\r\n"
  174. b"{}"
  175. )
  176. # We should get a successful response
  177. r = self.successResultOf(d)
  178. self.assertEqual(r, {})
  179. self.assertFalse(conn.disconnecting)
  180. # wait for a while
  181. self.pump(120)
  182. self.assertTrue(conn.disconnecting)