コード例 #1
0
    def get_request(self, path=None, language=settings.LANGUAGES[0][0]):
        if not path:
            path = self.get_pages_root()

        parsed_path = urlparse(path)
        host = parsed_path.netloc or 'testserver'
        port = 80
        if ':' in host:
            host, port = host.split(':', 1)

        environ = {
            'HTTP_COOKIE': self.client.cookies,
            'PATH_INFO': parsed_path.path,
            'QUERY_STRING': parsed_path.query,
            'REMOTE_ADDR': '127.0.0.1',
            'REQUEST_METHOD': 'GET',
            'SCRIPT_NAME': '',
            'SERVER_NAME': host,
            'SERVER_PORT': port,
            'SERVER_PROTOCOL': 'HTTP/1.1',
            'wsgi.version': (1, 0),
            'wsgi.url_scheme': 'http',
            'wsgi.errors': self.client.errors,
            'wsgi.multiprocess': True,
            'wsgi.multithread': False,
            'wsgi.run_once': False,
            'wsgi.input': ''
        }
        request = WSGIRequest(environ)
        request.session = self.client.session
        request.user = getattr(self, 'user', AnonymousUser())
        request.LANGUAGE_CODE = language
        return request
コード例 #2
0
 def setUp(self):
     context = {}
     environ = {
         'HTTP_COOKIE':      self.client.cookies,
         'PATH_INFO':         '/',
         'QUERY_STRING':      '',
         'REMOTE_ADDR':       '127.0.0.1',
         'REQUEST_METHOD':    'GET',
         'SCRIPT_NAME':       '',
         'SERVER_NAME':       'testserver',
         'SERVER_PORT':       '80',
         'SERVER_PROTOCOL':   'HTTP/1.1',
         'wsgi.version':      (1,0),
         'wsgi.url_scheme':   'http',
         'wsgi.errors':       self.client.errors,
         'wsgi.multiprocess': True,
         'wsgi.multithread':  False,
         'wsgi.run_once':     False,
     }
     request = WSGIRequest(environ)
     request.session = self.client.session
     request.user = User()
     context['request'] = request
     
     self.context = context
コード例 #3
0
ファイル: tests.py プロジェクト: daniell/djangocms-utils
    def get_request(self, path=None):
        
        if not path:
            path = '/'

        environ = {
            'HTTP_COOKIE': self.client.cookies,
            'PATH_INFO': path,
            'QUERY_STRING': '',
            'REMOTE_ADDR': '127.0.0.1',
            'REQUEST_METHOD': 'GET',
            'SCRIPT_NAME': '',
            'SERVER_NAME': 'testserver',
            'SERVER_PORT': '80',
            'SERVER_PROTOCOL': 'HTTP/1.1',
            'wsgi.version': (1,0),
            'wsgi.url_scheme': 'http',
            'wsgi.errors': self.client.errors,
            'wsgi.multiprocess': True,
            'wsgi.multithread': False,
            'wsgi.run_once': False,
        }
        request = WSGIRequest(environ)
        request.session = self.client.session
        request.LANGUAGE_CODE = settings.LANGUAGE_CODE
        return request
コード例 #4
0
ファイル: testcases.py プロジェクト: hedberg/django-cms
    def get_request(self, path=None, language=settings.LANGUAGES[0][0]):
        if not path:
            path = self.get_pages_root()

        parsed_path = urlparse(path)
        host = parsed_path.netloc or 'testserver'
        port = 80
        if ':' in host:
            host, port = host.split(':', 1)

        environ = {
            'HTTP_COOKIE': self.client.cookies,
            'PATH_INFO': parsed_path.path,
            'QUERY_STRING': parsed_path.query,
            'REMOTE_ADDR': '127.0.0.1',
            'REQUEST_METHOD': 'GET',
            'SCRIPT_NAME': '',
            'SERVER_NAME': host,
            'SERVER_PORT': port,
            'SERVER_PROTOCOL': 'HTTP/1.1',
            'wsgi.version': (1, 0),
            'wsgi.url_scheme': 'http',
            'wsgi.errors': self.client.errors,
            'wsgi.multiprocess': True,
            'wsgi.multithread': False,
            'wsgi.run_once': False,
        }
        request = WSGIRequest(environ)
        request.session = self.client.session
        request.user = getattr(self, 'user', AnonymousUser())
        request.LANGUAGE_CODE = language
        return request
