def test_build_response(self) -> None: self.assertEqual( build_http_response(200, reason=b'OK', protocol_version=b'HTTP/1.1'), CRLF.join([b'HTTP/1.1 200 OK', CRLF])) self.assertEqual( build_http_response(200, reason=b'OK', protocol_version=b'HTTP/1.1', headers={b'key': b'value'}), CRLF.join([b'HTTP/1.1 200 OK', b'key: value', CRLF]))
def test_authenticated_proxy_http_tunnel(self, mock_server_connection: mock.Mock, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None: server = mock_server_connection.return_value server.connect.return_value = True server.buffer_size.return_value = 0 self._conn = mock_fromfd.return_value self.mock_selector_for_client_read_read_server_write( mock_selector, server) flags = Proxy.initialize(auth_code=base64.b64encode(b'user:pass')) flags.plugins = Proxy.load_plugins( [bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER)]) self.protocol_handler = HttpProtocolHandler(TcpClientConnection( self._conn, self._addr), flags=flags) self.protocol_handler.initialize() assert self.http_server_port is not None self._conn.recv.return_value = CRLF.join([ b'CONNECT localhost:%d HTTP/1.1' % self.http_server_port, b'Host: localhost:%d' % self.http_server_port, b'User-Agent: proxy.py/%s' % bytes_(__version__), b'Proxy-Connection: Keep-Alive', b'Proxy-Authorization: Basic dXNlcjpwYXNz', CRLF ]) self.assert_tunnel_response(mock_server_connection, server) self.protocol_handler.client.flush() self.assert_data_queued_to_server(server) self.protocol_handler.run_once() server.flush.assert_called_once()
def test_default_web_server_returns_404(self, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None: self._conn = mock_fromfd.return_value mock_selector.return_value.select.return_value = [ (selectors.SelectorKey(fileobj=self._conn, fd=self._conn.fileno, events=selectors.EVENT_READ, data=None), selectors.EVENT_READ), ] flags = Flags() flags.plugins = Flags.load_plugins( b'proxy.http.proxy.HttpProxyPlugin,proxy.http.server.HttpWebServerPlugin' ) self.protocol_handler = HttpProtocolHandler(TcpClientConnection( self._conn, self._addr), flags=flags) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET /hello HTTP/1.1', CRLF, ]) self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.request.state, httpParserStates.COMPLETE) self.assertEqual(self.protocol_handler.client.buffer[0], HttpWebServerPlugin.DEFAULT_404_RESPONSE)
async def test_proxy_authentication_failed(self) -> None: self._conn = self.mock_fromfd.return_value mock_selector_for_client_read(self) flags = FlagParser.initialize( auth_code=base64.b64encode(b'user:pass'), threaded=True, ) flags.plugins = Plugins.load([ bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER), bytes_(PLUGIN_PROXY_AUTH), ]) self.protocol_handler = HttpProtocolHandler( HttpClientConnection(self._conn, self._addr), flags=flags, ) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET http://abhinavsingh.com HTTP/1.1', b'Host: abhinavsingh.com', CRLF, ]) await self.protocol_handler._run_once() self.assertEqual( self.protocol_handler.work.buffer[0], PROXY_AUTH_FAILED_RESPONSE_PKT, )
def test_response_parse_without_content_length(self) -> None: """Case when server response doesn't contain a content-length header for non-chunk response types. HttpParser by itself has no way to know if more data should be expected. In example below, parser reaches state httpParserStates.HEADERS_COMPLETE and it is responsibility of callee to change state to httpParserStates.COMPLETE when server stream closes. See https://github.com/abhinavsingh/proxy.py/issues/20 for details. Post commit https://github.com/abhinavsingh/proxy.py/commit/269484df2e89bc659124177d339d4fc59f280cba HttpParser would reach state COMPLETE also for RESPONSE_PARSER types and no longer it is callee responsibility to change state on stream close. This was important because pipelined responses not trigger stream close but may receive multiple responses. """ self.parser.type = httpParserTypes.RESPONSE_PARSER self.parser.parse(b'HTTP/1.0 200 OK' + CRLF) self.assertEqual(self.parser.code, b'200') self.assertEqual(self.parser.version, b'HTTP/1.0') self.assertEqual(self.parser.state, httpParserStates.LINE_RCVD) self.parser.parse( CRLF.join([ b'Server: BaseHTTP/0.3 Python/2.7.10', b'Date: Thu, 13 Dec 2018 16:24:09 GMT', CRLF ])) self.assertEqual(self.parser.state, httpParserStates.COMPLETE)
def test_post_partial_parse(self) -> None: self.parser.parse( CRLF.join([ b'POST http://localhost HTTP/1.1', b'Host: localhost', b'Content-Length: 7', b'Content-Type: application/x-www-form-urlencoded' ])) self.assertEqual(self.parser.method, b'POST') assert self.parser.url self.assertEqual(self.parser.url.hostname, b'localhost') self.assertEqual(self.parser.url.port, None) self.assertEqual(self.parser.version, b'HTTP/1.1') self.assert_state_change_with_crlf(httpParserStates.RCVING_HEADERS, httpParserStates.RCVING_HEADERS, httpParserStates.HEADERS_COMPLETE) self.parser.parse(b'a=b') self.assertEqual(self.parser.state, httpParserStates.RCVING_BODY) self.assertEqual(self.parser.body, b'a=b') self.assertEqual(self.parser.buffer, b'') self.parser.parse(b'&c=d') self.assertEqual(self.parser.state, httpParserStates.COMPLETE) self.assertEqual(self.parser.body, b'a=b&c=d') self.assertEqual(self.parser.buffer, b'')
def test_http_get(self, mock_server_connection: mock.Mock) -> None: server = mock_server_connection.return_value server.connect.return_value = True server.buffer_size.return_value = 0 self.mock_selector_for_client_read_read_server_write( self.mock_selector, server) # Send request line assert self.http_server_port is not None self._conn.recv.return_value = (b'GET http://localhost:%d HTTP/1.1' % self.http_server_port) + CRLF self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.request.state, httpParserStates.LINE_RCVD) self.assertNotEqual(self.protocol_handler.request.state, httpParserStates.COMPLETE) # Send headers and blank line, thus completing HTTP request assert self.http_server_port is not None self._conn.recv.return_value = CRLF.join([ b'User-Agent: proxy.py/%s' % bytes_(__version__), b'Host: localhost:%d' % self.http_server_port, b'Accept: */*', b'Proxy-Connection: Keep-Alive', CRLF ]) self.assert_data_queued(mock_server_connection, server) self.protocol_handler.run_once() server.flush.assert_called_once()
def test_get_partial_parse1(self) -> None: pkt = CRLF.join([b'GET http://localhost:8080 HTTP/1.1']) self.parser.parse(pkt) self.assertEqual(self.parser.total_size, len(pkt)) self.assertEqual(self.parser.method, None) self.assertEqual(self.parser.url, None) self.assertEqual(self.parser.version, None) self.assertEqual(self.parser.state, httpParserStates.INITIALIZED) self.parser.parse(CRLF) self.assertEqual(self.parser.total_size, len(pkt) + len(CRLF)) self.assertEqual(self.parser.method, b'GET') assert self.parser.url self.assertEqual(self.parser.url.hostname, b'localhost') self.assertEqual(self.parser.url.port, 8080) self.assertEqual(self.parser.version, b'HTTP/1.1') self.assertEqual(self.parser.state, httpParserStates.LINE_RCVD) host_hdr = b'Host: localhost:8080' self.parser.parse(host_hdr) self.assertEqual(self.parser.total_size, len(pkt) + len(CRLF) + len(host_hdr)) self.assertDictEqual(self.parser.headers, dict()) self.assertEqual(self.parser.buffer, b'Host: localhost:8080') self.assertEqual(self.parser.state, httpParserStates.LINE_RCVD) self.parser.parse(CRLF * 2) self.assertEqual(self.parser.total_size, len(pkt) + (3 * len(CRLF)) + len(host_hdr)) self.assertEqual(self.parser.headers[b'host'], (b'Host', b'localhost:8080')) self.assertEqual(self.parser.state, httpParserStates.COMPLETE)
def test_get_partial_parse2(self) -> None: self.parser.parse( CRLF.join([b'GET http://localhost:8080 HTTP/1.1', b'Host: '])) self.assertEqual(self.parser.method, b'GET') assert self.parser.url self.assertEqual(self.parser.url.hostname, b'localhost') self.assertEqual(self.parser.url.port, 8080) self.assertEqual(self.parser.version, b'HTTP/1.1') self.assertEqual(self.parser.buffer, b'Host: ') self.assertEqual(self.parser.state, httpParserStates.LINE_RCVD) self.parser.parse(b'localhost:8080' + CRLF) self.assertEqual(self.parser.headers[b'host'], (b'Host', b'localhost:8080')) self.assertEqual(self.parser.buffer, b'') self.assertEqual(self.parser.state, httpParserStates.RCVING_HEADERS) self.parser.parse(b'Content-Type: text/plain' + CRLF) self.assertEqual(self.parser.buffer, b'') self.assertEqual(self.parser.headers[b'content-type'], (b'Content-Type', b'text/plain')) self.assertEqual(self.parser.state, httpParserStates.RCVING_HEADERS) self.parser.parse(CRLF) self.assertEqual(self.parser.state, httpParserStates.COMPLETE)
def test_post_full_parse(self) -> None: raw = CRLF.join([ b'POST %s HTTP/1.1', b'Host: localhost', b'Content-Length: 7', b'Content-Type: application/x-www-form-urlencoded' + CRLF, b'a=b&c=d', ]) self.parser.parse(raw % b'http://localhost') self.assertEqual(self.parser.method, b'POST') assert self.parser._url self.assertEqual(self.parser._url.hostname, b'localhost') self.assertEqual(self.parser._url.port, None) self.assertEqual(self.parser.version, b'HTTP/1.1') assert self.parser.headers self.assertEqual( self.parser.headers[b'content-type'], (b'Content-Type', b'application/x-www-form-urlencoded'), ) self.assertEqual( self.parser.headers[b'content-length'], (b'Content-Length', b'7'), ) self.assertEqual(self.parser.body, b'a=b&c=d') self.assertEqual(self.parser.buffer, b'') self.assertEqual(self.parser.state, httpParserStates.COMPLETE) self.assertEqual(len(self.parser.build()), len(raw % b'/'))
def test_get_full_parse(self) -> None: raw = CRLF.join([ b'GET %s HTTP/1.1', b'Host: %s', CRLF, ]) pkt = raw % ( b'https://example.com/path/dir/?a=b&c=d#p=q', b'example.com', ) self.parser.parse(pkt) self.assertEqual(self.parser.total_size, len(pkt)) assert self.parser._url and self.parser._url.remainder self.assertEqual(self.parser._url.remainder, b'/path/dir/?a=b&c=d#p=q') self.assertEqual(self.parser.method, b'GET') self.assertEqual(self.parser._url.hostname, b'example.com') self.assertEqual(self.parser._url.port, None) self.assertEqual(self.parser.version, b'HTTP/1.1') self.assertEqual(self.parser.state, httpParserStates.COMPLETE) assert self.parser.headers self.assertEqual( self.parser.headers[b'host'], (b'Host', b'example.com'), ) self.parser.del_headers([b'host']) self.parser.add_headers([(b'Host', b'example.com')]) self.assertEqual( raw % ( b'/path/dir/?a=b&c=d#p=q', b'example.com', ), self.parser.build(), )
def _setUp(self, request: Any, mocker: MockerFixture) -> None: self.mock_fromfd = mocker.patch('socket.fromfd') self.mock_selector = mocker.patch('selectors.DefaultSelector') self.fileno = 10 self._addr = ('127.0.0.1', 54382) self._conn = self.mock_fromfd.return_value self.pac_file = request.param if isinstance(self.pac_file, str): with open(self.pac_file, 'rb') as f: self.expected_response = f.read() else: self.expected_response = PAC_FILE_CONTENT self.flags = FlagParser.initialize( pac_file=self.pac_file, threaded=True, ) self.flags.plugins = Plugins.load([ bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER), bytes_(PLUGIN_PAC_FILE), ]) self.protocol_handler = HttpProtocolHandler( HttpClientConnection(self._conn, self._addr), flags=self.flags, ) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET / HTTP/1.1', CRLF, ]) mock_selector_for_client_read(self)
def test_proxy_connection_failed(self) -> None: self.mock_selector_for_client_read(self.mock_selector) self._conn.recv.return_value = CRLF.join([ b'GET http://unknown.domain HTTP/1.1', b'Host: unknown.domain', CRLF ]) self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.client.buffer[0], ProxyConnectionFailed.RESPONSE_PKT)
def test_build_response(self) -> None: self.assertEqual( okResponse(protocol_version=b'HTTP/1.1'), CRLF.join([ b'HTTP/1.1 200 OK', CRLF, ]), ) self.assertEqual( okResponse( headers={b'key': b'value'}, protocol_version=b'HTTP/1.1', ), CRLF.join([ b'HTTP/1.1 200 OK', b'key: value', CRLF, ]), )
def test_status_code_response(self) -> None: e = HttpRequestRejected(status_code=200, reason=b'OK') self.assertEqual( e.response(self.request), CRLF.join([ b'HTTP/1.1 200 OK', b'Connection: close', CRLF, ]), )
def test_build_request(self) -> None: self.assertEqual( build_http_request(b'GET', b'http://localhost:12345', b'HTTP/1.1'), CRLF.join([b'GET http://localhost:12345 HTTP/1.1', CRLF])) self.assertEqual( build_http_request(b'GET', b'http://localhost:12345', b'HTTP/1.1', headers={b'key': b'value'}), CRLF.join( [b'GET http://localhost:12345 HTTP/1.1', b'key: value', CRLF])) self.assertEqual( build_http_request(b'GET', b'http://localhost:12345', b'HTTP/1.1', headers={b'key': b'value'}, body=b'Hello from py'), CRLF.join([ b'GET http://localhost:12345 HTTP/1.1', b'key: value', CRLF ]) + b'Hello from py')
def test_build_response_adds_content_length_header(self) -> None: body = b'Hello world!!!' self.assertEqual( build_http_response(200, reason=b'OK', protocol_version=b'HTTP/1.1', headers={b'key': b'value'}, body=body), CRLF.join([ b'HTTP/1.1 200 OK', b'key: value', b'Content-Length: ' + bytes_(len(body)), CRLF ]) + body)
async def test_proxy_connection_failed(self) -> None: mock_selector_for_client_read(self) self._conn.recv.return_value = CRLF.join([ b'GET http://unknown.domain HTTP/1.1', b'Host: unknown.domain', CRLF, ]) await self.protocol_handler._run_once() self.assertEqual( self.protocol_handler.work.buffer[0], BAD_GATEWAY_RESPONSE_PKT, )
async def test_proxy_bails_out_for_sip_request_lines(self) -> None: mock_selector_for_client_read(self) self._conn.recv.return_value = CRLF.join([ b'OPTIONS sip:nm SIP/2.0', b'Accept: application/sdp', CRLF, ]) await self.protocol_handler._run_once() self.assertEqual( self.protocol_handler.work.buffer[0], BAD_REQUEST_RESPONSE_PKT, )
async def test_proxy_bails_out_for_unknown_schemes(self) -> None: mock_selector_for_client_read(self) self._conn.recv.return_value = CRLF.join([ b'REQMOD icap://icap-server.net/server?arg=87 ICAP/1.0', b'Host: icap-server.net', CRLF, ]) await self.protocol_handler._run_once() self.assertEqual( self.protocol_handler.work.buffer[0], BAD_REQUEST_RESPONSE_PKT, )
def init_and_make_pac_file_request(self, pac_file: str) -> None: flags = Flags(pac_file=pac_file) flags.plugins = Flags.load_plugins( b'proxy.http.proxy.HttpProxyPlugin,proxy.http.server.HttpWebServerPlugin,' b'proxy.http.server.HttpWebServerPacFilePlugin') self.protocol_handler = HttpProtocolHandler(TcpClientConnection( self._conn, self._addr), flags=flags) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET / HTTP/1.1', CRLF, ])
def test_http_tunnel(self, mock_server_connection: mock.Mock) -> None: server = mock_server_connection.return_value server.connect.return_value = True def has_buffer() -> bool: return cast(bool, server.queue.called) server.has_buffer.side_effect = has_buffer self.mock_selector.return_value.select.side_effect = [ [ (selectors.SelectorKey(fileobj=self._conn, fd=self._conn.fileno, events=selectors.EVENT_READ, data=None), selectors.EVENT_READ), ], [ (selectors.SelectorKey(fileobj=self._conn, fd=self._conn.fileno, events=0, data=None), selectors.EVENT_WRITE), ], [ (selectors.SelectorKey(fileobj=self._conn, fd=self._conn.fileno, events=selectors.EVENT_READ, data=None), selectors.EVENT_READ), ], [ (selectors.SelectorKey(fileobj=server.connection, fd=server.connection.fileno, events=0, data=None), selectors.EVENT_WRITE), ], ] assert self.http_server_port is not None self._conn.recv.return_value = CRLF.join([ b'CONNECT localhost:%d HTTP/1.1' % self.http_server_port, b'Host: localhost:%d' % self.http_server_port, b'User-Agent: proxy.py/%s' % bytes_(__version__), b'Proxy-Connection: Keep-Alive', CRLF ]) self.assert_tunnel_response(mock_server_connection, server) # Dispatch tunnel established response to client self.protocol_handler.run_once() self.assert_data_queued_to_server(server) self.protocol_handler.run_once() self.assertEqual(server.queue.call_count, 1) server.flush.assert_called_once()
def init_and_make_pac_file_request(self, pac_file: str) -> None: flags = Proxy.initialize(pac_file=pac_file) flags.plugins = Proxy.load_plugins([ bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER), bytes_(PLUGIN_PAC_FILE), ]) self.protocol_handler = HttpProtocolHandler( TcpClientConnection(self._conn, self._addr), flags=flags) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET / HTTP/1.1', CRLF, ])
async def test_authenticated_proxy_http_get(self) -> None: self._conn = self.mock_fromfd.return_value mock_selector_for_client_read(self) server = self.mock_server_connection.return_value server.connect.return_value = True server.buffer_size.return_value = 0 flags = FlagParser.initialize( auth_code=base64.b64encode(b'user:pass'), threaded=True, ) flags.plugins = Plugins.load([ bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER), ]) self.protocol_handler = HttpProtocolHandler( HttpClientConnection(self._conn, self._addr), flags=flags, ) self.protocol_handler.initialize() assert self.http_server_port is not None self._conn.recv.return_value = b'GET http://localhost:%d HTTP/1.1' % self.http_server_port await self.protocol_handler._run_once() self.assertEqual( self.protocol_handler.request.state, httpParserStates.INITIALIZED, ) self._conn.recv.return_value = CRLF await self.protocol_handler._run_once() self.assertEqual( self.protocol_handler.request.state, httpParserStates.LINE_RCVD, ) assert self.http_server_port is not None self._conn.recv.return_value = CRLF.join([ b'User-Agent: proxy.py/%s' % bytes_(__version__), b'Host: localhost:%d' % self.http_server_port, b'Accept: */*', httpHeaders.PROXY_CONNECTION + b': Keep-Alive', httpHeaders.PROXY_AUTHORIZATION + b': Basic dXNlcjpwYXNz', CRLF, ]) await self.assert_data_queued(server)
def test_request_parse_without_content_length(self) -> None: """Case when incoming request doesn't contain a content-length header. From http://w3-org.9356.n7.nabble.com/POST-with-empty-body-td103965.html 'A POST with no content-length and no body is equivalent to a POST with Content-Length: 0 and nothing following, as could perfectly happen when you upload an empty file for instance.' See https://github.com/abhinavsingh/py/issues/20 for details. """ self.parser.parse( CRLF.join([ b'POST http://localhost HTTP/1.1', b'Host: localhost', b'Content-Type: application/x-www-form-urlencoded', CRLF ])) self.assertEqual(self.parser.method, b'POST') self.assertEqual(self.parser.state, httpParserStates.COMPLETE)
def assert_data_queued_to_server(self, server: mock.Mock) -> None: assert self.http_server_port is not None self.assertEqual(self._conn.send.call_args[0][0], HttpProxyPlugin.PROXY_TUNNEL_ESTABLISHED_RESPONSE_PKT) pkt = CRLF.join([ b'GET / HTTP/1.1', b'Host: localhost:%d' % self.http_server_port, b'User-Agent: proxy.py/%s' % bytes_(__version__), CRLF ]) self._conn.recv.return_value = pkt self.protocol_handler.run_once() server.queue.assert_called_once_with(pkt) server.buffer_size.return_value = len(pkt) server.flush.assert_not_called()
def assert_data_queued(self, mock_server_connection: mock.Mock, server: mock.Mock) -> None: self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.request.state, httpParserStates.COMPLETE) mock_server_connection.assert_called_once() server.connect.assert_called_once() server.closed = False assert self.http_server_port is not None pkt = CRLF.join([ b'GET / HTTP/1.1', b'User-Agent: proxy.py/%s' % bytes_(__version__), b'Host: localhost:%d' % self.http_server_port, b'Accept: */*', b'Via: 1.1 proxy.py v%s' % bytes_(__version__), CRLF ]) server.queue.assert_called_once_with(pkt) server.buffer_size.return_value = len(pkt)
def test_proxy_authentication_failed(self, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None: self._conn = mock_fromfd.return_value self.mock_selector_for_client_read(mock_selector) flags = Flags(auth_code=b'Basic %s' % base64.b64encode(b'user:pass')) flags.plugins = Flags.load_plugins( b'proxy.http.proxy.HttpProxyPlugin,proxy.http.server.HttpWebServerPlugin' ) self.protocol_handler = HttpProtocolHandler(TcpClientConnection( self._conn, self._addr), flags=flags) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET http://abhinavsingh.com HTTP/1.1', b'Host: abhinavsingh.com', CRLF ]) self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.client.buffer[0], ProxyAuthenticationFailed.RESPONSE_PKT)
def test_authenticated_proxy_http_get(self, mock_server_connection: mock.Mock, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None: self._conn = mock_fromfd.return_value self.mock_selector_for_client_read(mock_selector) server = mock_server_connection.return_value server.connect.return_value = True server.buffer_size.return_value = 0 flags = Proxy.initialize(auth_code=base64.b64encode(b'user:pass')) flags.plugins = Proxy.load_plugins([ bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER), ]) self.protocol_handler = HttpProtocolHandler(TcpClientConnection( self._conn, self._addr), flags=flags) self.protocol_handler.initialize() assert self.http_server_port is not None self._conn.recv.return_value = b'GET http://localhost:%d HTTP/1.1' % self.http_server_port self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.request.state, httpParserStates.INITIALIZED) self._conn.recv.return_value = CRLF self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.request.state, httpParserStates.LINE_RCVD) assert self.http_server_port is not None self._conn.recv.return_value = CRLF.join([ b'User-Agent: proxy.py/%s' % bytes_(__version__), b'Host: localhost:%d' % self.http_server_port, b'Accept: */*', b'Proxy-Connection: Keep-Alive', b'Proxy-Authorization: Basic dXNlcjpwYXNz', CRLF ]) self.assert_data_queued(mock_server_connection, server)
def test_proxy_authentication_failed(self, mock_fromfd: mock.Mock, mock_selector: mock.Mock) -> None: self._conn = mock_fromfd.return_value self.mock_selector_for_client_read(mock_selector) flags = Proxy.initialize(auth_code=base64.b64encode(b'user:pass')) flags.plugins = Proxy.load_plugins([ bytes_(PLUGIN_HTTP_PROXY), bytes_(PLUGIN_WEB_SERVER), bytes_(PLUGIN_PROXY_AUTH), ]) self.protocol_handler = HttpProtocolHandler(TcpClientConnection( self._conn, self._addr), flags=flags) self.protocol_handler.initialize() self._conn.recv.return_value = CRLF.join([ b'GET http://abhinavsingh.com HTTP/1.1', b'Host: abhinavsingh.com', CRLF ]) self.protocol_handler.run_once() self.assertEqual(self.protocol_handler.client.buffer[0], ProxyAuthenticationFailed.RESPONSE_PKT)