Python util.setup_testing_defaults函数代码示例

 def request(self, application, url, query_string="", post_data=b""):
     """Hand a request to the application as if sent by a client.
     @param application: The callable wsgi application to test.
     @param url: The URL to make the request against.
     @param query_string: Url parameters.
     @param post_data: bytes to post."""
     self.response_started = False
     method = 'POST' if post_data else 'GET'
     temp = io.BytesIO(post_data)
     environ = {
         'PATH_INFO': url,
         'REQUEST_METHOD': method,
         'CONTENT_LENGTH': len(post_data),
         'QUERY_STRING': query_string,
         'wsgi.input': temp,
     }
     if method == "POST":
         environ["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
     setup_testing_defaults(environ)
     if self.cookies:
         environ['HTTP_COOKIE'] = ';'.join(self.cookies)
     response = b''
     for ret in application(environ, self._start_response):
         assert self.response_started
         response += ret
     temp.close()
     return response

 def _makeEnv(self, **kw):
     from wsgiref.util import setup_testing_defaults
     env = {}
     setup_testing_defaults(env)
     env.update(kw)
     env['QUERY_STRING'] = ''
     return env

def serve(environ, start_response):
	setup_testing_defaults(environ)


	web_path = environ['PATH_INFO']
	local_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
	path = local_path + '/www' + web_path
	#sys.stderr.write(web_path + "\n")
	#sys.stderr.write(local_path + "\n")
	sys.stderr.write(path + "\n")
	# if path is a directory add index.html to the end of it
	if not os.path.exists(path):
		return not_found(start_response)


	# if no index.html, shall we provide directory listing?
	if os.path.isdir(path):
		path += '/index.html'

	if not os.path.exists(path):
		return not_found(start_response)

	fh = open(path, 'r')
	status = '200 OK'
	headers = [('Content-type', 'text/html')]
	start_response(status, headers)
	return fh 

 def create_event(self, **kwargs):
     router = Router({"home": {"path": "/"}})
     environ = {}
     util.setup_testing_defaults(environ)
     environ.update(**kwargs)
     event = Event("TestEvent", params={"router": router, "request": create_request_from_environ(environ)})
     return event

    def __call__(self, environ, start_response):

        # parse the request
        setup_testing_defaults(environ)
        path = environ['PATH_INFO']
        querystring = environ['QUERY_STRING']
        multiargs = urlparse.parse_qs(querystring)

        # get the route and the associated Python method, then execute
        # that method with the given querystring parameters as Python kwargs
        if path[1:]:
            path_method = 'get_%s' % path[1:]
        else:
            path_method = 'get_index'
        if hasattr(self.__routable_object, path_method):

            # call the routed method
            single_value_args = {}
            for key in multiargs:
                single_value_args[key] = multiargs[key][0]
            status, content_type, content = getattr(self.__routable_object, path_method)(**single_value_args)

        else:
            # route doesn't exist
            content_type = 'text/html'
            content = status = '404 NOT FOUND'

        # write out the HTTP response
        status = '200 OK'
        headers = [('Content-type', content_type)]
        start_response(status, headers)
        return [content]

    def test_stats_w_logging_client(self):
        # In the case where a statsd server has not been configured,
        #   stats info is sent to a log using a custom class that provides
        #   the same interface as the statsd.StatsClient.
        metric_data = {
            'type': 'timing',
            'label': 'i.haz.thunkd.cheezburgr',
            'value': 300,
            }
        environ = {
            'PATH_INFO': '/metric',
            'REQUEST_METHOD': 'POST',
            }
        setup_testing_defaults(environ)
        # Assign the posted message.
        environ['wsgi.input'].write(json.dumps(metric_data))
        environ['wsgi.input'].seek(0)

        resp_body = self.app(environ, self.start_response)

        # Check response, smoke test.
        self.assertEqual(resp_body, [])
        self.assertEqual(self.resp_args[0].upper(), '200 OK')
        self.assertEqual(self.resp_args[1], [])

        # Check the metric was accepted.
        self.assertEqual([x.msg for x in self.logged],
                         ['i.haz.thunkd.cheezburgr:300|ms'])

 def execute(self):
     try:
         router = self.container.get('router')
         if not router.routes:
             raise ConsoleError('There are no routes associated with the application.')
         if self.parsed_args.url:
             environ = {}
             util.setup_testing_defaults(environ)
             environ.update({
                 'REQUEST_METHOD': self.parsed_args.method or 'GET',
                 'HTTP_ACCEPT': self.parsed_args.format or 'text/html',
                 'PATH_INFO': self.parsed_args.url,
                 'SERVER_NAME': self.parsed_args.server or '127.0.0.1'
             })
             request = create_request_from_environ(environ)
             matches = router.matches(request)
             if matches:
                 sys.stdout.write(colors.header('Displaying {0} matching routes for the application:\n'.format(len(matches))))
                 for match in matches:
                     sys.stdout.write('{0}\t\t\{1}\t\t{2}\n'.format(colors.ok_green(match.route.name), match.route.path, match.route.regex.pattern))
             else:
                 raise ConsoleError('There are no matching routes.')
         else:
             sys.stdout.write(colors.header('Displaying {0} routes for the application:\n'.format(len(router))))
             for name, route in router:
                 sys.stdout.write('{0}\t\t{1}\n'.format(name, route.path))
     except ConsoleError:
         raise
     except:
         _no_application_error()

def dummy_request(env, uname=None):
    environ = {}
    setup_testing_defaults(environ)
    environ.update({
                'REQUEST_METHOD' : 'GET',
                'SCRIPT_NAME' : urlparse(str(env._abs_href())).path,
                'trac.base_url' : str(env._abs_href()), 
                })
    req = Request(environ, lambda *args, **kwds: None)
    # Intercept redirection
    req.redirect = lambda *args, **kwds: None
    # Setup user information
    if uname is not None :
        environ['REMOTE_USER'] = req.authname = uname
    
    rd = RequestDispatcher(env)
    chrome = Chrome(env)
    req.callbacks.update({
        'authname': rd.authenticate,
        'chrome': chrome.prepare_request,
        'hdf': getattr(rd, '_get_hdf', None),
        'lc_time': rd._get_lc_time,
        'locale' : getattr(rd, '_get_locale', None),
        'perm': rd._get_perm,
        'session': rd._get_session,
        'tz': rd._get_timezone,
        'form_token': rd._get_form_token
    })
    return req

def setup_environ(**kwargs):
    """ setup basic wsgi environ"""
    environ = {}
    from wsgiref.util import setup_testing_defaults
    setup_testing_defaults(environ)
    environ.update(kwargs)
    return environ

    def testGetWsdl(self):
        """Simple test for serving of WSDL by spyne through pyramid route"""
        application = PyramidApplication(
            Application([self.HelloWorldService],
                        tns='spyne.examples.hello',
                        in_protocol=Soap11(validator='lxml'),
                        out_protocol=Soap11()))

        config = Configurator(settings={'debug_all': True})
        config.add_route('home', '/')
        config.add_view(application, route_name='home')
        wsgi_app = validator(config.make_wsgi_app())

        env = {
            'SCRIPT_NAME': '',
            'REQUEST_METHOD': 'GET',
            'PATH_INFO': '/',
            'QUERY_STRING': 'wsdl',
        }
        setup_testing_defaults(env)

        request = Request(env)
        resp = request.get_response(wsgi_app)
        self.assert_(resp.status.startswith("200 "))
        node = etree.XML(resp.body)  # will throw exception if non well formed

def simple_app(environ, start_response):
    setup_testing_defaults(environ)
    
    if environ['REQUEST_METHOD'] == 'POST':
        leng = environ['CONTENT_LENGTH']
        mpt_file = open("Multipart-form.txt","wb")
        mpt_file.write(environ['wsgi.input'].read(int(leng)))
        mpt_file.close()

    status = '200 OK'
    headers = [('Content-type', 'text/html')]

    start_response(status, headers)
    
    keys = environ.keys()
    keys.sort()
    
    ret = list()
    ret.append("<html><body>")
    ret.append('<a href=".">This page</a>')
    
    ret.append('<form method="POST" action="." enctype="multipart/form-data">')
    ret.append('<input type="file" name="my_file">')
    ret.append('<input type="text" name="age">')
    ret.append('<input type="text" name="age">')
    ret.append('<input type="text" name="age">')
    ret.append('<input type="submit" value="Submit">')
    ret.append('</form>')
    
    ret.extend(["%s: %s<br>" % (key, environ[key])
           for key in keys])
    ret.append("</body></html>")
    return ret

def webapp(environ, start_response):
    """Serve simple pages, based on whether the URL requests
    users, rooms or bookings. For now, just serve the Home page
    """
    setup_testing_defaults(environ)

    #
    # Assume we're going to serve a valid HTML page
    #
    status = '200 OK'
    headers = [('Content-type', 'text/html; charset=utf-8')]
    #
    # Pick up the first segment on the path and pass
    # the rest along.
    #
    # ie if we're looking for /users/1/bookings,
    # param1 will be "users", and the remaining path will
    # be "/1/bookings".
    #
    param1 = shift_path_info(environ)
    if param1 == "":
        data = index_page(environ)
    elif param1 == "users":
        data = users_page(environ)
    elif param1 == "rooms":
        data = rooms_page(environ)
    else:
        status = '404 Not Found'
        data = "Not Found: %s" % param1

    start_response(status, headers)
    return [data.encode("utf-8")]

def simple_app(environ, start_response):
    global counter
    setup_testing_defaults(environ)

    status = '200 OK'
    headers = [('Content-type', 'text/plain; charset=utf-8')]

    start_response(status, headers)

    firstname, lastname = get_random_name()
    joke_str = get_random_joke("plain_first_name", "plain_last_name")
    print joke_str
    #Replace plain_first_name with actual firstname, and plain_last_name with actual lastname

    joke_str_mod = replace_pattern(joke_str, "plain_first_name", "FIRST_NAME")
    joke_str_mod = replace_pattern(joke_str_mod, "plain_last_name", "LAST_NAME")

    ret = [("%s: %s\n" % (key, value)).encode("utf-8")
           for key, value in environ.items()]
    ret = "{0} Hello, cruel world!\n".format(threading.current_thread().ident)
    ret = joke_str_mod + "\n"
    print "Will be sleeping now"

    if counter < 5:
        counter += 1
        sleep(50)
    return ret

 def _makeEnviron(self, kw=None):
     from wsgiref.util import setup_testing_defaults
     environ = {}
     setup_testing_defaults(environ)
     if kw is not None:
         environ.update(kw)
     return environ

def wsgi_app(environ, start_response):
    setup_testing_defaults(environ)
    if environ['REQUEST_METHOD'] == 'OPTIONS':
        # This is to hanle the preflight request for CORS.
        # See https://developer.mozilla.org/en/http_access_control
        response = Response()
        response.status = "200 OK"
    else:
        params = extract_params(environ)
        log('------')
        path = environ['PATH_INFO'].split(environ['HTTP_HOST'])[-1]
        if BASE_PATH: path = path.split(BASE_PATH)[1]
        log(path)
        try:
            if '/pico/' in path:
                path = path.replace('/pico/', '/')
                try:
                    response = handle_api_v1(path, params)
                except APIError:
                    try:
                        response = handle_pico_js(path, params)
                    except APIError:
                        try:
                            response = handle_api_v2(path, params)
                        except APIError:
                            response = not_found_error(path)
            else:           
                try:
                    response = static_file_handler(path)
                except OSError, e:
                    response = not_found_error(path)
        except Exception, e:
            response = generate_exception_report(e, path, params)