def _makeRequest(self):
class Request(object):
def route_path(self, route_name, *elements, **kw):
self.route_name = route_name
self.elements = elements
self.kw = kw
return 'route path'
return Request()
def test_has_key(self):
environ = {
'PATH_INFO': '/',
'QUERY_STRING':
'lastName=Doe;country:list=Japan;country:list=Hungary',
}
request = Request(environ)
zrequest = IBrowserRequest(request)
assert_that(zrequest.has_key('lastName'), is_(True))
def test_valid(self):
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
tween = config.junk_encoding_tween_factory(handler, pretend.stub())
request = Request({"QUERY_STRING": ":action=browse", "PATH_INFO": "/pypi"})
resp = tween(request)
assert resp is response
def test__make_response_with_real_request(self):
# functional
from pyramid.request import Request
request = Request({})
request.registry = self.config.registry
request.response.status = '406 You Lose'
helper = self._makeOne('loo.foo')
response = helper._make_response('abc', request)
self.assertEqual(response.status, '406 You Lose')
self.assertEqual(response.body, 'abc')
def test__make_response_with_real_request(self):
# functional
from pyramid.request import Request
request = Request({})
attrs = {'response_status': '406 You Lose'}
request.__dict__.update(attrs)
helper = self._makeOne('loo.foo')
response = helper._make_response('abc', request)
self.assertEqual(response.status, '406 You Lose')
self.assertEqual(response.body, 'abc')
def request_factory(environ):
request = Request(environ)
if request.is_xhr:
request.response = Response()
request.response.headerlist = []
request.response.headerlist.extend(
(('Access-Control-Allow-Origin', '*'),
#('Content-Type', 'application/json')
))
return request
def test_item_image_delete_fail(self):
"""
Test deletion of non-existent image via DELETE request.
"""
# send DELETE request
request = Request({}, method='DELETE')
request.matchdict = {'id': 1}
request.registry = self.config.registry
self.assertRaises(HTTPBadRequest, item_images, None, request)
def _make_one(self, v=_no_header):
from pyramid.request import Request
r = Request(environ={})
class FakeRegistry(object):
settings = {'pyramid.available_languages': 'en fr'}
r.registry = FakeRegistry()
if v is not _no_header:
r.headers['Accept-Language'] = v
return r
def getRequest():
r = Request({
"PATH_INFO": "http://aaa.com/test?key=123",
"wsgi.url_scheme": "http",
"SERVER_NAME": "testserver.de",
"SERVER_PORT": 80,
"REQUEST_METHOD": "GET"
})
r.subpath = ["file1.txt"]
r.context = None
return r
def test_invalid_path(self):
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
tween = config.junk_encoding_tween_factory(handler, pretend.stub())
request = Request({"PATH_INFO": "/projects/abouÅt"})
resp = tween(request)
assert resp is not response
assert resp.status_code == 400
assert resp.detail == "Invalid bytes in URL."
def test_form_parsing(self):
environ = {
'PATH_INFO': '/',
'QUERY_STRING':
'lastName=Doe;country:list=Japan;country:list=Hungary',
}
request = Request(environ)
zrequest = IBrowserRequest(request)
assert_that(zrequest.form, {
'country': ['Japan', 'Hungary'],
'lastName': 'Doe'
})
def request_factory(environ):
"""
This functions
:param environ:
:return request:
"""
request = Request(environ)
request.response = Response()
request.response.headerlist = []
request.response.headerlist.extend(
(('Access-Control-Allow-Origin', '*'), ('Content-Type', '*')))
return request
def _makeOne(self, environ=None):
from pyramid.url import URLMethodsMixin
if environ is None:
environ = {}
class Request(URLMethodsMixin):
application_url = 'http://example.com:5432'
script_name = ''
def __init__(self, environ):
self.environ = environ
request = Request(environ)
request.registry = self.config.registry
return request
def test_items_put(self):
"""
Test updating an item.
"""
self._create_item_status()
payload = {
"name": "Macbook Air",
"type": "TRADE",
"quantity": "1",
"price": "",
"description": "Lightweight lappy.",
"reason": "",
"is_draft": "y",
"uuid": str(uuid.uuid4())
}
request = Request({}, method='POST', body=json.dumps(payload))
request.registry = self.config.registry
# make the request
items(request)
# try retrieving the newly added item
item = DBSession.query(Item).first()
self.failUnless(item)
payload = {
"name": "Macbook Pro",
"type": "SALE",
"quantity": "5",
"price": "200.00",
"description": "Lightweight lappy.",
"reason": "",
"is_draft": "n",
"id": item.id
}
request.matchdict = {'id': item.id}
request.method = 'PUT'
request.body = json.dumps(payload)
# make the request again
response = items(request)
self.assertEqual(response.status_code, 200)
# reload item
item = DBSession.query(Item).filter_by(id=item.id).first()
self.assertEqual(item.name, payload['name'])
self.assertEqual(item.type, payload['type'])
self.assertEqual(item.quantity, int(payload['quantity']))
self.assertEqual(str(item.price), payload['price'])
self.assertEqual(item.status_id, self.draft_status.id)
def test_invalid_form(self):
request = Request({
"REQUEST_METHOD":
"POST",
"CONTENT_TYPE": ("multipart/form-data"),
"wsgi.input":
io.BytesIO(b'Content-Disposition: form-data; name="person"\r\n'
b"anonymous"),
})
with pytest.raises(HTTPBadRequest, match="Invalid Form Data."):
sanity.invalid_forms(request)
def test_invalid_qsl(self):
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
tween = config.junk_encoding_tween_factory(handler, pretend.stub())
request = Request({"QUERY_STRING": "%Aaction=browse"})
resp = tween(request)
assert resp is not response
assert resp.status_code == 400
assert resp.detail == "Invalid bytes in query string."
def test_validate_terminate_contract_without_amountPaid(
self, mocker_raise_operation_error):
mocker_raise_operation_error.return_value = False
request = Request(dict())
request.validated = dict()
self.contract.status = 'terminated'
request.validated['contract'] = self.contract
self.assertEquals(
validate_terminate_contract_without_amountPaid(request), None)
mocker_raise_operation_error.assert_called_once_with(
request,
'Can\'t terminate contract while \'amountPaid\' is not set')
def test_call(self):
contract = Contract()
request = Request(dict())
request.contract = None
self.assertEqual(self.isContract(None, request), False)
request.contract = Contract()
self.assertEqual(self.isContract(None, request), False)
request.contract.contractType = 'common'
self.isContract.val = 'common'
self.assertEqual(self.isContract(None, request), True)
def _makeRequest(self, extra):
from pyramid.request import Request
from io import BytesIO
kw = {'PATH_INFO':'',
'SCRIPT_NAME':'',
'SERVER_NAME':'localhost',
'SERVER_PORT':'80',
'REQUEST_METHOD':'GET',
'wsgi.version':(1,0),
'wsgi.url_scheme':'http',
'wsgi.input':BytesIO()}
kw.update(extra)
request = Request(kw)
return request
def test_valid(self):
request = Request({
"REQUEST_METHOD":
"POST",
"CONTENT_TYPE":
("multipart/form-data; boundary=c397e2aa2980f1a53dee37c05b8fb45a"),
"wsgi.input":
io.BytesIO(
b"--------------------------c397e2aa2980f1a53dee37c05b8fb45a\r\n"
b'Content-Disposition: form-data; name="person"\r\n'
b"anonymous"),
})
sanity.invalid_forms(request)
def _makeRequest(self, kw=None):
from pyramid.request import Request
environ = {
'wsgi.url_scheme': 'http',
'wsgi.version': (1, 0),
'SERVER_NAME': 'example.com',
'SERVER_PORT': '6543',
'PATH_INFO': '/',
'SCRIPT_NAME': '',
'REQUEST_METHOD': 'GET',
}
if kw is not None:
environ.update(kw)
return Request(environ=environ)
def test_directive_get_sockjs_manager(self):
self.config.include('pyramid_sockjs')
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
self.assertTrue(hasattr(request, 'get_sockjs_manager'))
def test_tilecache(self):
from papyrus_tilecache.views import tilecache
from pyramid.request import Request
from papyrus_tilecache.views import load_tilecache_config
curdir = os.path.dirname(os.path.abspath(__file__))
cfgfile = os.path.join(curdir, 'tilecache.cfg')
settings = {'tilecache.cfg': cfgfile}
load_tilecache_config(settings)
context = DummyContext()
request = Request({})
response = tilecache(context, request)
from pyramid.response import Response
self.assertTrue(isinstance(response, Response))
def test_request_has_localizer(self):
from pyramid.threadlocal import get_current_registry
from pyramid.interfaces import ILocalizer
from pyramid.request import Request
# register mock localizer
dummy = object()
registry = get_current_registry()
registry.registerUtility(dummy, ILocalizer, name='en')
request = Request(environ={})
self.assertEqual(request.localizer, dummy)
# `get_localizer` is only called once...
other = object()
registry.registerUtility(other, ILocalizer, name='en')
self.assertNotEqual(request.localizer, other)
self.assertEqual(request.localizer, dummy)
def test_verify_output_bytestring(self):
from pyramid.request import Request
from pyramid.config import Configurator
from pyramid.view import render_view
from webob.compat import text_type
config = Configurator(settings={})
def view(request):
request.response.text = text_type('<body></body>')
return request.response
config.add_view(name='test', view=view)
config.commit()
r = Request({})
r.registry = config.registry
self.assertEqual(render_view(object(), r, 'test'), b'<body></body>')
def test_get_session_manager_unknown(self):
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
self.assertRaises(
KeyError, request.get_sockjs_manager, 'test')
self.config.add_sockjs_route()
self.assertRaises(
KeyError, request.get_sockjs_manager, 'test')
def test_get_session_manager_default(self):
import pyramid_sockjs
self.config.add_sockjs_route()
request = Request(self._environ)
request.registry = self.registry
self.registry.notify(NewRequest(request))
try:
from pyramid.interfaces import IRequestExtensions
extensions = self.registry.getUtility(IRequestExtensions)
request._set_extensions(extensions)
except ImportError:
pass
sm = request.get_sockjs_manager()
self.assertIs(self.registry.__sockjs_managers__[''], sm)
def _makeOne(self, environ=None):
from pyramid.decorator import reify
from pyramid.view import ViewMethodsMixin
if environ is None:
environ = {}
class Request(ViewMethodsMixin):
def __init__(self, environ):
self.environ = environ
@reify
def response(self):
return DummyResponse()
request = Request(environ)
request.registry = self.config.registry
return request
def __call__(self, environ, start_response):
request = Request(environ)
if request.path.endswith('shell') and request.method == 'GET':
try:
backend = self.app.routes_mapper(request)['match']['backend']
machine = self.app.routes_mapper(request)['match']['machine']
host = request.params.get('host', None)
ssh_user = request.params.get('ssh_user', None)
command = request.params.get('command', None)
request.registry = self.app.registry
if not ssh_user or ssh_user == 'undefined':
log.debug("Will select root as the ssh-user as we don't know who we are")
ssh_user = '******'
with get_user(request, readonly=True) as user:
keypairs = user['keypairs']
preferred_keypairs = get_preferred_keypairs(keypairs, backend, machine)
log.debug("preferred keypairs = %s" % preferred_keypairs)
if preferred_keypairs:
keypair = keypairs[preferred_keypairs[0]]
private_key = keypair['private']
s_user = get_ssh_user_from_keypair(keypair, backend, machine)
log.debug("get user from keypair returned: %s" % s_user)
if s_user:
ssh_user = s_user
log.debug("Will select %s as the ssh-user" % ssh_user)
else:
private_key = None
log.error("Missing private key")
raise Exception("Missing private key")
conn = connect(request, backend)
if conn:
return self.stream_command(conn, machine, host, ssh_user,
private_key, command,
start_response)
else:
raise
except:
# leave error handling up to the app
return self.app(environ, start_response)
else:
return self.app(environ, start_response)
def make_request(config, path="/", environ={}):
"""Helper function for making pyramid Request objects."""
my_environ = {}
my_environ["wsgi.version"] = (1, 0)
my_environ["wsgi.multithread"] = True
my_environ["wsgi.multiprocess"] = True
my_environ["wsgi.run_once"] = False
my_environ["wsgi.url_scheme"] = "http"
my_environ["REQUEST_METHOD"] = "GET"
my_environ["SCRIPT_NAME"] = ""
my_environ["PATH_INFO"] = path
my_environ["SERVER_NAME"] = "localhost"
my_environ["SERVER_PORT"] = "5000"
my_environ["QUERY_STRING"] = "5000"
my_environ.update(environ)
request = Request(my_environ)
request.registry = config.registry
return request
