Python EnvironBuilder.get_environ方法代码示例

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
def test_environ_builder_headers_content_type():
    b = EnvironBuilder(headers={"Content-Type": "text/plain"})
    env = b.get_environ()
    assert env["CONTENT_TYPE"] == "text/plain"
    b = EnvironBuilder(content_type="text/html", headers={"Content-Type": "text/plain"})
    env = b.get_environ()
    assert env["CONTENT_TYPE"] == "text/html"

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
def test_apihandler_ws_error(conn):
    values = {'format': 'json'}
    builder = EnvironBuilder(method='POST', data=values)
    handler = WebServiceErrorHandler(connect=provider(conn))
    resp = handler.handle(Request(builder.get_environ()))
    assert_equals('application/json; charset=UTF-8', resp.content_type)
    expected = {
        "status": "error",
        "error": {
            "message": "invalid API key",
            "code": 4,
        }
    }
    assert_json_equals(expected, resp.data)
    assert_equals('400 BAD REQUEST', resp.status)
    handler = InternalErrorHandler(connect=provider(conn))
    resp = handler.handle(Request(builder.get_environ()))
    assert_equals('application/json; charset=UTF-8', resp.content_type)
    expected = {
        "status": "error",
        "error": {
            "message": "internal error",
            "code": 5,
        }
    }
    assert_json_equals(expected, resp.data)
    assert_equals('500 INTERNAL SERVER ERROR', resp.status)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
 def test_environ_builder_headers_content_type(self):
     b = EnvironBuilder(headers={'Content-Type': 'text/plain'})
     env = b.get_environ()
     self.assert_equal(env['CONTENT_TYPE'], 'text/plain')
     b = EnvironBuilder(content_type='text/html',
                        headers={'Content-Type': 'text/plain'})
     env = b.get_environ()
     self.assert_equal(env['CONTENT_TYPE'], 'text/html')

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
def test_environ_builder_headers_content_type():
    b = EnvironBuilder(headers={'Content-Type': 'text/plain'})
    env = b.get_environ()
    assert env['CONTENT_TYPE'] == 'text/plain'
    b = EnvironBuilder(content_type='text/html',
                       headers={'Content-Type': 'text/plain'})
    env = b.get_environ()
    assert env['CONTENT_TYPE'] == 'text/html'

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
def test_environ_builder_headers():
    b = EnvironBuilder(environ_base={"HTTP_USER_AGENT": "Foo/0.1"}, environ_overrides={"wsgi.version": (1, 1)})
    b.headers["X-Beat-My-Horse"] = "very well sir"
    env = b.get_environ()
    strict_eq(env["HTTP_USER_AGENT"], "Foo/0.1")
    strict_eq(env["HTTP_X_BEAT_MY_HORSE"], "very well sir")
    strict_eq(env["wsgi.version"], (1, 1))

    b.headers["User-Agent"] = "Bar/1.0"
    env = b.get_environ()
    strict_eq(env["HTTP_USER_AGENT"], "Bar/1.0")

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_environ_builder_headers(self):
        b = EnvironBuilder(environ_base={'HTTP_USER_AGENT': 'Foo/0.1'},
                           environ_overrides={'wsgi.version': (1, 1)})
        b.headers['X-Beat-My-Horse'] = 'very well sir'
        env = b.get_environ()
        self.assert_strict_equal(env['HTTP_USER_AGENT'], 'Foo/0.1')
        self.assert_strict_equal(env['HTTP_X_BEAT_MY_HORSE'], 'very well sir')
        self.assert_strict_equal(env['wsgi.version'], (1, 1))

        b.headers['User-Agent'] = 'Bar/1.0'
        env = b.get_environ()
        self.assert_strict_equal(env['HTTP_USER_AGENT'], 'Bar/1.0')

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_environ_builder_headers(self):
        b = EnvironBuilder(environ_base={'HTTP_USER_AGENT': 'Foo/0.1'},
                           environ_overrides={'wsgi.version': (1, 1)})
        b.headers['X-Suck-My-Dick'] = 'very well sir'
        env = b.get_environ()
        assert env['HTTP_USER_AGENT'] == 'Foo/0.1'
        assert env['HTTP_X_SUCK_MY_DICK'] == 'very well sir'
        assert env['wsgi.version'] == (1, 1)

        b.headers['User-Agent'] = 'Bar/1.0'
        env = b.get_environ()
        assert env['HTTP_USER_AGENT'] == 'Bar/1.0'

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_same_submission(self, mock_validate_email):
        """
        Tests that the same form is not sent twice.
        """
        builder = EnvironBuilder(method='POST',
                                 data={'name': 'Valid Guy',
                                       'email': '[email protected]',
                                       'last_name': '',
                                       'token': conf.TOKEN,
                                       'redirect': 'http://www.example.com'})

        env = builder.get_environ()

        # Mock sendmail function so it doesn't send an actual email
        smtplib.SMTP.sendmail = Mock('smtplib.SMTP.sendmail')
        mock_validate_email.return_value = True

        # Create apps
        app = handler.create_app()

        # Will cause a duplicate with the last call because
        # first app.name = 'Valid Guy' = last app.name
        req = Request(env)
        app.on_form_page(req)
        self.assertEquals(app.error, None)

        # Update name so not a duplicate
        builder.form['name'] = 'Another Guy'
        env = builder.get_environ()
        req = Request(env)
        app.on_form_page(req)
        self.assertEquals(app.error, None)

        # Update name so not a duplicate
        builder.form['name'] = 'A Third Guy'
        env = builder.get_environ()
        req = Request(env)
        app.on_form_page(req)
        self.assertEquals(app.error, None)

        # Duplicate with first app because
        # first app.name = 'Valid Guy' = this app.name
        builder.form['name'] = 'Valid Guy'
        env = builder.get_environ()
        req = Request(env)
        app.on_form_page(req)

        self.assertEquals(app.error, 'Duplicate Request')

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
 def test_format_message(self):
     # Build test environment
     builder = EnvironBuilder(method='POST',
                              data={'name': 'Valid Guy',
                                    'email': '[email protected]',
                                    'some_field': ("This is multi line and "
                                                   "should not be on the "
                                                   "same line as the title"),
                                    'redirect': 'http://www.example.com',
                                    'last_name': '',
                                    'token': conf.TOKEN})
     env = builder.get_environ()
     req = Request(env)
     target_message = ("Contact:\n"
                       "--------\n"
                       "NAME:   Valid Guy\n"
                       "EMAIL:   [email protected]\n\n"
                       "Information:\n"
                       "------------\n"
                       "Some Field:\n\n"
                       "This is multi line and should not be on the same "
                       "line as the title\n\n")
     message = handler.create_msg(req)
     formatted_message = handler.format_message(message)
     self.assertEqual(formatted_message, target_message)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_03_no_detail_on_success(self):
        builder = EnvironBuilder(method='POST',
                                 data={'serial': "HOTP123435"},
                                 headers={})
        env = builder.get_environ()
        # Set the remote address so that we can filter for it
        env["REMOTE_ADDR"] = "10.0.0.1"
        req = Request(env)
        # The response contains the token type SPASS
        res = {"jsonrpc": "2.0",
               "result": {"status": True,
                          "value": True},
               "version": "privacyIDEA test",
               "id": 1,
               "detail": {"message": "matching 1 tokens",
                          "serial": "HOTP123456",
                          "type": "hotp"}}
        resp = Response(json.dumps(res))

        # Set a policy, that does not allow the detail on success
        set_policy(name="pol2",
                   scope=SCOPE.AUTHZ,
                   action="no_detail_on_success", client="10.0.0.0/8")
        g.policy_object = PolicyClass()

        new_response = no_detail_on_success(req, resp)
        jresult = json.loads(new_response.data)
        self.assertTrue("detail" not in jresult, jresult)
        delete_policy("pol2")

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_15_reset_password(self):
        builder = EnvironBuilder(method='POST',
                                 data={'user': "cornelius",
                                       "realm": self.realm1},
                                 headers={})
        env = builder.get_environ()
        # Set the remote address so that we can filter for it
        env["REMOTE_ADDR"] = "10.0.0.1"
        req = Request(env)
        # Set a mangle policy to change the username
        # and only use the last 4 characters of the username
        set_policy(name="recover",
                   scope=SCOPE.USER,
                   action="%s" % ACTION.RESYNC)
        g.policy_object = PolicyClass()
        req.all_data = {"user": "cornelius", "realm": self.realm1}
        # There is a user policy without password reset, so an exception is
        # raised
        self.assertRaises(PolicyError, check_anonymous_user, req,
                          ACTION.PASSWORDRESET)

        # The password reset is allowed
        set_policy(name="recover",
                   scope=SCOPE.USER,
                   action="%s" % ACTION.PASSWORDRESET)
        g.policy_object = PolicyClass()
        r = check_anonymous_user(req, ACTION.PASSWORDRESET)
        self.assertEqual(r, True)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_14_required_email(self):
        g.logged_in_user = {"username": "admin1",
                            "role": "admin"}
        builder = EnvironBuilder(method='POST',
                                 data={'serial': "OATH123456"},
                                 headers={})
        env = builder.get_environ()
        # Set the remote address so that we can filter for it
        env["REMOTE_ADDR"] = "10.0.0.1"
        req = Request(env)
        # Set a mangle policy to change the username
        # and only use the last 4 characters of the username
        set_policy(name="email1",
                   scope=SCOPE.REGISTER,
                   action="%s=/.*@mydomain\..*" % ACTION.REQUIREDEMAIL)
        g.policy_object = PolicyClass()
        # request, that matches the policy
        req.all_data = {"email": "[email protected]"}
        # This emails is allowed
        r = required_email(req)
        self.assertTrue(r)

        # This email is not allowed
        req.all_data = {"email": "[email protected]"}
        # This emails is allowed
        self.assertRaises(RegistrationError, required_email, req)

        delete_policy("email1")
        g.policy_object = PolicyClass()
        # Without a policy, this email can register
        req.all_data = {"email": "[email protected]"}
        # This emails is allowed
        r = required_email(req)
        self.assertTrue(r)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_loading_file(self):
        """Test that it loads image from disk."""
        self.hass.wsgi = mock.MagicMock()

        with NamedTemporaryFile() as fp:
            fp.write('hello'.encode('utf-8'))
            fp.flush()

            assert setup_component(self.hass, 'camera', {
                'camera': {
                    'name': 'config_test',
                    'platform': 'local_file',
                    'file_path': fp.name,
                }})

            image_view = self.hass.wsgi.mock_calls[0][1][0]

            builder = EnvironBuilder(method='GET')
            Request = request_class()
            request = Request(builder.get_environ())
            request.authenticated = True
            resp = image_view.get(request, 'camera.config_test')

            assert resp.status_code == 200, resp.response
            assert resp.response[0].decode('utf-8') == 'hello'

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_10_api_endpoint(self):
        fixed = "ebedeeefegeheiej"
        otpkey = "cc17a4d77eaed96e9d14b5c87a02e718"
        uid = "000000000000"
        otps = ["ebedeeefegeheiejtjtrutblehenfjljrirgdihrfuetljtt",
                "ebedeeefegeheiejlekvlrlkrcluvctenlnnjfknrhgtjned",
                "ebedeeefegeheiejktudedbktcnbuntrhdueikggtrugckij",
                "ebedeeefegeheiejjvjncbnffdrvjcvrbgdfufjgndfetieu",
                "ebedeeefegeheiejdruibhvlvktcgfjiruhltketifnitbuk"
        ]

        token = init_token({"type": "yubikey",
                            "otpkey": otpkey,
                            "otplen": len(otps[0]),
                            "yubikey.prefix": fixed,
                            "serial": "UBAM12345678_1"})

        builder = EnvironBuilder(method='GET',
                                 headers={})
        env = builder.get_environ()
        # Set the remote address so that we can filter for it
        env["REMOTE_ADDR"] = "10.0.0.1"
        g.client_ip = env["REMOTE_ADDR"]
        req = Request(env)
        nonce = "random nonce"
        apiid = "hallo"
        apikey = "1YMEbMZijD3DzL21UfKGnOOI13c="
        set_privacyidea_config("yubikey.apiid.{0!s}".format(apiid), apikey)
        req.all_data = {'id': apiid,
                        "otp": otps[0],
                        "nonce": nonce}
        text_type, result = YubikeyTokenClass.api_endpoint(req, g)
        self.assertEqual(text_type, "plain")
        self.assertTrue("status=OK" in result, result)
        self.assertTrue("nonce={0!s}".format(nonce) in result, result)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_environ [as 别名]
    def test_send_email_default(self, mock_validate_email):
        """
        Tests that the form is sent to the correct default address when
        the 'send_to' field is set to an empty string.

        Returns true if the form has been sent to [email protected]
        Errors out if unsuccessful
        """
        builder = EnvironBuilder(method='POST',
                                 data={'name': 'Valid Guy',
                                       'email': '[email protected]',
                                       'send_to': '',
                                       'last_name': '',
                                       'token': conf.TOKEN,
                                       'redirect': 'http://www.example.com'})
        env = builder.get_environ()
        req = Request(env)

        # Construct message for assertion
        msg = handler.create_msg(req)
        msg_send = MIMEText(str(msg))
        msg_subj = handler.set_mail_subject(msg)
        msg_send['Subject'] = msg_subj
        msg_send['To'] = conf.EMAIL['default']

        # Mock sendmail function
        smtplib.SMTP.sendmail = Mock('smtplib.SMTP.sendmail')

        # Call send_email and assert sendmail was correctly called
        handler.send_email(msg, msg_subj, send_to_email='default')
        smtplib.SMTP.sendmail.assert_called_with(conf.FROM,
                                                 conf.EMAIL['default'],
                                                 msg_send.as_string())