コード例 #5
0
ファイル: fakes.py プロジェクト: stormers/vault
def fake_request(path='/', method='GET', user=None, extra={}):
    params = {
        'REQUEST_METHOD': method,
        'PATH_INFO': path,
        'wsgi.input': StringIO()
    }
    params.update(extra)

    req = WSGIRequest(params)

    req.user = user or AnonymousUser()
    req.user.id = ''
    req.user.username = '******'
    req.user.first_name = 'mock_user'
    req.user.is_superuser = True
    req.user.groups.all = lambda: [GroupFactory(id=1)]

    req.build_absolute_uri = lambda x=None: '/'

    # for sessions middleware
    req.session = build_fake_session()

    # for messages middleware
    req._messages = default_storage(req)

    req.get_host = lambda x=None: 'localhost'

    return req
コード例 #6
0
ファイル: fakes.py プロジェクト: isabella-coimbra/vault
def fake_request(path='/', method='GET', user=True, extra={}):
    params = {
        'REQUEST_METHOD': method,
        'PATH_INFO': path,
        'wsgi.input': StringIO()
    }
    params.update(extra)

    req = WSGIRequest(params)

    if user:
        req.user = UserFactory.create(groups=(GroupFactory(), GroupFactory()))
    else:
        req.user = AnonymousUser()

    req.build_absolute_uri = lambda x=None: '/'

    # for sessions middleware
    req.session = build_fake_session()

    # for messages middleware
    req._messages = default_storage(req)

    req.get_host = lambda x=None: 'localhost'

    return req
コード例 #7
0
    def request(self, **request):
        request = WSGIRequest(self._base_environ(**request))

        if self.session:
            request.session = self.session
            request.user = get_user(request)
        return request
コード例 #8
0
ファイル: fakes.py プロジェクト: globocom/vault
def fake_request(path='/', method='GET', user=None, extra={}):
    params = {
        'REQUEST_METHOD': method,
        'PATH_INFO': path,
        'wsgi.input': StringIO()
    }
    params.update(extra)

    req = WSGIRequest(params)

    req.user = user or AnonymousUser()
    req.user.id = ''
    req.user.username = '******'
    req.user.first_name = 'mock_user'
    req.user.is_superuser = True
    req.user.groups.all = lambda: [GroupFactory(id=1)]

    req.build_absolute_uri = lambda x=None: '/'

    # for sessions middleware
    req.session = build_fake_session()

    # for messages middleware
    req._messages = default_storage(req)

    req.get_host = lambda x=None: 'localhost'

    return req
コード例 #9
0
 def process_request(self, request: WSGIRequest):
     auth_token = request.META.get("HTTP_X_AUTH_TOKEN")
     if auth_token:
         session_key = auth_token
         request.session = self.SessionStore(session_key)
     else:
         super(AuthTokenAwareSessionMiddleware,
               self).process_request(request)
コード例 #10
0
ファイル: tests.py プロジェクト: jakubste/oioioi
 def wrapped_handler500(request):
     from oioioi.base.views import handler500
     r = WSGIRequest(request)
     r.session = import_module(settings.SESSION_ENGINE).SessionStore()
     if self._user:
         r.user = self._user
     self._req = r
     return handler500(r)
コード例 #11
0
ファイル: __init__.py プロジェクト: papedaniel/oioioi
 def wrapped_handler500(request):
     from oioioi.base.views import handler500
     r = WSGIRequest(request)
     r.session = import_module(settings.SESSION_ENGINE).SessionStore()
     if self._user:
         r.user = self._user
     self._req = r
     return handler500(r)
