Python environ.pop函数代码示例

    def _get_info(self):
        old_lang = environ.get('LANG')
        environ['LANG'] = 'C'

        sys_profiler_process = Popen(
            ["system_profiler", "SPBluetoothDataType"],
            stdout=PIPE
        )

        stdout = sys_profiler_process.communicate()[0].decode('utf-8')
        output = stdout.splitlines()

        lines = []
        for line in output:
            if 'Bluetooth Power' not in line:
                continue
            lines.append(line)

        if old_lang is None:
            environ.pop('LANG')
        else:
            environ['LANG'] = old_lang

        if output and len(lines) == 1:
            return lines[0].split()[2]
        else:
            return None

    def test_adds_authorization_header_to_response_with_cookie(self):
        environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.middlewares_test_auth_settings'

        class TestResource(ListResourceMixin):

            def list(self, request):
                request.environ['session']['test'] = 'test'
                return Response()

        self.test_client = self.client(
            WSGIDispatcher(resources=[TestResource]), Response
        )

        session_store = locate(settings.SESSION_STORE)()
        session = session_store.new()
        session_store.save(session)

        response = self.test_client.get(
            '/', headers=[('Cookie', 'session_id={0}'.format(session.sid))]
        )

        self.assertIn('HTTP_AUTHORIZATION', response.headers)
        self.assertEqual(
            response.headers.get('HTTP_AUTHORIZATION'), 'Token {0}'.format(session.sid)
        )

        environ.pop('MONGOREST_SETTINGS_MODULE')

def _stop_acceptance_cluster():
    """
    Stop the Flocker cluster configured for the acceptance tests.

    XXX https://clusterhq.atlassian.net/browse/FLOC-1563
    Flocker doesn't support using flocker-deploy along-side flocker-control and
    flocker-agent. Since flocker-deploy (in it's SSH using incarnation) is
    going away, we do the hack of stopping the cluster before running tests
    that use flocker-deploy. This introduces an order dependency on the
    acceptance test-suite.

    This also removes the environment variables associated with the cluster, so
    that tests attempting to use it will be skipped.

    :return: A ``Deferred`` which fires when the cluster is stopped.
    """
    control_node = environ.pop("FLOCKER_ACCEPTANCE_CONTROL_NODE", None)
    agent_nodes_env_var = environ.pop("FLOCKER_ACCEPTANCE_AGENT_NODES", "")
    agent_nodes = filter(None, agent_nodes_env_var.split(':'))

    if control_node and agent_nodes:
        return succeed(sync_perform(
            dispatcher,
            stop_cluster(control_node, agent_nodes)
        ))
    else:
        return succeed(None)

    def unsetenv(self, key):
        if environ.get(key) is not None:
            environ.pop(key)

        if WINDOWS:
            keyrm = "%s=" % key
            self.msvcrt._putenv(keyrm.encode("utf-8"))

    def test_a_default_setting_can_be_overwritten(self):
        environ.pop('MONGOREST_SETTINGS_MODULE', None)

        self.assertEqual(settings.MONGODB['URI'], '')

        environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.settings_test_settings'

        self.assertEqual(settings.MONGODB['URI'], 'test')

    def test_cors_middleware_sets_correct_headers_on_other_methods(self):
        response = self.test_client.get('/')

        self.assertIn('Access-Control-Allow-Origin', response.headers)
        self.assertIn('Access-Control-Allow-Methods', response.headers)
        self.assertIn('Access-Control-Allow-Headers', response.headers)
        self.assertIn('Access-Control-Allow-Credentials', response.headers)

        environ.pop('MONGOREST_SETTINGS_MODULE')

    def test_raises_value_error_if_auth_collection_is_not_sub_class_of_collection(self):
        environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.middlewares_test_auth_colelction_error_settings'

        self.test_client = self.client(
            WSGIDispatcher(resources=[ListResourceMixin]), Response
        )

        with self.assertRaises(ValueError):
            self.test_client.get('/')

        environ.pop('MONGOREST_SETTINGS_MODULE')

    def test_authentication_middleware_does_not_set_token_or_cookie_or_header_if_not_authorized(self):
        environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.middlewares_test_auth_settings'

        self.test_client = self.client(
            WSGIDispatcher(resources=[ListResourceMixin]), Response
        )

        response = self.test_client.get('/')

        self.assertNotIn('HTTP_AUTHORIZATION', response.headers)
        self.assertNotIn('Set-Cookie', response.headers)

        environ.pop('MONGOREST_SETTINGS_MODULE')

    def test_adds_authorization_header_to_response_without_token(self):
        environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.middlewares_test_auth_settings'

        self.test_client = self.client(
            WSGIDispatcher(resources=[ListResourceMixin]), Response
        )

        response = self.test_client.get('/')

        self.assertIn('HTTP_AUTHORIZATION', response.headers)
        self.assertIn('Token ', response.headers.get('HTTP_AUTHORIZATION'))

        environ.pop('MONGOREST_SETTINGS_MODULE')

