Python request_handler.RequestHandler类代码示例

class RequestHandlerTestCase(unittest.TestCase):

    def setUp(self):
        self.request = RequestHandler()
        self.request.connect(EXAMPLE_APP)

    def test_should_receive_an_url_and_get_a_success_response(self):
        self.assertTrue(self.request.status_code.is_success())

    def test_should_start_a_request_with_localhost_and_get_localhost_as_hostname(self):
        self.assertEqual("localhost", self.request.host)

    def test_should_start_a_request_with_localhost_in_port_5000_and_get_5000_as_port(self):
        self.assertEqual(5000, self.request.port)

    def test_should_visit_alert_page_and_get_a_success_response(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "alert")
        self.assertTrue(request.status_code.is_success())

    def test_should_compare_app_index_with_404_and_get_false(self):
        self.assertFalse(self.request.status_code == 404)

    def test_should_get_an_absent_url_and_get_false_when_call_to_is_success(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        self.assertFalse(request.status_code.is_success())

    def test_should_get_an_absent_url_and_raise_an_exception(self):
        with self.assertRaises(HttpResponseError):
            request = RequestHandler()
            request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
            request.ensure_success_response()

    def test_should_get_an_exception_and_format_it_using_the_exception_attrs(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        try:
            request.ensure_success_response()
        except HttpResponseError as e:
            exception = e.msg
        self.assertEqual("404 - Not Found", exception)

    def test_should_be_able_to_represent_exception_as_string(self):
        "HttpResponseError exception should be representable as string"
        error = HttpResponseError(404, "Not Found")
        self.assertEqual("404 - Not Found", str(error))

    def test_should_not_connect_to_non_http_protocols(self):
        mockfile_path = "file://%s" % os.path.join(TESTS_ROOT, "mockfile.txt")
        request = RequestHandler()
        request.connect(mockfile_path)
        self.assertTrue(request.status_code.is_success())
        
    def test_should_connect_to_pages_with_query_string(self):
        request = RequestHandler()
        url = EXAMPLE_APP + "query?model"
        request.connect(url)
        self.assertTrue(request.status_code.is_success())

 def test_should_connect_to_https_protocols(self):
     # We do not run an HTTPS server, but we know we handle https
     # if we get an SSLError accessing a non-HTTPS site.
     with self.assertRaises(SSLError):
         request = RequestHandler()
         url = EXAMPLE_APP.replace('http', 'https')
         request.connect(url)
         self.assertEqual(request.scheme, 'https')

 def test_should_get_an_exception_and_format_it(self):
     request = RequestHandler()
     request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
     try:
         request.ensure_success_response()
     except HttpResponseError as e:
         exception = e.msg
     self.assertEqual("404 - Not Found", exception)

def _transcripts_are_downloaded():
    world.wait_for_ajax_complete()
    request = RequestHandler()
    DOWNLOAD_BUTTON = world.css_find(TRANSCRIPTS_BUTTONS["download_to_edit"][0]).first
    url = DOWNLOAD_BUTTON["href"]
    request.connect(url)

    return request.status_code.is_success()

 def test_should_get_an_exception_and_format_it_using_the_exception_attrs(self):
     request = RequestHandler()
     request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
     try:
         request.ensure_success_response()
     except HttpResponseError as e:
         exception = "I failed with code %d and reason %s" % (e.status_code, e.reason)
     assert_equals(exception, "I failed with code 404 and reason Not Found")

class RequestHandlerTestCase(unittest.TestCase):
    def setUp(self):
        self.request = RequestHandler()
        self.request.connect(EXAMPLE_APP)

    def test_should_receive_an_url_and_get_a_success_response(self):
        assert_true(self.request.status_code.is_success())

    def test_should_start_a_request_with_localhost_and_get_localhost_as_hostname(self):
        assert_equals(self.request.host, "localhost")

    def test_should_start_a_request_with_localhost_in_port_5000_and_get_5000_as_port(self):
        assert_equals(self.request.port, 5000)

    def test_should_visit_alert_page_and_get_a_success_response(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "alert")
        assert_true(request.status_code.is_success())

    def test_should_compare_app_index_with_404_and_get_false(self):
        assert_false(self.request.status_code == 404)

    def test_should_get_an_absent_url_and_get_false_when_call_to_is_success(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        assert_false(request.status_code.is_success())

    @raises(HttpResponseError)
    def test_should_get_an_absent_url_and_raise_an_exception(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        request.ensure_success_response()

    def test_should_get_an_exception_and_format_it_using_the_exception_attrs(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        try:
            request.ensure_success_response()
        except HttpResponseError as e:
            exception = "I failed with code %d and reason %s" % (e.status_code, e.reason)
        assert_equals(exception, "I failed with code 404 and reason Not Found")

 def test_should_be_able_to_connect_with_basic_auth(self):
     request = RequestHandler()
     url = 'http://admin:[email protected]:5000/authenticate'
     request.connect(url)
     self.assertEqual(b'Success!', request.response.read())

 def test_should_set_user_agent(self):
     request = RequestHandler()
     url = EXAMPLE_APP + 'useragent'
     request.connect(url)
     self.assertEqual(b'python/splinter', request.response.read())

 def test_should_connect_to_pages_with_query_string(self):
     request = RequestHandler()
     url = EXAMPLE_APP + "query?model"
     request.connect(url)
     self.assertTrue(request.status_code.is_success())

 def test_should_not_connect_to_non_http_protocols(self):
     mockfile_path = "file://%s" % os.path.join(TESTS_ROOT, "mockfile.txt")
     request = RequestHandler()
     request.connect(mockfile_path)
     self.assertTrue(request.status_code.is_success())

 def test_should_get_an_absent_url_and_raise_an_exception(self):
     with self.assertRaises(HttpResponseError):
         request = RequestHandler()
         request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
         request.ensure_success_response()

 def test_is_success_should_be_false_when_url_does_not_exists(self):
     request = RequestHandler()
     request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
     self.assertFalse(request.status_code.is_success())

 def test_should_visit_alert_page_and_get_a_success_response(self):
     request = RequestHandler()
     request.connect(EXAMPLE_APP + "alert")
     self.assertTrue(request.status_code.is_success())

 def setUp(self):
     self.request = RequestHandler()
     self.request.connect(EXAMPLE_APP)

class RequestHandlerTestCase(unittest.TestCase):

    def setUp(self):
        self.request = RequestHandler()
        self.request.connect(EXAMPLE_APP)

    def test_should_receive_an_url_and_get_a_success_response(self):
        self.assertTrue(self.request.status_code.is_success())

    def test_should_start_a_request_with_localhost(self):
        self.assertEqual("127.0.0.1", self.request.host)

    def test_should_start_a_request_with_port_5000(self):
        self.assertEqual(5000, self.request.port)

    def test_should_visit_alert_page_and_get_a_success_response(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "alert")
        self.assertTrue(request.status_code.is_success())

    def test_should_compare_app_index_with_404_and_get_false(self):
        self.assertFalse(self.request.status_code == 404)

    def test_is_success_should_be_false_when_url_does_not_exists(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        self.assertFalse(request.status_code.is_success())

    def test_should_get_an_absent_url_and_raise_an_exception(self):
        with self.assertRaises(HttpResponseError):
            request = RequestHandler()
            request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
            request.ensure_success_response()

    def test_should_get_an_exception_and_format_it(self):
        request = RequestHandler()
        request.connect(EXAMPLE_APP + "page-that-doesnt-exists")
        try:
            request.ensure_success_response()
        except HttpResponseError as e:
            exception = e.msg
        self.assertEqual("404 - Not Found", exception)

    def test_should_be_able_to_represent_exception_as_string(self):
        "HttpResponseError exception should be representable as string"
        error = HttpResponseError(404, "Not Found")
        self.assertEqual("404 - Not Found", str(error))

    def test_should_not_connect_to_non_http_protocols(self):
        mockfile_path = "file://%s" % os.path.join(TESTS_ROOT, "mockfile.txt")
        request = RequestHandler()
        request.connect(mockfile_path)
        self.assertTrue(request.status_code.is_success())

    def test_should_connect_to_pages_with_query_string(self):
        request = RequestHandler()
        url = EXAMPLE_APP + "query?model"
        request.connect(url)
        self.assertTrue(request.status_code.is_success())

    def test_should_connect_to_https_protocols(self):
        # We do not run an HTTPS server, but we know we handle https
        # if we get an SSLError accessing a non-HTTPS site.
        with self.assertRaises(SSLError):
            request = RequestHandler()
            url = EXAMPLE_APP.replace('http', 'https')
            request.connect(url)
            self.assertEqual(request.scheme, 'https')

    def test_should_set_user_agent(self):
        request = RequestHandler()
        url = EXAMPLE_APP + 'useragent'
        request.connect(url)
        self.assertEqual(b'python/splinter', request.response.read())

    def test_should_be_able_to_connect_with_basic_auth(self):
        request = RequestHandler()
        url = 'http://admin:[email protected]:5000/authenticate'
        request.connect(url)
        self.assertEqual(b'Success!', request.response.read())