コード例 #12
0
    def get_django_request(self):
        request = \
            WSGIRequest(WSGIContainer.environ(self.request))
        request.session = self.get_django_session()

        if self.current_user:
            request.user = self.current_user
        else:
            request.user = auth.models.AnonymousUser()
        return request
コード例 #13
0
ファイル: base_redis.py プロジェクト: prakashru/fiduswriter
    def get_django_request(self):
        request = \
            WSGIRequest(WSGIContainer.environ(self.request))
        request.session = self.get_django_session()

        if self.current_user:
            request.user = self.current_user
        else:
            request.user = auth.models.AnonymousUser()
        return request
コード例 #14
0
ファイル: tests.py プロジェクト: bebraw/django-navi
def get_request(path, method):
    """
    @param path
    @param method
    @return:
    """
    env = {"PATH_INFO": path, "REQUEST_METHOD": method}
    request = WSGIRequest(env)
    request.session = {}
    request.user = User()
    request.user.id = 1

    return request
コード例 #15
0
    def get_request(self, path=None, language=None, post_data=None, enforce_csrf_checks=False):
        if not path:
            path = self.get_pages_root()

        if not language:
            language = settings.LANGUAGES[0][0]

        parsed_path = urlparse(path)
        host = parsed_path.netloc or "testserver"
        port = 80
        if ":" in host:
            host, port = host.split(":", 1)

        environ = {
            "HTTP_COOKIE": self.client.cookies,
            "PATH_INFO": parsed_path.path,
            "QUERY_STRING": parsed_path.query,
            "REMOTE_ADDR": "127.0.0.1",
            "REQUEST_METHOD": "GET",
            "SCRIPT_NAME": "",
            "SERVER_NAME": host,
            "SERVER_PORT": port,
            "SERVER_PROTOCOL": "HTTP/1.1",
            "wsgi.version": (1, 0),
            "wsgi.url_scheme": "http",
            "wsgi.errors": self.client.errors,
            "wsgi.multiprocess": True,
            "wsgi.multithread": False,
            "wsgi.run_once": False,
            "wsgi.input": "",
        }
        if post_data:
            post_data = encode_multipart(BOUNDARY, post_data)
            environ.update(
                {
                    "CONTENT_LENGTH": len(post_data),
                    "CONTENT_TYPE": MULTIPART_CONTENT,
                    "REQUEST_METHOD": "POST",
                    "wsgi.input": FakePayload(post_data),
                }
            )
        request = WSGIRequest(environ)
        request.session = self.client.session
        request.user = getattr(self, "user", AnonymousUser())
        request.LANGUAGE_CODE = language
        if not enforce_csrf_checks:
            request.csrf_processing_done = True
        return request
コード例 #16
0
def artificial_login(**credentials):
    from django.contrib.auth import authenticate, login

    cookies = SimpleCookie()

    user = authenticate(**credentials)
    engine = import_module(settings.SESSION_ENGINE)

    # Create a fake request that goes through request middleware
    request = WSGIRequest({
        'HTTP_COOKIE': cookies.output(header='', sep=';'),
        'PATH_INFO': str('/'),
        'REMOTE_ADDR': str('127.0.0.1'),
        'REQUEST_METHOD': str('GET'),
        'SCRIPT_NAME': str(''),
        'SERVER_NAME': str('testserver'),
        'SERVER_PORT': str('80'),
        'SERVER_PROTOCOL': str('HTTP/1.1'),
        'wsgi.version': (1, 0),
        'wsgi.url_scheme': str('http'),
        'wsgi.input': BytesIO(),
        'wsgi.errors': BytesIO(),
        'wsgi.multiprocess': True,
        'wsgi.multithread': False,
        'wsgi.run_once': False,
    })
    request.session = engine.SessionStore()
    login(request, user)

    # Save the session values.
    request.session.save()

    # Set the cookie to represent the session.
    session_cookie = settings.SESSION_COOKIE_NAME
    cookies[session_cookie] = request.session.session_key
    cookie_data = {
        'max-age': None,
        'path': '/',
        'domain': settings.SESSION_COOKIE_DOMAIN,
        'secure': settings.SESSION_COOKIE_SECURE or None,
        'expires': None,
    }
    cookies[session_cookie].update(cookie_data)
    return {
        session_cookie: cookies[session_cookie].value,
        settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key(),
    }
