def test_restful_ignore_extension(self): env = { 'request_method': 'GET', 'PATH_INFO': '/welcome/default/index/127.0.0.1' } r = Request(env) regex_url_in(r, env) @r.restful(ignore_extension=True) def ignore_rest(): def GET(*args, **vars): return args[0] return locals() self.assertEqual(ignore_rest(), '127.0.0.1')
def test_admin_compile(self): request = Request(env={}) request.application = 'a' request.controller = 'c' request.function = 'f' request.folder = 'applications/admin' # remove any existing test app app_path = os.path.join('applications', test_app2_name) if os.path.exists(app_path): shutil.rmtree(app_path) self.assertTrue(app_create(test_app2_name, request)) self.assertTrue(os.path.exists('applications/%s/controllers/default.py' % test_app2_name)) self.assertIsNone(app_compile(test_app2_name, request)) self.assertTrue(app_cleanup(test_app2_name, request)) self.assertTrue(app_uninstall(test_app2_name, request))
def test_restful_simple(self): env = { 'request_method': 'GET', 'PATH_INFO': '/welcome/default/index/1.pdf' } r = Request(env) regex_url_in(r, env) @r.restful() def simple_rest(): def GET(*args, **vars): return args[0] return locals() self.assertEqual(simple_rest(), '1')
def setUp(self): global request, session, auth request = Request(globals()) # Use a clean Request object request.application = 'runestone' session = Session() auth = Auth(db, hmac_key=Auth.get_or_create_key()) # bring in the ajax controllers exec( compile( open("applications/runestone/controllers/ajax.py").read(), "applications/runestone/controllers/ajax.py", 'exec'), globals()) # Create a default user and course. self.course_name_1 = 'test_course_1' self.course_id_1 = self.createCourse(self.course_name_1) self.user_name_1 = 'test_user_1' self.user_id_1 = self.createUser(self.user_name_1, self.course_id_1)
def setUp(self): request = Request(env={}) request.application = 'a' request.controller = 'c' request.function = 'f' request.folder = 'applications/admin' response = Response() session = Session() session.connect(request, response) from gluon.globals import current current.request = request current.response = response current.session = session self.current = current rconn = RConn(host='localhost') self.db = RedisSession(redis_conn=rconn, session_expiry=False) self.tname = 'testtablename' return current
def env( a, import_models=False, c=None, f=None, dir='', ): """ Return web2py execution environment for application (a), controller (c), function (f). If import_models is True the exec all application models into the evironment. """ request = Request() response = Response() session = Session() request.application = a # Populate the dummy environment with sensible defaults. if not dir: request.folder = os.path.join('applications', a) else: request.folder = dir request.controller = c or 'default' request.function = f or 'index' response.view = '%s/%s.html' % (request.controller, request.function) request.env.path_info = '/%s/%s/%s' % (a, c, f) request.env.http_host = '127.0.0.1:8000' request.env.remote_addr = '127.0.0.1' # Monkey patch so credentials checks pass. def check_credentials(request, other_application='admin'): return True gluon.fileutils.check_credentials = check_credentials environment = build_environment(request, response, session) if import_models: run_models_in(environment) return environment
def setUp(self): # Load the to-be-tested file execfile("applications/vidjil/controllers/admin.py", globals()) # Set up default session/request/auth/... global response, session, request, auth session = Session() request = Request([]) auth = VidjilAuth(globals(), db) auth.login_bare("*****@*****.**", "1234") # rewrite info / error functions # for some reasons we lost them between the testRunner and the testCase but we need them to avoid error so ... def f(a, **kwargs): pass log.info = f log.error = f log.debug = f
def exec_environment( pyfile='', request=None, response=None, session=None, ): """ .. function:: gluon.shell.exec_environment([pyfile=''[, request=Request() [, response=Response[, session=Session()]]]]) Environment builder and module loader. Builds a web2py environment and optionally executes a Python file into the environment. A Storage dictionary containing the resulting environment is returned. The working directory must be web2py root -- this is the web2py default. """ if request is None: request = Request({}) if response is None: response = Response() if session is None: session = Session() if request.folder is None: mo = re.match(r'(|.*/)applications/(?P<appname>[^/]+)', pyfile) if mo: appname = mo.group('appname') request.folder = os.path.join('applications', appname) else: request.folder = '' env = build_environment(request, response, session, store_current=False) if pyfile: pycfile = pyfile + 'c' if os.path.isfile(pycfile): exec read_pyc(pycfile) in env else: execfile(pyfile, env) return Storage(env)
def setUp(self): from gluon.globals import Request, Response, Session, current from gluon.html import A, DIV, FORM, MENU, TABLE, TR, INPUT, URL, XML from gluon.html import ASSIGNJS from gluon.validators import IS_NOT_EMPTY from gluon.compileapp import LOAD from gluon.http import HTTP, redirect from gluon.tools import Auth from gluon.sql import SQLDB from gluon.sqlhtml import SQLTABLE, SQLFORM self.original_check_credentials = fileutils.check_credentials fileutils.check_credentials = fake_check_credentials request = Request(env={}) request.application = 'welcome' request.controller = 'appadmin' request.function = self._testMethodName.split('_')[1] request.folder = 'applications/welcome' request.env.http_host = '127.0.0.1:8000' request.env.remote_addr = '127.0.0.1' response = Response() session = Session() T = translator('', 'en') session.connect(request, response) current.request = request current.response = response current.session = session current.T = T db = DAL(DEFAULT_URI, check_reserved=['all']) auth = Auth(db) auth.define_tables(username=True, signature=False) db.define_table('t0', Field('tt'), auth.signature) # Create a user db.auth_user.insert(first_name='Bart', last_name='Simpson', username='******', email='*****@*****.**', password='******', registration_key=None, registration_id=None) self.env = locals()
def exec_environment( pyfile='', request=None, response=None, session=None, ): """Environment builder and module loader. Builds a web2py environment and optionally executes a Python file into the environment. A Storage dictionary containing the resulting environment is returned. The working directory must be web2py root -- this is the web2py default. """ if request is None: request = Request({}) if response is None: response = Response() if session is None: session = Session() if request.folder is None: mo = re.match(REGEX_APP_PATH, pyfile) if mo: a = mo.group('a') request.folder = os.path.abspath(os.path.join('applications', a)) else: request.folder = '' env = build_environment(request, response, session, store_current=False) if pyfile: pycfile = pyfile + 'c' if os.path.isfile(pycfile): exec(read_pyc(pycfile), env) else: execfile(pyfile, env) return Storage(env)
def setUp(self): # Load the to-be-tested file execfile("applications/vidjil/controllers/config.py", globals()) execfile("applications/vidjil/modules/defs.py", globals()) # set up default session/request/auth/... global response, session, request, auth session = Session() request = Request({}) auth = VidjilAuth(globals(), db) auth.login_bare("*****@*****.**", "1234") auth.add_permission(group_id, 'admin', db.patient, 0) auth.add_permission(group_id, 'admin', db.config, 0) auth.add_permission(group_id, 'read', db.config, 0) # rewrite info / error functions # for some reasons we lost them between the testRunner and the testCase but we need them to avoid error so ... def f(a, **kwargs): pass log.info = f log.error = f log.debug = f
def wsgibase(environ, responder): """ The gluon wsgi application. The first function called when a page is requested (static or dynamic). It can be called by paste.httpserver or by apache mod_wsgi (or any WSGI-compatible server). - fills request with info - the environment variables, replacing '.' with '_' - adds web2py path and version info - compensates for fcgi missing path_info and query_string - validates the path in url The url path must be either: 1. for static pages: - /<application>/static/<file> 2. for dynamic pages: - /<application>[/<controller>[/<function>[/<sub>]]][.<extension>] The naming conventions are: - application, controller, function and extension may only contain `[a-zA-Z0-9_]` - file and sub may also contain '-', '=', '.' and '/' """ eget = environ.get current.__dict__.clear() request = Request(environ) response = Response() session = Session() env = request.env #env.web2py_path = global_settings.applications_parent env.web2py_version = web2py_version #env.update(global_settings) static_file = False try: try: try: # ################################################## # handle fcgi missing path_info and query_string # select rewrite parameters # rewrite incoming URL # parse rewritten header variables # parse rewritten URL # serve file if static # ################################################## fixup_missing_path_info(environ) (static_file, version, environ) = url_in(request, environ) response.status = env.web2py_status_code or response.status if static_file: if eget('QUERY_STRING', '').startswith('attachment'): response.headers['Content-Disposition'] \ = 'attachment' if version: response.headers['Cache-Control'] = 'max-age=315360000' response.headers[ 'Expires'] = 'Thu, 31 Dec 2037 23:59:59 GMT' response.stream(static_file, request=request) # ################################################## # fill in request items # ################################################## app = request.application # must go after url_in! if not global_settings.local_hosts: local_hosts = set(['127.0.0.1', '::ffff:127.0.0.1', '::1']) if not global_settings.web2py_runtime_gae: try: fqdn = socket.getfqdn() local_hosts.add(socket.gethostname()) local_hosts.add(fqdn) local_hosts.update([ addrinfo[4][0] for addrinfo in getipaddrinfo(fqdn) ]) if env.server_name: local_hosts.add(env.server_name) local_hosts.update([ addrinfo[4][0] for addrinfo in getipaddrinfo(env.server_name) ]) except (socket.gaierror, TypeError): pass global_settings.local_hosts = list(local_hosts) else: local_hosts = global_settings.local_hosts client = get_client(env) x_req_with = str(env.http_x_requested_with).lower() request.update( client = client, folder = abspath('applications', app) + os.sep, ajax = x_req_with == 'xmlhttprequest', cid = env.http_web2py_component_element, is_local = env.remote_addr in local_hosts, is_https = env.wsgi_url_scheme in HTTPS_SCHEMES or \ request.env.http_x_forwarded_proto in HTTPS_SCHEMES \ or env.https == 'on' ) request.compute_uuid() # requires client request.url = environ['PATH_INFO'] # ################################################## # access the requested application # ################################################## disabled = pjoin(request.folder, 'DISABLED') if not exists(request.folder): if app == rwthread.routes.default_application \ and app != 'welcome': redirect(URL('welcome', 'default', 'index')) elif rwthread.routes.error_handler: _handler = rwthread.routes.error_handler redirect( URL(_handler['application'], _handler['controller'], _handler['function'], args=app)) else: raise HTTP(404, rwthread.routes.error_message % 'invalid request', web2py_error='invalid application') elif not request.is_local and exists(disabled): raise HTTP( 503, "<html><body><h1>Temporarily down for maintenance</h1></body></html>" ) # ################################################## # build missing folders # ################################################## create_missing_app_folders(request) # ################################################## # get the GET and POST data # ################################################## #parse_get_post_vars(request, environ) # ################################################## # expose wsgi hooks for convenience # ################################################## request.wsgi = LazyWSGI(environ, request, response) # ################################################## # load cookies # ################################################## if env.http_cookie: try: request.cookies.load(env.http_cookie) except Cookie.CookieError, e: pass # invalid cookies # ################################################## # try load session or create new session file # ################################################## if not env.web2py_disable_session: session.connect(request, response) # ################################################## # run controller # ################################################## if global_settings.debugging and app != "admin": import gluon.debug # activate the debugger gluon.debug.dbg.do_debug(mainpyfile=request.folder) serve_controller(request, response, session) except HTTP, http_response: if static_file: return http_response.to(responder, env=env) if request.body: request.body.close() if hasattr(current, 'request'): # ################################################## # on success, try store session in database # ################################################## session._try_store_in_db(request, response) # ################################################## # on success, commit database # ################################################## if response.do_not_commit is True: BaseAdapter.close_all_instances(None) elif response.custom_commit: BaseAdapter.close_all_instances(response.custom_commit) else: BaseAdapter.close_all_instances('commit') # ################################################## # if session not in db try store session on filesystem # this must be done after trying to commit database! # ################################################## session._try_store_in_cookie_or_file(request, response) # Set header so client can distinguish component requests. if request.cid: http_response.headers.setdefault( 'web2py-component-content', 'replace') if request.ajax: if response.flash: http_response.headers['web2py-component-flash'] = \ urllib2.quote(xmlescape(response.flash)\ .replace('\n','')) if response.js: http_response.headers['web2py-component-command'] = \ urllib2.quote(response.js.replace('\n','')) # ################################################## # store cookies in headers # ################################################## session._fixup_before_save() http_response.cookies2headers(response.cookies) ticket = None except RestrictedError, e: if request.body: request.body.close() # ################################################## # on application error, rollback database # ################################################## # log tickets before rollback if not in DB if not request.tickets_db: ticket = e.log(request) or 'unknown' # rollback if response._custom_rollback: response._custom_rollback() else: BaseAdapter.close_all_instances('rollback') # if tickets in db, reconnect and store it in db if request.tickets_db: ticket = e.log(request) or 'unknown' http_response = \ HTTP(500, rwthread.routes.error_message_ticket % dict(ticket=ticket), web2py_error='ticket %s' % ticket)
def env( a, import_models=False, c=None, f=None, dir='', extra_request={}, ): """ Returns web2py execution environment for application (a), controller (c), function (f). If import_models is True the exec all application models into the environment. extra_request allows you to pass along any extra variables to the request object before your models get executed. This was mainly done to support web2py_utils.test_runner, however you can use it with any wrapper scripts that need access to the web2py environment. """ request = Request({}) response = Response() session = Session() request.application = a # Populate the dummy environment with sensible defaults. if not dir: request.folder = os.path.join('applications', a) else: request.folder = dir request.controller = c or 'default' request.function = f or 'index' response.view = '%s/%s.html' % (request.controller, request.function) if global_settings.cmd_options: ip = global_settings.cmd_options.ip port = global_settings.cmd_options.port request.is_shell = global_settings.cmd_options.shell is not None request.is_scheduler = global_settings.cmd_options.scheduler is not None else: ip, port = '127.0.0.1', '8000' request.env.http_host = '%s:%s' % (ip, port) request.env.remote_addr = '127.0.0.1' request.env.web2py_runtime_gae = global_settings.web2py_runtime_gae for k, v in extra_request.items(): request[k] = v path_info = '/%s/%s/%s' % (a, c, f) if request.args: path_info = '%s/%s' % (path_info, '/'.join(request.args)) if request.vars: vars = [ '%s=%s' % (k, v) if v else '%s' % k for (k, v) in request.vars.iteritems() ] path_info = '%s?%s' % (path_info, '&'.join(vars)) request.env.path_info = path_info # Monkey patch so credentials checks pass. def check_credentials(request, other_application='admin'): return True fileutils.check_credentials = check_credentials environment = build_environment(request, response, session) if import_models: try: run_models_in(environment) except RestrictedError, e: sys.stderr.write(e.traceback + '\n') sys.exit(1)
def setUp(self): global request, session, auth request = Request(globals()) # Use a clean Request object session = Session() auth = Auth(db, hmac_key=Auth.get_or_create_key()) execfile("applications/runestone/controllers/admin.py", globals())
def setUp(self): global request request = Request(globals()) # Use a clean Request object
def setUp(self): global request request = Request(globals()) # Use a clean Request object execfile("applications/runestone/controllers/assignments.py", globals())
def env(app, dir='', nomodel=False): import gluon.html as html import gluon.validators as validators from gluon.http import HTTP, redirect from gluon.languages import translator from gluon.cache import Cache from gluon.globals import Request, Response, Session from gluon.sqlhtml import SQLFORM, SQLTABLE from gluon.dal import BaseAdapter, SQLDB, SQLField, DAL, Field from gluon.compileapp import local_import_aux, LoadFactory request = Request() response = Response() session = Session() if not dir: request.folder = os.path.join('applications', app) else: request.folder = dir environment = {} # for key in html.__all__: environment[key]=eval('html.%s' % key) # for key in validators.__all__: environment[key]=eval('validators.%s' % key) for key in html.__all__: environment[key] = getattr(html, key) for key in validators.__all__: environment[key] = getattr(validators, key) global __builtins__ environment['__builtins__'] = __builtins__ environment['T'] = translator(request) # environment['HTTP']=HTTP # environment['redirect']=redirect # environment['request']=request # environment['response']=response # environment['session']=session # environment['cache']=Cache(request) # environment['SQLDB']=SQLDB # SQLDB._set_thread_folder(os.path.join(request.folder,'databases')) # environment['SQLField']=SQLField # environment['SQLFORM']=SQLFORM # environment['SQLTABLE']=SQLTABLE # # if not nomodel: # model_path = os.path.join(request.folder,'models', '*.py') # from glob import glob # for f in glob(model_path): # fname, ext = os.path.splitext(f) # execfile(f, environment) ## print 'Imported "%s" model file' % fname environment['HTTP'] = HTTP environment['redirect'] = redirect environment['request'] = request environment['response'] = response environment['session'] = session environment['DAL'] = DAL environment['Field'] = Field environment['SQLDB'] = SQLDB # for backward compatibility environment['SQLField'] = SQLField # for backward compatibility environment['SQLFORM'] = SQLFORM environment['SQLTABLE'] = SQLTABLE environment['LOAD'] = LoadFactory(environment) environment['local_import'] = \ lambda name, reload=False, app=request.application:\ local_import_aux(name,reload,app) BaseAdapter.set_folder(os.path.join(request.folder, 'databases')) response._view_environment = copy.copy(environment) return environment
# web2py path, its assumed you are setup correctly that is web2py/applications/<application>/tests web2py_path = os.path.abspath(os.path.join(os.getcwd(), '..', '..', '..')) sys.path.append(web2py_path) # setup the application controllers path sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '..', 'controllers'))) # setup a very basic environment from gluon import current from gluon.globals import Request, Session, Response from gluon.storage import Storage current.T = lambda t: t current.request = Request(dict()) current.session = Session() current.response = Response() # you will need to update this with your application name current.request.application = 'web2py_unit_test' # create our test database from app import Application application = Application( config=Storage(db=Storage(uri='sqlite://test_storage.db', migrate=True, migrate_enabled=True, folder='databases'), mail=Storage(server='logging', sender='*****@*****.**'), upload_folder=os.path.join(os.getcwd(), 'uploads')))
def setUp(self): request = Request("")
def setUp(self): self.request = Request([]) # Use a clean Request object
# Copyright 2011 - Thomas Bellembois [email protected] # Cecill licence, see LICENSE # $Id: chimitheque_ide_autocomplete.py 194 2015-02-23 16:27:16Z tbellemb $ # -*- coding: utf-8 -*- if False: # # never imported - just for IDE autocompletion # from gluon import DAL db = DAL() from gluon import settings from gluon.cache import Cache from gluon.dal import Field from gluon.globals import Request request = Request() from gluon.globals import Response response = Response() from gluon.globals import Session session = Session() from gluon.html import * from gluon.http import HTTP from gluon.http import redirect from gluon.languages import translator T = translator(request) from gluon.sqlhtml import SQLFORM from gluon.tools import Auth auth = Auth() from gluon.tools import Crud, Mail from gluon.validators import * import sys mail = Mail()
def setUp(self): env = {} request = Request(env) clean_db() # making sure we always start off with a clean database during setup self.person_id, self.role_id, self.role_membership_id = setup_test_data()