def request(self, host, handler, request_body, verbose=0): request = "POST %s HTTP/1.0\n" % (handler,) request += "Content-Length: %i\n" % len(request_body) request += "Content-Type: text/xml\n" host, extra_headers, x509 = self.get_host_info(host) if extra_headers: request += "Authorization: %s\n" \ % (dict(extra_headers)["Authorization"],) request += "\n" + request_body response = HTTPCaller()(request, handle_errors=self.handleErrors) errcode = response.getStatus() errmsg = response.getStatusString() # This is not the same way that the normal transport deals # with the headers. headers = response.getHeaders() if errcode != 200: raise xmlrpclib.ProtocolError( host + handler, errcode, errmsg, headers ) return self._parse_response( StringIO.StringIO(response.getBody()), sock=None)
def __init__(self, *args, **kw): if kw.get("debug"): self._debug = True del kw["debug"] else: self._debug = False HTTPCaller.__init__(self, *args, **kw)
def __init__(self, *args, **kw): if kw.get('debug'): self._debug = True del kw['debug'] else: self._debug = False HTTPCaller.__init__(self, *args, **kw)
def __call__(self, *args, **kw): if self._debug: pdb.set_trace() try: return HTTPCaller.__call__(self, *args, **kw) finally: self.resetCookies()
def suiteFromPackage(name): files = resource_listdir(__name__, name) suite = unittest.TestSuite() for filename in files: if not filename.endswith('.py'): continue if filename == '__init__.py': continue if filename[0] in ( '.', '#', ): continue dottedname = 'megrok.z3cpt.ftests.%s.%s' % (name, filename[:-3]) test = doctest.DocTestSuite( dottedname, setUp=setUp, tearDown=tearDown, checker=checker, extraglobs=dict(http=HTTPCaller(), getRootFolder=getRootFolder, sync=sync), optionflags=(doctest.ELLIPSIS + doctest.NORMALIZE_WHITESPACE + doctest.REPORT_NDIFF)) test.layer = FunctionalLayer suite.addTest(test) return suite
def test_put(self): # PUT something for the first time response = HTTPCaller()(r"""PUT /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3 Content-Length: 20 Content-Type: text/plain This is just a test.""") self.assertEquals(response._response.getStatus(), 201) self.assertEquals(response._response.getHeader("Location"), "http://localhost/testfile.txt") response = HTTPCaller()(r"""GET /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3""") self.assertEquals(response.getBody(), "This is just a test.") # now modify it response = HTTPCaller()(r"""PUT /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3 Content-Length: 23 Content-Type: text/plain And now it is modified.""") self.assertEquals(response._response.getStatus(), 200) self.assertEquals(response.getBody(), "") response = HTTPCaller()(r"""GET /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3""") self.assertEquals(response.getBody(), "And now it is modified.")
def chooseRequestClass(self, method, path, environment): """See `HTTPCaller`. This version adds the 'PATH_INFO' variable to the environment, because some of our factories expects it. """ if 'PATH_INFO' not in environment: environment = dict(environment) environment['PATH_INFO'] = path return HTTPCaller.chooseRequestClass(self, method, path, environment)
def chooseRequestClass(self, method, path, environment): """See `HTTPCaller`. This version adds the 'PATH_INFO' variable to the environment, because some of our factories expects it. """ if "PATH_INFO" not in environment: environment = dict(environment) environment["PATH_INFO"] = path return HTTPCaller.chooseRequestClass(self, method, path, environment)
def test_registered(self): # The Navigation is registered and traversable over HTTP. spph = self.makeSPPHWithChangelog() lfa_url = spph.sourcepackagerelease.changelog.http_url redir_url = (canonical_url(spph, path_only_if_possible=True) + '/+files/changelog') logout() response = str(HTTPCaller()("GET %s HTTP/1.1\n\n" % redir_url)) self.assertThat( response, MatchesAll(Contains("HTTP/1.1 303 See Other"), Contains("Location: %s" % lfa_url)))
def request(self, host, handler, request_body, verbose=0): request = "POST %s HTTP/1.0\n" % (handler, ) request += "Content-Length: %i\n" % len(request_body) request += "Content-Type: text/xml\n" host, extra_headers, x509 = self.get_host_info(host) if extra_headers: request += "Authorization: %s\n" \ % (dict(extra_headers)["Authorization"],) request += "\n" + request_body response = HTTPCaller()(request, handle_errors=self.handleErrors) errcode = response.getStatus() errmsg = response.getStatusString() # This is not the same way that the normal transport deals # with the headers. headers = response.getHeaders() if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) return self._parse_response(StringIO.StringIO(response.getBody()), sock=None)
def request(self, host, handler, request_body, verbose=0): request = "POST %s HTTP/1.0\n" % (handler,) request += "Content-Length: %i\n" % len(request_body) request += "Content-Type: text/xml\n" host, extra_headers, _x509 = self.get_host_info(host) if extra_headers: request += "Authorization: %s\n" % ( dict(extra_headers)["Authorization"],) request += "\n" if isinstance(request_body, bytes) and str is not bytes: # Python 3 request = request.encode("ascii") request += request_body if not isinstance(request, str) and str is not bytes: request = request.decode("utf-8") response = HTTPCaller()(request, handle_errors=self.handleErrors) errcode = response.getStatus() errmsg = response.getStatusString() # This is not the same way that the normal transport deals with the # headers. headers = response.getHeaders() if errcode != 200: # pragma: no cover raise xmlrpclib.ProtocolError( host + handler, errcode, errmsg, headers ) content = 'HTTP/1.0 ' + errmsg + '\n\n' + response.getBody() res = HTTPResponse(FakeSocket(content)) res.begin() return self.parse_response(res)
def http_call(method, path, data=None, **kw): """Function to help make RESTful calls. method - HTTP method to use path - testbrowser style path data - (body) data to submit kw - any request parameters """ if path.startswith('http://localhost'): path = path[len('http://localhost'):] request_string = '%s %s HTTP/1.1\n' % (method, path) for key, value in kw.items(): request_string += '%s: %s\n' % (key, value) if data is not None: request_string += '\r\n' request_string += data return HTTPCaller()(request_string, handle_errors=False)
def test_suite(): suite = unittest.TestSuite() test_modules = ['catalog', 'xmlrpc'] for module in test_modules: module_name = 'bookshelf.ftests.%s' % module test = doctest.DocTestSuite( module_name, setUp=setUp, tearDown=tearDown, extraglobs=dict(http=HTTPCaller(), getRootFolder=getRootFolder, sync=sync), optionflags=(doctest.ELLIPSIS + doctest.NORMALIZE_WHITESPACE + doctest.REPORT_NDIFF)) test.layer = BookShelfFunctionalLayer suite.addTest(test) return suite
def FunctionalDocTestSuite(*paths, **kw): globs = kw.setdefault('globs', {}) globs['http'] = HTTPCaller() globs['getRootFolder'] = getRootFolder globs['sync'] = sync #kw['package'] = doctest._normalize_module(kw.get('package')) kwsetUp = kw.get('setUp') def setUp(test): FunctionalTestSetup().setUp() if kwsetUp is not None: kwsetUp(test) kw['setUp'] = setUp kwtearDown = kw.get('tearDown') def tearDown(test): if kwtearDown is not None: kwtearDown(test) FunctionalTestSetup().tearDown() kw['tearDown'] = tearDown if 'optionflags' not in kw: old = doctest.set_unittest_reportflags(0) doctest.set_unittest_reportflags(old) kw['optionflags'] = (old | doctest.ELLIPSIS | doctest.REPORT_NDIFF | doctest.NORMALIZE_WHITESPACE) suite = doctest.DocTestSuite(*paths, **kw) suite.layer = Functional return suite
def setUp(self): TestCase.setUp(self) self.http = HTTPCaller() self.original_flag = haproxy.going_down_flag self.addCleanup(haproxy.set_going_down_flag, self.original_flag)
def __init__(self, host): httplib.HTTPConnection.__init__(self, host) self.caller = HTTPCaller()
def __init__(self, host, timeout=None): from zope.app.testing.functional import HTTPCaller self.caller = HTTPCaller() self.host = host
def serve(self, url=None, port=8000): if url is None: url = self.url startServer(HTTPCaller(), url, self.username, self.password, port=port)
def test_put(self): # PUT something for the first time response = HTTPCaller()(r"""PUT /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3 Content-Length: 20 Content-Type: text/plain This is just a test.""") self.assertEquals(response._response.getStatus(), 201) self.assertEquals(response._response.getHeader("Location"), "http://localhost/testfile.txt") response = HTTPCaller()(r"""GET /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3""") self.assertEquals(response.getBody(), "This is just a test.") # now modify it response = HTTPCaller()(r"""PUT /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3 Content-Length: 22 Content-Type: text/plain And now it is modified.""") self.assertEquals(response._response.getStatus(), 200) self.assertEquals(response.getBody(), "") response = HTTPCaller()(r"""GET /testfile.txt HTTP/1.1 Authorization: Basic bWdyOm1ncnB3""") self.assertEquals(response.getBody(), "And now it is modified.")
def http(indented_request_string, http_caller=HTTPCaller()): """Dedent the request string and perform the HTTP request.""" rq = textwrap.dedent(indented_request_string).strip() return http_caller(rq, handle_errors=False)