コード例 #17
0
ファイル: debug_utils.py プロジェクト: westurner/inthe.am
def artificial_login(**credentials):
    from django.contrib.auth import authenticate, login

    cookies = SimpleCookie()

    user = authenticate(**credentials)
    engine = import_module(settings.SESSION_ENGINE)

    # Create a fake request that goes through request middleware
    request = WSGIRequest({
        "HTTP_COOKIE": cookies.output(header="", sep=";"),
        "PATH_INFO": "/",
        "REMOTE_ADDR": "127.0.0.1",
        "REQUEST_METHOD": "GET",
        "SCRIPT_NAME": "",
        "SERVER_NAME": "testserver",
        "SERVER_PORT": "80",
        "SERVER_PROTOCOL": "HTTP/1.1",
        "wsgi.version": (1, 0),
        "wsgi.url_scheme": "http",
        "wsgi.input": BytesIO(),
        "wsgi.errors": BytesIO(),
        "wsgi.multiprocess": True,
        "wsgi.multithread": False,
        "wsgi.run_once": False,
    })
    request.session = engine.SessionStore()
    login(request, user)

    # Save the session values.
    request.session.save()

    # Set the cookie to represent the session.
    session_cookie = settings.SESSION_COOKIE_NAME
    cookies[session_cookie] = request.session.session_key
    cookie_data = {
        "max-age": None,
        "path": "/",
        "domain": settings.SESSION_COOKIE_DOMAIN,
        "secure": settings.SESSION_COOKIE_SECURE or None,
        "expires": None,
    }
    cookies[session_cookie].update(cookie_data)
    return {
        session_cookie: cookies[session_cookie].value,
        settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key(),
    }
コード例 #18
0
ファイル: debug_utils.py プロジェクト: gabamnml/inthe.am
def artificial_login(**credentials):
    from django.contrib.auth import authenticate, login

    cookies = SimpleCookie()

    user = authenticate(**credentials)
    engine = import_module(settings.SESSION_ENGINE)

    # Create a fake request that goes through request middleware
    request = WSGIRequest(
        {
            "HTTP_COOKIE": cookies.output(header="", sep=";"),
            "PATH_INFO": str("/"),
            "REMOTE_ADDR": str("127.0.0.1"),
            "REQUEST_METHOD": str("GET"),
            "SCRIPT_NAME": str(""),
            "SERVER_NAME": str("testserver"),
            "SERVER_PORT": str("80"),
            "SERVER_PROTOCOL": str("HTTP/1.1"),
            "wsgi.version": (1, 0),
            "wsgi.url_scheme": str("http"),
            "wsgi.input": BytesIO(),
            "wsgi.errors": BytesIO(),
            "wsgi.multiprocess": True,
            "wsgi.multithread": False,
            "wsgi.run_once": False,
        }
    )
    request.session = engine.SessionStore()
    login(request, user)

    # Save the session values.
    request.session.save()

    # Set the cookie to represent the session.
    session_cookie = settings.SESSION_COOKIE_NAME
    cookies[session_cookie] = request.session.session_key
    cookie_data = {
        "max-age": None,
        "path": "/",
        "domain": settings.SESSION_COOKIE_DOMAIN,
        "secure": settings.SESSION_COOKIE_SECURE or None,
        "expires": None,
    }
    cookies[session_cookie].update(cookie_data)
    return {session_cookie: cookies[session_cookie].value, settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key()}
