def setUp(self):
self.request = Request(env={})
self.request.application = 'a'
self.request.controller = 'c'
self.request.function = 'f'
self.request.folder = 'applications/admin'
self.response = Response()
self.session = Session()
T = translator('', 'en')
self.session.connect(self.request, self.response)
from gluon.globals import current
self.current = current
self.current.request = self.request
self.current.response = self.response
self.current.session = self.session
self.current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=['all'])
self.auth = AuthAPI(self.db)
self.auth.define_tables(username=True, signature=False)
# Create a user
self.auth.table_user().validate_and_insert(first_name='Bart',
last_name='Simpson',
username='******',
email='*****@*****.**',
password='******',
registration_key='',
registration_id='')
self.db.commit()
def setUp(self):
request = Request(env={})
request.application = 'a'
request.controller = 'c'
request.function = 'f'
request.folder = 'applications/admin'
response = Response()
session = Session()
T = translator('', 'en')
session.connect(request, response)
from gluon.globals import current
current.request = request
current.response = response
current.session = session
current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=['all'])
self.auth = Auth(self.db)
self.auth.define_tables(username=True, signature=False)
self.db.define_table('t0', Field('tt'), self.auth.signature)
self.auth.enable_record_versioning(self.db)
# Create a user
self.db.auth_user.insert(first_name='Bart',
last_name='Simpson',
username='******',
email='*****@*****.**',
password='******',
registration_key=None,
registration_id=None)
self.db.commit()
def setUp(self):
request = Request(env={})
request.application = 'a'
request.controller = 'c'
request.function = 'f'
request.folder = 'applications/admin'
response = Response()
session = Session()
T = translator('', 'en')
session.connect(request, response)
from gluon.globals import current
current.request = request
current.response = response
current.session = session
current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=['all'])
self.auth = Auth(self.db)
self.auth.define_tables(username=True, signature=False)
self.db.define_table('t0', Field('tt'), self.auth.signature)
self.auth.enable_record_versioning(self.db)
# Create a user
self.db.auth_user.insert(first_name='Bart',
last_name='Simpson',
username='******',
email='*****@*****.**',
password='******',
registration_key=None,
registration_id=None)
self.db.commit()
def setUp(self):
request = Request(env={})
request.application = "a"
request.controller = "c"
request.function = "f"
request.folder = "applications/admin"
response = Response()
session = Session()
T = translator("", "en")
session.connect(request, response)
from gluon.globals import current
current.request = request
current.response = response
current.session = session
current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=["all"])
self.auth = Auth(self.db)
self.auth.define_tables(username=True, signature=False)
self.db.define_table("t0", Field("tt"), self.auth.signature)
self.auth.enable_record_versioning(self.db)
# Create a user
self.db.auth_user.insert(
first_name="Bart",
last_name="Simpson",
username="******",
email="*****@*****.**",
password="******",
registration_key=None,
registration_id=None,
)
self.db.commit()
def testRun(self):
# setup
request = Request(env={})
request.application = 'a'
request.controller = 'c'
request.function = 'f'
request.folder = 'applications/admin'
response = Response()
session = Session()
T = translator('', 'en')
session.connect(request, response)
from gluon.globals import current
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)
self.assertTrue('auth_user' in db)
self.assertTrue('auth_group' in db)
self.assertTrue('auth_membership' in db)
self.assertTrue('auth_permission' in db)
self.assertTrue('auth_event' in db)
db.define_table('t0', Field('tt'), auth.signature)
auth.enable_record_versioning(db)
self.assertTrue('t0_archive' in db)
for f in [
'login', 'register', 'retrieve_password', 'retrieve_username'
]:
html_form = getattr(auth, f)().xml()
self.assertTrue('name="_formkey"' in html_form)
for f in [
'logout', 'verify_email', 'reset_password', 'change_password',
'profile', 'groups'
]:
self.assertRaisesRegexp(HTTP, "303*", getattr(auth, f))
self.assertRaisesRegexp(HTTP, "401*", auth.impersonate)
try:
for t in [
't0_archive', 't0', 'auth_cas', 'auth_event',
'auth_membership', 'auth_permission', 'auth_group',
'auth_user'
]:
db[t].drop()
except SyntaxError as e:
# GAE doesn't support drop
pass
return
def setup_clean_session():
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
return current
def setup_clean_session():
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
return current
def setUp(self):
self.request = Request(env={})
self.request.application = 'a'
self.request.controller = 'c'
self.request.function = 'f'
self.request.folder = 'applications/admin'
self.response = Response()
self.session = Session()
T = translator('', 'en')
self.session.connect(self.request, self.response)
from gluon.globals import current
self.current = current
self.current.request = self.request
self.current.response = self.response
self.current.session = self.session
self.current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=['all'])
self.auth = AuthAPI(self.db)
self.auth.define_tables(username=True, signature=False)
# Create a user
self.auth.table_user().validate_and_insert(first_name='Bart',
last_name='Simpson',
username='******',
email='*****@*****.**',
password='******',
registration_key='',
registration_id=''
)
self.db.commit()
def initVars(): global current, request, response, session, cache, T current.request = request = Request() current.response = response = Response() current.session = session = Session() current.cache = cache = Cache(request) current.T = T = m__T__
def setUp(self):
# Load the to-be-tested file
execfile("applications/vidjil/controllers/patient.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
# for defs
current.db = db
current.auth = auth
auth.add_permission(group_id, 'admin', db.patient, 0)
auth.add_permission(group_id, 'read', db.patient, 0)
auth.add_permission(group_id, 'create', db.patient, 0)
def build_web2py_environment(self):
"build a namespace suitable for editor autocompletion and calltips"
# warning: this can alter current global variable, use with care!
try:
from gluon.globals import Request, Response, Session
from gluon.compileapp import build_environment, DAL
request = Request()
response = Response()
session = Session()
# fake request values
request.folder = ""
request.application = "welcome"
request.controller = "default"
request.function = "index"
ns = build_environment(
request,
response,
session,
)
# fake common model objects
db = ns['db'] = DAL("sqlite:memory")
from gluon.tools import Auth, Crud, Service
ns['auth'] = Auth(db)
ns['crud'] = Crud(db)
ns['service'] = Service()
except Exception, e:
print e
ns = {}
def 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.
"""
from gluon.compileapp import read_pyc
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)
if pyfile:
pycfile = pyfile + 'c'
if os.path.isfile(pycfile):
exec read_pyc(pycfile) in env
else:
execfile(pyfile, env)
return Storage(env)
def testRun(self):
# setup
request = Request(env={})
request.application = 'a'
request.controller = 'c'
request.function = 'f'
request.folder = 'applications/admin'
response = Response()
session = Session()
T = translator('', 'en')
session.connect(request, response)
from gluon.globals import current
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)
self.assertTrue('auth_user' in db)
self.assertTrue('auth_group' in db)
self.assertTrue('auth_membership' in db)
self.assertTrue('auth_permission' in db)
self.assertTrue('auth_event' in db)
db.define_table('t0', Field('tt'), auth.signature)
auth.enable_record_versioning(db)
self.assertTrue('t0_archive' in db)
for f in ['login', 'register', 'retrieve_password',
'retrieve_username']:
html_form = getattr(auth, f)().xml()
self.assertTrue('name="_formkey"' in html_form)
for f in ['logout', 'verify_email', 'reset_password',
'change_password', 'profile', 'groups']:
self.assertRaisesRegexp(HTTP, "303*", getattr(auth, f))
self.assertRaisesRegexp(HTTP, "401*", auth.impersonate)
try:
for t in ['t0_archive', 't0', 'auth_cas', 'auth_event',
'auth_membership', 'auth_permission', 'auth_group',
'auth_user']:
db[t].drop()
except SyntaxError as e:
# GAE doesn't support drop
pass
return
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 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())
exec(
compile(
open("applications/runestone/controllers/dashboard.py").read(),
"applications/runestone/controllers/dashboard.py", 'exec'),
globals())
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 = TranslatorFactory('', '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 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 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())
# bring in the ajax controllers
execfile("applications/runestone/controllers/ajax.py", 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 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 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)
"""
This file is part of the Nervatura Framework
http://www.nervatura.com
Copyright © 2011-2015, Csaba Kappel
License: LGPLv3
http://www.nervatura.com/nerva2py/default/licenses
"""
if 0:
global response
response = globals.Response()
global request
request = globals.Request()
from gluon.globals import Session
global session
session = Session()
from gluon.sql import DAL
global db
db = DAL()
import gluon.languages.translator as T
from db import DEMO_MODE
from gluon.http import redirect
from gluon.sqlhtml import DIV, SPAN, A, INPUT, FORM
from gluon.html import BR, HR, SELECT, OPTION, P, IMG, TABLE, TR, TD
from gluon.validators import IS_NOT_EMPTY
from gluon.html import URL
from gluon.storage import Storage
import os
from gluon.sqlhtml import SQLFORM
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
def wsgibase(environ, responder):
"""
this is 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.
- 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>]
- (sub may go several levels deep, currently 3 levels are supported:
sub1/sub2/sub3)
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)
# -*- coding: utf-8 -*-
"""
This file is part of the Nervatura Framework
http://www.nervatura.com
Copyright © 2011-2015, Csaba Kappel
License: LGPLv3
http://www.nervatura.com/nerva2py/default/licenses
"""
if 0:
from gluon.globals import Session
global session
session = Session()
global request
request = globals.Request()
import gluon.languages.translator as T
from gluon.sql import DAL
global db
db = DAL()
global response
response = globals.Response()
import pyamf
from pyamf.flex import ArrayCollection
from gluon.tools import Service
from nerva2py.nervastore import NervaStore
from nerva2py.tools import NervaTools
from nerva2py.npi import Npi
import nerva2py.models
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)
class TestAuthAPI(unittest.TestCase):
def setUp(self):
self.request = Request(env={})
self.request.application = 'a'
self.request.controller = 'c'
self.request.function = 'f'
self.request.folder = 'applications/admin'
self.response = Response()
self.session = Session()
T = translator('', 'en')
self.session.connect(self.request, self.response)
from gluon.globals import current
self.current = current
self.current.request = self.request
self.current.response = self.response
self.current.session = self.session
self.current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=['all'])
self.auth = AuthAPI(self.db)
self.auth.define_tables(username=True, signature=False)
# Create a user
self.auth.table_user().validate_and_insert(first_name='Bart',
last_name='Simpson',
username='******',
email='*****@*****.**',
password='******',
registration_key='',
registration_id=''
)
self.db.commit()
def test_login(self):
result = self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.auth.logout()
self.assertFalse(self.auth.is_logged_in())
self.auth.settings.username_case_sensitive = False
result = self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
def test_logout(self):
self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
result = self.auth.logout()
self.assertTrue(not self.auth.is_logged_in())
self.assertTrue(result['user'] is None)
def test_register(self):
self.auth.settings.login_after_registration = True
result = self.auth.register(**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.assertTrue(self.auth.is_logged_in())
with self.assertRaises(AssertionError): # Can't register if you're logged in
result = self.auth.register(**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.auth.logout()
self.auth.settings.login_after_registration = False
result = self.auth.register(**{
'username': '******',
'first_name': 'Barney',
'last_name': 'Gumble',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.assertFalse(self.auth.is_logged_in())
self.auth.settings.login_userfield = 'email'
result = self.auth.register(**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(result['errors']['email'] == self.auth.messages.email_taken)
self.assertTrue(result['user'] is None)
self.auth.settings.registration_requires_verification = True
result = self.auth.register(**{
'username': '******',
'first_name': 'Homer',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue('key' in result['user'])
def test_profile(self):
with self.assertRaises(AssertionError):
# We are not logged in
self.auth.profile()
self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
result = self.auth.profile(email='*****@*****.**')
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.assertTrue(self.auth.table_user()[result['user']['id']].email == '*****@*****.**')
def test_change_password(self):
with self.assertRaises(AssertionError):
# We are not logged in
self.auth.change_password()
self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
self.auth.change_password(old_password='******', new_password='******', new_password2='1234')
self.auth.logout()
self.assertTrue(not self.auth.is_logged_in())
self.auth.login(username='******', password='******')
self.assertTrue(self.auth.is_logged_in())
result = self.auth.change_password(old_password='******', new_password='******', new_password2='5678')
self.assertTrue('new_password2' in result['errors'])
result = self.auth.change_password(old_password='******', new_password='******', new_password2='1234')
self.assertTrue('old_password' in result['errors'])
def test_verify_key(self):
self.auth.settings.registration_requires_verification = True
result = self.auth.register(**{
'username': '******',
'first_name': 'Homer',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue('key' in result['user'])
homer_id = result['user']['id']
homers_key = result['user']['key']
result = self.auth.verify_key(key=None)
self.assertTrue(result['errors'] is not None)
result = self.auth.verify_key(key='12345')
self.assertTrue(result['errors'] is not None)
result = self.auth.verify_key(key=homers_key)
self.assertTrue(result['errors'] is None)
self.assertEqual(self.auth.table_user()[homer_id].registration_key, '')
self.auth.settings.registration_requires_approval = True
result = self.auth.register(**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
lisa_id = result['user']['id']
result = self.auth.verify_key(key=result['user']['key'])
self.assertEqual(self.auth.table_user()[lisa_id].registration_key, 'pending')
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())
# -*- coding: utf-8 -*- """ This file is part of the Nervatura Framework http://www.nervatura.com Copyright © 2011-2015, Csaba Kappel License: LGPLv3 http://www.nervatura.com/nerva2py/default/licenses """ if 0: global request; request = globals.Request() from gluon.globals import Session global session; session = Session() global response; response = globals.Response() import gluon.languages.translator as T from gluon.sql import DAL global db; db = DAL() from gluon.html import URL from nerva2py.nervastore import NervaStore from gluon.html import TABLE, TR, TD from gluon.sqlhtml import SPAN, A #postgres://username:password@localhost/database #mysql://username:password@localhost/database #sqlite://database.db conStr="sqlite://demo.db" ns = NervaStore(request, session, T, None) ns.engine = "sqlite"
# -*- coding: utf-8 -*- """ This file is part of the Nervatura Framework http://www.nervatura.com Copyright © 2011-2015, Csaba Kappel License: LGPLv3 http://www.nervatura.com/nerva2py/default/licenses """ if 0: global response; response = globals.Response() global request; request = globals.Request() from gluon.globals import Session global session; session = Session() from gluon.sql import DAL global db; db = DAL() import gluon.languages.translator as T from db import DEMO_MODE from gluon.http import redirect from gluon.sqlhtml import DIV, SPAN, A, INPUT, FORM from gluon.html import BR, HR, SELECT, OPTION, P, IMG, TABLE, TR, TD from gluon.validators import IS_NOT_EMPTY from gluon.html import URL from gluon.storage import Storage import os from gluon.sqlhtml import SQLFORM from gluon.validators import IS_IN_DB, IS_IN_SET, IS_EMPTY_OR from gluon.html import TBODY, THEAD, TH, TEXTAREA, CODE
# 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 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)
class TestAuthAPI(unittest.TestCase):
def setUp(self):
self.request = Request(env={})
self.request.application = 'a'
self.request.controller = 'c'
self.request.function = 'f'
self.request.folder = 'applications/admin'
self.response = Response()
self.session = Session()
T = translator('', 'en')
self.session.connect(self.request, self.response)
from gluon.globals import current
self.current = current
self.current.request = self.request
self.current.response = self.response
self.current.session = self.session
self.current.T = T
self.db = DAL(DEFAULT_URI, check_reserved=['all'])
self.auth = AuthAPI(self.db)
self.auth.define_tables(username=True, signature=False)
# Create a user
self.auth.table_user().validate_and_insert(first_name='Bart',
last_name='Simpson',
username='******',
email='*****@*****.**',
password='******',
registration_key='',
registration_id='')
self.db.commit()
def test_login(self):
result = self.auth.login(**{
'username': '******',
'password': '******'
})
self.assertTrue(self.auth.is_logged_in())
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.auth.logout()
self.assertFalse(self.auth.is_logged_in())
self.auth.settings.username_case_sensitive = False
result = self.auth.login(**{
'username': '******',
'password': '******'
})
self.assertTrue(self.auth.is_logged_in())
def test_logout(self):
self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
result = self.auth.logout()
self.assertTrue(not self.auth.is_logged_in())
self.assertTrue(result['user'] is None)
def test_register(self):
self.auth.settings.login_after_registration = True
result = self.auth.register(
**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.assertTrue(self.auth.is_logged_in())
with self.assertRaises(
AssertionError): # Can't register if you're logged in
result = self.auth.register(
**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.auth.logout()
self.auth.settings.login_after_registration = False
result = self.auth.register(
**{
'username': '******',
'first_name': 'Barney',
'last_name': 'Gumble',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.assertFalse(self.auth.is_logged_in())
self.auth.settings.login_userfield = 'email'
result = self.auth.register(
**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(
result['errors']['email'] == self.auth.messages.email_taken)
self.assertTrue(result['user'] is None)
self.auth.settings.registration_requires_verification = True
result = self.auth.register(
**{
'username': '******',
'first_name': 'Homer',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue('key' in result['user'])
def test_profile(self):
with self.assertRaises(AssertionError):
# We are not logged in
self.auth.profile()
self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
result = self.auth.profile(email='*****@*****.**')
self.assertTrue(result['user']['email'] == '*****@*****.**')
self.assertTrue(self.auth.table_user()[result['user']['id']].email ==
'*****@*****.**')
def test_change_password(self):
with self.assertRaises(AssertionError):
# We are not logged in
self.auth.change_password()
self.auth.login(**{'username': '******', 'password': '******'})
self.assertTrue(self.auth.is_logged_in())
self.auth.change_password(old_password='******',
new_password='******',
new_password2='1234')
self.auth.logout()
self.assertTrue(not self.auth.is_logged_in())
self.auth.login(username='******', password='******')
self.assertTrue(self.auth.is_logged_in())
result = self.auth.change_password(old_password='******',
new_password='******',
new_password2='5678')
self.assertTrue('new_password2' in result['errors'])
result = self.auth.change_password(old_password='******',
new_password='******',
new_password2='1234')
self.assertTrue('old_password' in result['errors'])
# Test the default 4 min_length is enforced on change password
result = self.auth.change_password(old_password='******',
new_password='******',
new_password2='123')
self.assertTrue('new_password' in result['errors'])
def test_verify_key(self):
self.auth.settings.registration_requires_verification = True
result = self.auth.register(
**{
'username': '******',
'first_name': 'Homer',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue('key' in result['user'])
homer_id = result['user']['id']
homers_key = result['user']['key']
result = self.auth.verify_key(key=None)
self.assertTrue(result['errors'] is not None)
result = self.auth.verify_key(key='12345')
self.assertTrue(result['errors'] is not None)
result = self.auth.verify_key(key=homers_key)
self.assertTrue(result['errors'] is None)
self.assertEqual(self.auth.table_user()[homer_id].registration_key, '')
self.auth.settings.registration_requires_approval = True
result = self.auth.register(
**{
'username': '******',
'first_name': 'Lisa',
'last_name': 'Simpson',
'email': '*****@*****.**',
'password': '******'
})
lisa_id = result['user']['id']
result = self.auth.verify_key(key=result['user']['key'])
self.assertEqual(self.auth.table_user()[lisa_id].registration_key,
'pending')
