Python Storage.env方法代码示例

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
 def test_routes_absolute(self):
     """
     Test absolute URL
     """
     load(data="")
     r = Storage()
     r.env = Storage()
     r.env.http_host = "domain.com"
     r.env.wsgi_url_scheme = "httpx"  # distinguish incoming scheme
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f")), "/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", host=True)), "httpx://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", host="host.com")), "httpx://host.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=True)), "httpx://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=False)), "/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme="https")), "https://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme="wss")), "wss://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=True, host=True)), "httpx://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme="https", host=True)), "https://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=False, host=True)), "httpx://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=True, host="host.com")), "httpx://host.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=False, host="host.com")), "httpx://host.com/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", port=1234)), "httpx://domain.com:1234/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", scheme=True, port=1234)), "httpx://domain.com:1234/a/c/f")
     self.assertEqual(str(URL(r=r, a="a", c="c", f="f", host="host.com", port=1234)), "httpx://host.com:1234/a/c/f")
     self.assertEqual(
         str(URL(r=r, a="a", c="c", f="f", scheme="wss", host="host.com", port=1234)), "wss://host.com:1234/a/c/f"
     )

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
    def testURL(self):
        self.assertEqual(URL('a', 'c', 'f', args='1'), '/a/c/f/1')
        self.assertEqual(URL('a', 'c', 'f', args=('1', '2')), '/a/c/f/1/2')
        self.assertEqual(URL('a', 'c', 'f', args=['1', '2']), '/a/c/f/1/2')
        self.assertEqual(URL('a', 'c', '/f'), '/a/c/f')
        self.assertEqual(URL('a', 'c', 'f.json'), '/a/c/f.json')
        self.assertRaises(SyntaxError, URL, *['a'])

        request = Storage()
        request.application = 'a'
        request.controller = 'c'
        request.function = 'f'
        request.env = {}

        from globals import current  # Can't be moved with other import
        current.request = request

        must_return = '/a/c/f'
        self.assertEqual(URL(), must_return)
        self.assertEqual(URL('f'), must_return)
        self.assertEqual(URL('c', 'f'), must_return)
        self.assertEqual(URL('a', 'c', 'f'), must_return)
        self.assertEqual(URL('a', 'c', 'f', extension='json'), '/a/c/f.json')

        def weird():
            pass
        self.assertEqual(URL('a', 'c', weird), '/a/c/weird')
        self.assertRaises(SyntaxError, URL, *['a', 'c', 1])
        # test signature
        rtn = URL(
            a='a', c='c', f='f', args=['x', 'y', 'z'],
            vars={'p': (1, 3), 'q': 2}, anchor='1', hmac_key='key'
            )
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f#1')
        # test _signature exclusion
        rtn = URL(
            a='a', c='c', f='f', args=['x', 'y', 'z'],
            vars={'p': (1, 3), 'q': 2, '_signature': 'abc'},
            anchor='1', hmac_key='key'
            )
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f#1')
        # emulate user_signature
        current.session = Storage(auth=Storage(hmac_key='key'))
        self.assertEqual(URL(user_signature=True), '/a/c/f?_signature=c4aed53c08cff08f369dbf8b5ba51889430cf2c2')
        # hash_vars combination
        rtn = URL('a', 'c', 'f', args=['x', 'y', 'z'], vars={'p': (1, 3), 'q': 2}, hmac_key='key')
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f')
        rtn = URL('a', 'c', 'f', args=['x', 'y', 'z'], vars={'p': (1, 3), 'q': 2}, hmac_key='key', hash_vars=True)
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f')
        rtn = URL('a', 'c', 'f', args=['x', 'y', 'z'], vars={'p': (1, 3), 'q': 2}, hmac_key='key', hash_vars=False)
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=0b5a0702039992aad23c82794b8496e5dcd59a5b')
        rtn = URL('a', 'c', 'f', args=['x', 'y', 'z'], vars={'p': (1, 3), 'q': 2}, hmac_key='key', hash_vars=['p'])
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=5d01b982fd72b39674b012e0288071034e156d7a')
        rtn = URL('a', 'c', 'f', args=['x', 'y', 'z'], vars={'p': (1, 3), 'q': 2}, hmac_key='key', hash_vars='p')
        self.assertEqual(rtn, '/a/c/f/x/y/z?p=1&p=3&q=2&_signature=5d01b982fd72b39674b012e0288071034e156d7a')
        # test CRLF detection
        self.assertRaises(SyntaxError, URL, *['a\n', 'c', 'f'])
        self.assertRaises(SyntaxError, URL, *['a\r', 'c', 'f'])

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
 def test_routes_absolute(self):
     '''
     Test absolute URL
     '''
     load(data='')
     r = Storage()
     r.env = Storage()
     r.env.http_host = 'domain.com'
     r.env.wsgi_url_scheme = 'httpx'  # distinguish incoming scheme
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f')), "/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', host=True)),
                      "httpx://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', host='host.com')),
                      "httpx://host.com/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme=True)),
                      "httpx://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme=False)),
                      "/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme='https')),
                      "https://domain.com/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme='wss')),
                      "wss://domain.com/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme=True, host=True)),
         "httpx://domain.com/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme='https', host=True)),
         "https://domain.com/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme=False, host=True)),
         "httpx://domain.com/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme=True, host='host.com')),
         "httpx://host.com/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme=False, host='host.com')),
         "httpx://host.com/a/c/f")
     self.assertEqual(str(URL(r=r, a='a', c='c', f='f', port=1234)),
                      "httpx://domain.com:1234/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme=True, port=1234)),
         "httpx://domain.com:1234/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', host='host.com', port=1234)),
         "httpx://host.com:1234/a/c/f")
     self.assertEqual(
         str(URL(r=r, a='a', c='c', f='f', scheme='wss',
             host='host.com', port=1234)),
         "wss://host.com:1234/a/c/f")

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
    def test_verifyURL(self):
        r = Storage()
        r.application = "a"
        r.controller = "c"
        r.function = "f"
        r.extension = "html"
        r.env = {}
        r.get_vars = Storage()
        # missing signature as request.get_vars returns False
        rtn = verifyURL(r, "key")
        self.assertEqual(rtn, False)
        # reverse tests from previous testcase with hash_vars combinations
        r.args = ["x", "y", "z"]
        r.get_vars = Storage(p=(1, 3), q=2)
        # add signature
        r.get_vars["_signature"] = "a32530f0d0caa80964bb92aad2bedf8a4486a31f"
        rtn = verifyURL(r, "key")
        self.assertEqual(rtn, True)
        r.get_vars["_signature"] = "a32530f0d0caa80964bb92aad2bedf8a4486a31f"
        rtn = verifyURL(r, "key", hash_vars=True)
        self.assertEqual(rtn, True)
        r.get_vars["_signature"] = "0b5a0702039992aad23c82794b8496e5dcd59a5b"
        rtn = verifyURL(r, "key", hash_vars=False)
        self.assertEqual(rtn, True)
        r.get_vars["_signature"] = "5d01b982fd72b39674b012e0288071034e156d7a"
        rtn = verifyURL(r, "key", hash_vars=["p"])
        self.assertEqual(rtn, True)
        r.get_vars["_signature"] = "5d01b982fd72b39674b012e0288071034e156d7a"
        rtn = verifyURL(r, "key", hash_vars="p")
        self.assertEqual(rtn, True)
        # without session, user_signature returns always False
        rtn = verifyURL(r, user_signature=True)
        self.assertEqual(rtn, False)
        # same goes if you don't use an hmac_key
        rtn = verifyURL(r)
        self.assertEqual(rtn, False)
        # emulate user signature
        from globals import current

        current.session = Storage(auth=Storage(hmac_key="key"))
        r.get_vars["_signature"] = "a32530f0d0caa80964bb92aad2bedf8a4486a31f"
        rtn = verifyURL(r, user_signature=True)
        self.assertEqual(rtn, True)

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
 def test_verifyURL(self):
     r = Storage()
     r.application = 'a'
     r.controller = 'c'
     r.function = 'f'
     r.extension = 'html'
     r.env = {}
     r.get_vars = Storage()
     # missing signature as request.get_vars returns False
     rtn = verifyURL(r, 'key')
     self.assertEqual(rtn, False)
     # reverse tests from previous testcase with hash_vars combinations
     r.args = ['x', 'y', 'z']
     r.get_vars = Storage(p=(1, 3), q=2)
     # add signature
     r.get_vars['_signature'] = 'a32530f0d0caa80964bb92aad2bedf8a4486a31f'
     rtn = verifyURL(r, 'key')
     self.assertEqual(rtn, True)
     r.get_vars['_signature'] = 'a32530f0d0caa80964bb92aad2bedf8a4486a31f'
     rtn = verifyURL(r, 'key', hash_vars=True)
     self.assertEqual(rtn, True)
     r.get_vars['_signature'] = '0b5a0702039992aad23c82794b8496e5dcd59a5b'
     rtn = verifyURL(r, 'key', hash_vars=False)
     self.assertEqual(rtn, True)
     r.get_vars['_signature'] = '5d01b982fd72b39674b012e0288071034e156d7a'
     rtn = verifyURL(r, 'key', hash_vars=['p'])
     self.assertEqual(rtn, True)
     r.get_vars['_signature'] = '5d01b982fd72b39674b012e0288071034e156d7a'
     rtn = verifyURL(r, 'key', hash_vars='p')
     self.assertEqual(rtn, True)
     # without session, user_signature returns always False
     rtn = verifyURL(r, user_signature=True)
     self.assertEqual(rtn, False)
     # same goes if you don't use an hmac_key
     rtn = verifyURL(r)
     self.assertEqual(rtn, False)
     # emulate user signature
     from globals import current
     current.session = Storage(auth=Storage(hmac_key='key'))
     r.get_vars['_signature'] = 'a32530f0d0caa80964bb92aad2bedf8a4486a31f'
     rtn = verifyURL(r, user_signature=True)
     self.assertEqual(rtn, True)

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
 def testURL(self):
     self.assertEqual(URL('a', 'c', 'f', args='1'), '/a/c/f/1')
     self.assertEqual(URL('a', 'c', 'f', args=('1', '2')), '/a/c/f/1/2')
     self.assertEqual(URL('a', 'c', 'f', args=['1', '2']), '/a/c/f/1/2')
     self.assertEqual(URL('a', 'c', '/f'), '/a/c/f')
     self.assertEqual(URL('a', 'c', 'f.json'), '/a/c/f.json')
     self.assertRaises(SyntaxError, URL, *['a'])
     request = Storage()
     request.application = 'a'
     request.controller = 'c'
     request.function = 'f'
     request.env = {}
     from globals import current
     current.request = request
     must_return = '/a/c/f'
     self.assertEqual(URL('f'), must_return)
     self.assertEqual(URL('c', 'f'), must_return)
     self.assertEqual(URL('a', 'c', 'f'), must_return)
     self.assertEqual(URL('a', 'c', 'f', extension='json'), '/a/c/f.json')
     def weird():
         pass
     self.assertEqual(URL('a', 'c', weird), '/a/c/weird')
     self.assertRaises(SyntaxError, URL, *['a','c', 1])

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
def filter_url(url, method='get', remote='0.0.0.0', out=False, app=False, lang=None,
        domain=(None,None), env=False, scheme=None, host=None, port=None):
    "doctest/unittest interface to regex_filter_in() and regex_filter_out()"
    regex_url = re.compile(r'^(?P<scheme>http|https|HTTP|HTTPS)\://(?P<host>[^/]*)(?P<uri>.*)')
    match = regex_url.match(url)
    urlscheme = match.group('scheme').lower()
    urlhost = match.group('host').lower()
    uri = match.group('uri')
    k = uri.find('?')
    if k < 0:
        k = len(uri)
    (path_info, query_string) = (uri[:k], uri[k+1:])
    path_info = urllib.unquote(path_info)   # simulate server
    e = {
         'REMOTE_ADDR': remote,
         'REQUEST_METHOD': method,
         'WSGI_URL_SCHEME': urlscheme,
         'HTTP_HOST': urlhost,
         'REQUEST_URI': uri,
         'PATH_INFO': path_info,
         'QUERY_STRING': query_string,
         #for filter_out request.env use lowercase
         'remote_addr': remote,
         'request_method': method,
         'wsgi_url_scheme': urlscheme,
         'http_host': urlhost
    }

    request = Storage()
    e["applications_parent"] = global_settings.applications_parent
    request.env = Storage(e)
    request.uri_language = lang

    #  determine application only
    #
    if app:
        if routers:
            return map_url_in(request, e, app=True)
        return regex_select(e)

    #  rewrite outbound URL
    #
    if out:
        (request.env.domain_application, request.env.domain_controller) = domain
        items = path_info.lstrip('/').split('/')
        if items[-1] == '':
            items.pop() # adjust trailing empty args
        assert len(items) >= 3, "at least /a/c/f is required"
        a = items.pop(0)
        c = items.pop(0)
        f = items.pop(0)
        if not routers:
            return regex_filter_out(uri, e)
        acf = map_url_out(request, None, a, c, f, items, None, scheme, host, port)
        if items:
            url = '%s/%s' % (acf, '/'.join(items))
            if items[-1] == '':
                url += '/'
        else:
            url = acf
        if query_string:
            url += '?' + query_string
        return url

    #  rewrite inbound URL
    #
    (static, e) = url_in(request, e)
    if static:
        return static
    result = "/%s/%s/%s" % (request.application, request.controller, request.function)
    if request.extension and request.extension != 'html':
        result += ".%s" % request.extension
    if request.args:
        result += " %s" % request.args
    if e['QUERY_STRING']:
        result += " ?%s" % e['QUERY_STRING']
    if request.uri_language:
        result += " (%s)" % request.uri_language
    if env:
        return request.env
    return result

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import env [as 别名]
    def test_URL(self):
        self.assertEqual(URL("a", "c", "f", args="1"), "/a/c/f/1")
        self.assertEqual(URL("a", "c", "f", args=("1", "2")), "/a/c/f/1/2")
        self.assertEqual(URL("a", "c", "f", args=["1", "2"]), "/a/c/f/1/2")
        self.assertEqual(URL("a", "c", "/f"), "/a/c/f")
        self.assertEqual(URL("a", "c", "f.json"), "/a/c/f.json")
        self.assertRaises(SyntaxError, URL, *["a"])

        request = Storage()
        request.application = "a"
        request.controller = "c"
        request.function = "f"
        request.env = {}

        from globals import current  # Can't be moved with other import

        current.request = request

        must_return = "/a/c/f"
        self.assertEqual(URL(), must_return)
        self.assertEqual(URL("f"), must_return)
        self.assertEqual(URL("c", "f"), must_return)
        self.assertEqual(URL("a", "c", "f"), must_return)
        self.assertEqual(URL("a", "c", "f", extension="json"), "/a/c/f.json")

        def weird():
            pass

        self.assertEqual(URL("a", "c", weird), "/a/c/weird")
        self.assertRaises(SyntaxError, URL, *["a", "c", 1])
        # test signature
        rtn = URL(a="a", c="c", f="f", args=["x", "y", "z"], vars={"p": (1, 3), "q": 2}, anchor="1", hmac_key="key")
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f#1")
        # test _signature exclusion
        rtn = URL(
            a="a",
            c="c",
            f="f",
            args=["x", "y", "z"],
            vars={"p": (1, 3), "q": 2, "_signature": "abc"},
            anchor="1",
            hmac_key="key",
        )
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f#1")
        # emulate user_signature
        current.session = Storage(auth=Storage(hmac_key="key"))
        self.assertEqual(URL(user_signature=True), "/a/c/f?_signature=c4aed53c08cff08f369dbf8b5ba51889430cf2c2")
        # hash_vars combination
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"p": (1, 3), "q": 2}, hmac_key="key")
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f")
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"p": (1, 3), "q": 2}, hmac_key="key", hash_vars=True)
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=a32530f0d0caa80964bb92aad2bedf8a4486a31f")
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"p": (1, 3), "q": 2}, hmac_key="key", hash_vars=False)
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=0b5a0702039992aad23c82794b8496e5dcd59a5b")
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"p": (1, 3), "q": 2}, hmac_key="key", hash_vars=["p"])
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=5d01b982fd72b39674b012e0288071034e156d7a")
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"p": (1, 3), "q": 2}, hmac_key="key", hash_vars="p")
        self.assertEqual(rtn, "/a/c/f/x/y/z?p=1&p=3&q=2&_signature=5d01b982fd72b39674b012e0288071034e156d7a")
        # test url_encode
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"maï": (1, 3), "lié": 2}, url_encode=False)
        self.assertEqual(rtn, "/a/c/f/x/y/z?li\xc3\xa9=2&ma\xc3\xaf=1&ma\xc3\xaf=3")
        rtn = URL("a", "c", "f", args=["x", "y", "z"], vars={"maï": (1, 3), "lié": 2}, url_encode=True)
        self.assertEqual(rtn, "/a/c/f/x/y/z?li%C3%A9=2&ma%C3%AF=1&ma%C3%AF=3")
        # test CRLF detection
        self.assertRaises(SyntaxError, URL, *["a\n", "c", "f"])
        self.assertRaises(SyntaxError, URL, *["a\r", "c", "f"])