コード例 #19
0
ファイル: testcases.py プロジェクト: BeUnique/django-cms
 def get_request(self, path=None, language=None, post_data=None):
     if not path:
         path = self.get_pages_root()
     
     if not language:
         language = settings.LANGUAGES[0][0]
     
     parsed_path = urlparse(path)
     host = parsed_path.netloc or 'testserver'
     port = 80
     if ':' in host:
         host, port = host.split(':', 1)
     
     environ = {
         'HTTP_COOKIE':       self.client.cookies,
         'PATH_INFO':         parsed_path.path,
         'QUERY_STRING':      parsed_path.query,
         'REMOTE_ADDR':       '127.0.0.1',
         'REQUEST_METHOD':    'GET',
         'SCRIPT_NAME':       '',
         'SERVER_NAME':       host,
         'SERVER_PORT':       port,
         'SERVER_PROTOCOL':   'HTTP/1.1',
         'wsgi.version':      (1,0),
         'wsgi.url_scheme':   'http',
         'wsgi.errors':       self.client.errors,
         'wsgi.multiprocess': True,
         'wsgi.multithread':  False,
         'wsgi.run_once':     False,
         'wsgi.input':        ''
     }
     if post_data:
         post_data = encode_multipart(BOUNDARY, post_data)
         environ.update({
                 'CONTENT_LENGTH': len(post_data),
                 'CONTENT_TYPE':   MULTIPART_CONTENT,
                 'REQUEST_METHOD': 'POST',
                 'wsgi.input':     FakePayload(post_data),
         })
     request = WSGIRequest(environ)
     request.session = self.client.session
     request.user = getattr(self, 'user', AnonymousUser())
     request.LANGUAGE_CODE = language
     return request
コード例 #20
0
    def bogus_request(self, **request):
        """
        The master request method. Composes the environment dictionary
        and passes to the handler, returning the result of the handler.
        Assumes defaults for the query environment, which can be overridden
        using the arguments to the request.
        """
        environ = {
            "HTTP_COOKIE": self.cookies,
            "PATH_INFO": "/",
            "QUERY_STRING": "",
            "REQUEST_METHOD": "GET",
            "SCRIPT_NAME": "",
            "SERVER_NAME": "testserver",
            "SERVER_PORT": "80",
            "SERVER_PROTOCOL": "HTTP/1.1",
            "HTTP_HOST": "localhost",
            "wsgi.version": (1, 0),
            "wsgi.url_scheme": "http",
            "wsgi.errors": None,  # self.errors,
            "wsgi.multiprocess": True,
            "wsgi.multithread": False,
            "wsgi.run_once": False,
            "wsgi.input": None,
        }
        environ.update(self.defaults)
        environ.update(request)
        r = WSGIRequest(environ)
        if "django.contrib.sessions" in settings.INSTALLED_APPS:
            engine = __import__(settings.SESSION_ENGINE, {}, {}, [""])
        r.session = engine.SessionStore()
        qlen = len(r.REQUEST.dicts)

        def setQuery(**query):
            r.REQUEST.dicts = r.REQUEST.dicts[:qlen]
            q = QueryDict("", mutable=True)
            q.update(query)
            r.REQUEST.dicts += (q,)

        r.setQuery = setQuery
        return r