def run(args, api):
    """
        run takes care of calling the action with the needed arguments parsed
        using argparse.

        We first try to call the action. In case the called action requires a
        valid token and the api instance does not have one a TokenRequiredError
        gets raised. In this case we catch the error and ask the user for a
        email/password combination to create a new token. After that we call
        the action again.

        pycclib raises an exception any time the API does answer with a
        HTTP STATUS CODE other than 200, 201 or 204. We catch these exceptions
        here and stop cctrlapp using sys.exit and show the error message to the
        user.
    """

    # check if there is a newer version of cctrl or pycclib
    try:
        check_for_updates(api.check_versions()['cctrl'])
    except KeyError:
        pass

    while True:
        try:
            try:
                args.func(args)
            except TokenRequiredError:
                # check ENV for credentials first
                try:
                    email = env.pop('CCTRL_EMAIL')
                    password = env.pop('CCTRL_PASSWORD')
                except KeyError:
                    email, password = get_credentials()
                try:
                    api.create_token(email, password)
                except UnauthorizedError:
                    sys.exit(messages['NotAuthorized'])
                else:
                    pass
            except ParseAppDeploymentName:
                sys.exit(messages['InvalidAppOrDeploymentName'])
            else:
                break
        except UnauthorizedError, e:
            if delete_tokenfile():
                api.set_token(None)
            else:
                sys.exit(messages['NotAuthorized'])
        except ForbiddenError, e:
            sys.exit(messages['NotAllowed'])

def main():
    venv_path = 'tmpvenv'

    import sys
    run((sys.executable, '-m', 'virtualenv', venv_path))

    from os.path import join
    venv_python = join(venv_path, 'bin', 'python')

    from os import environ
    environ.pop('__PYVENV_LAUNCHER__', None)  # this thing clobbers python's sys.executable
    # It's set by all OSX python executables  t.t

    run((venv_python, 'stage2.py'))

 def test_runtime_dir_notset(self):
     environ.pop('XDG_RUNTIME_DIR', None)
     self.assertRaises(KeyError, BaseDirectory.get_runtime_dir, strict=True)
     fallback = BaseDirectory.get_runtime_dir(strict=False)
     assert fallback.startswith('/tmp/'), fallback
     assert os.path.isdir(fallback), fallback
     mode = stat.S_IMODE(os.stat(fallback).st_mode)
     self.assertEqual(mode, stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR)
     
     # Calling it again should return the same directory.
     fallback2 = BaseDirectory.get_runtime_dir(strict=False)
     self.assertEqual(fallback, fallback2)
     mode = stat.S_IMODE(os.stat(fallback2).st_mode)
     self.assertEqual(mode, stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR)

    def test_wsgi_dispatcher_adds_middlewares_to_mounts(self):
        environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.wsgi_test_settings'

        class TestWSGIWrapper(WSGIWrapper):
            endpoint = 'test'
            url_map = Map([Rule('/', methods=['GET'], endpoint='test')])

            def test(self, request):
                return Response(status=999)

        app = WSGIDispatcher(resources=[TestWSGIWrapper])
        self.assertIsInstance(app.mounts['/test'], CORSMiddleware)

        environ.pop('MONGOREST_SETTINGS_MODULE')

    def test_no_proxy(self):
        """
        Starting with Agent 5.0.0, there should always be a local forwarder
        running and all payloads should go through it. So we should make sure
        that we pass the no_proxy environment variable that will be used by requests
        (See: https://github.com/kennethreitz/requests/pull/945 )
        """
        from os import environ as env

        env["http_proxy"] = "http://localhost:3128"
        env["https_proxy"] = env["http_proxy"]
        env["HTTP_PROXY"] = env["http_proxy"]
        env["HTTPS_PROXY"] = env["http_proxy"]

        set_no_proxy_settings()

        self.assertTrue("no_proxy" in env)

        self.assertEquals(env["no_proxy"], "127.0.0.1,localhost,169.254.169.254")
        self.assertEquals({}, get_environ_proxies(
            "http://localhost:17123/api/v1/series"))

        expected_proxies = {
            'http': 'http://localhost:3128',
            'https': 'http://localhost:3128',
            'no': '127.0.0.1,localhost,169.254.169.254'
        }
        environ_proxies = get_environ_proxies("https://www.google.com")
        self.assertEquals(expected_proxies, environ_proxies, (expected_proxies, environ_proxies))

        # Clear the env variables set
        env.pop("http_proxy", None)
        env.pop("https_proxy", None)
        env.pop("HTTP_PROXY", None)
        env.pop("HTTPS_PROXY", None)

    def test_cors_middleware_sets_correct_headers_on_options(self):
        response = self.test_client.options('/')

        self.assertIn('Access-Control-Allow-Origin', response.headers)
        self.assertIn('Access-Control-Allow-Methods', response.headers)
        self.assertIn('Access-Control-Allow-Headers', response.headers)
        self.assertIn('Access-Control-Allow-Credentials', response.headers)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.status, '200 OK')
        self.assertEqual(response.data, b'200 OK')
        self.assertEqual(response.headers.get('Content-Type'), 'text/plain')

        environ.pop('MONGOREST_SETTINGS_MODULE')