コード例 #21
0
 def bogus_request(self, **request):
     """
     The master request method. Composes the environment dictionary
     and passes to the handler, returning the result of the handler.
     Assumes defaults for the query environment, which can be overridden
     using the arguments to the request.
     """
     environ = {
         'HTTP_COOKIE':      self.cookies,
         'PATH_INFO':         '/',
         'QUERY_STRING':      '',
         'REQUEST_METHOD':    'GET',
         'SCRIPT_NAME':       '',
         'SERVER_NAME':       'testserver',
         'SERVER_PORT':       '80',
         'SERVER_PROTOCOL':   'HTTP/1.1',
         'HTTP_HOST':         'localhost',
         'wsgi.version':      (1,0),
         'wsgi.url_scheme':   'http',
         'wsgi.errors':       None,#self.errors,
         'wsgi.multiprocess': True,
         'wsgi.multithread':  False,
         'wsgi.run_once':     False,
         'wsgi.input':        None,
     }
     environ.update(self.defaults)
     environ.update(request)
     r = WSGIRequest(environ)
     if 'django.contrib.sessions' in settings.INSTALLED_APPS:
         engine = __import__(settings.SESSION_ENGINE, {}, {}, [''])
     r.session = engine.SessionStore()
     qlen = len(r.REQUEST.dicts)
     def setQuery (**query):
         r.REQUEST.dicts = r.REQUEST.dicts[:qlen]
         q = QueryDict('', mutable=True)
         q.update(query)
         r.REQUEST.dicts += (q,)
     r.setQuery = setQuery
     return r
コード例 #22
0
def request_mock(base=settings.SITE_URL, path='/', query_string='', user=None):
    """
    Create a request object that mocks a real one
    Useful in case a real request object is not available, but is needed (delayed Celery tasks for instance)
    """
    url_parse = urlparse(base)

    request = WSGIRequest({
        'REQUEST_METHOD': 'GET',
        'REQUEST_URI': path,

        'PATH_INFO': path,
        'QUERY_STRING': query_string,
        'SCRIPT_NAME': '',
        'HTTPS': ('on' if url_parse.scheme == 'https' else 'off'),

        'HTTP_ACCEPT': '*/*',
        'HTTP_HOST': url_parse.hostname,
        'HTTP_REFERER': base,
        'HTTP_USER_AGENT': 'MockRequest/1.0',
        'HTTP_ACCEPT_LANGUAGE': 'en-US,en;q=0.8',

        'SERVER_PROTOCOL': 'HTTP/1.1',
        'SERVER_NAME': url_parse.hostname,
        'SERVER_PORT': url_parse.port or (443 if url_parse.scheme == 'https' else 80),

        'wsgi.input': StringIO(),
        'wsgi.multiprocess': True,
        'wsgi.multithread': False,
        'wsgi.run_once': False,
        'wsgi.url_scheme': url_parse.scheme or 'http',
        'wsgi.version': (1, 0),
    })
    
    request.user = AnonymousUser() if user is None else user
    request.session = {}
    
    return request
コード例 #23
0
ファイル: base.py プロジェクト: rogeriofalcone/django-cms
 def get_request(self, path="/"):
     environ = {
         'HTTP_COOKIE':      self.client.cookies,
         'PATH_INFO':         path,
         'QUERY_STRING':      '',
         'REMOTE_ADDR':       '127.0.0.1',
         'REQUEST_METHOD':    'GET',
         'SCRIPT_NAME':       '',
         'SERVER_NAME':       'testserver',
         'SERVER_PORT':       '80',
         'SERVER_PROTOCOL':   'HTTP/1.1',
         'wsgi.version':      (1,0),
         'wsgi.url_scheme':   'http',
         'wsgi.errors':       self.client.errors,
         'wsgi.multiprocess': True,
         'wsgi.multithread':  False,
         'wsgi.run_once':     False,
     }
     request = WSGIRequest(environ)
     request.session = self.client.session
     request.user = self.user
     request.LANGUAGE_CODE = settings.LANGUAGES[0][0]
     return request
コード例 #24
0
 def request(self, **request):
     request = WSGIRequest(self._base_environ(**request))
     request.user = AnonymousUser()
     request.session = MagicMock()
     return request
コード例 #25
0
 def request(self, **request):
     "Construct a generic request object."
     req = WSGIRequest(self._base_environ(**request))
     req.session = {}
     return req
コード例 #26
0
 def request(self, **request):
     "Construct a generic request object."
     req = WSGIRequest(self._base_environ(**request))
     req.session = {}
     return req