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 __init__(self, host, port, user, passwd, wsdlDir: Path = Path(__file__).parent.parent / 'wsdl', encrypt=True, adjust_time=False, transport=None): environ.pop('http_proxy', None) environ.pop('https_proxy', None) self.host = host self.port = int(port) self.user = user self.passwd = passwd self.wsdlDir = wsdlDir self.encrypt = encrypt self.adjustTime = adjust_time self.transport = transport self.xaddrs = {} self.wsse = None # Active service client container self.services = {} self.servicesLock = RLock()
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 _fixmanpager(auto=False): """If MANPAGER is set to the vim plugin manpager.vim, this screws up the builtin help(...) function when run in a shell (see pydoc.py and https://bugs.python.org/issue8637). """ from os import environ as __environ mp = 'MANPAGER' pp = 'PYDOCPAGER' # if PYDOCPAGER has been explicitly set, sub for MANPAGER if pp in __environ: __environ[mp] = __environ[pp] return True elif mp in __environ: # look for the word 'vim' vimix = __environ[mp].find(' vim ') if vimix and __environ[mp].find(mp): # if MANPAGER follows vim, assume manpager.vim is being used if auto: # set MANPAGER to pydocpager.vim __environ[mp] = 'vim --not-a-term +PYDOCPAGER -' else: # just unset MANPAGER __environ.pop(mp) return True else: return False
def testMusicBrainz(self): # output from mb-submit-disc: # https://musicbrainz.org/cdtoc/attach?toc=1+12+195856+150+ # 15687+31841+51016+66616+81352+99559+116070+133243+149997+161710+ # 177832&tracks=12&id=KnpGsLhvH.lPrNc1PBL21lb9Bg4- # however, not (yet) in MusicBrainz database # setup to test if MusicBrainz submit URL is hardcoded to use https env_original = environ.get('XDG_CONFIG_HOME') tmp_conf = mkdtemp(suffix='.config') # HACK: hijack env var to avoid overwriting user's whipper config file # This works because directory.config_path() builds the location where # whipper's conf will reside based on the value of env XDG_CONFIG_HOME environ['XDG_CONFIG_HOME'] = tmp_conf self.config = config.Config() self.config._parser.add_section('musicbrainz') self.config._parser.set('musicbrainz', 'server', 'http://musicbrainz.org') self.config.write() self.assertEqual(self.table.getMusicBrainzSubmitURL(), "http://musicbrainz.org/cdtoc/attach?toc=1+12+1958" "56+150+15687+31841+51016+66616+81352+99559+116070+13" "3243+149997+161710+177832&tracks=12&id=KnpGsLhvH.lPr" "Nc1PBL21lb9Bg4-") # HACK: continuation - restore original env value (if defined) if env_original is not None: environ['XDG_CONFIG_HOME'] = env_original else: environ.pop('XDG_CONFIG_HOME', None) self.assertEqual(self.table.getMusicBrainzDiscId(), "KnpGsLhvH.lPrNc1PBL21lb9Bg4-") rmtree(tmp_conf)
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 reload_settings(): from os import environ global _cached_config for s in _cached_config: environ.pop(s, None) _cached_config = load_config()
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 test_settings_default_values(self): environ.pop('MONGOREST_SETTINGS_MODULE', None) self.assertEqual(settings.AUTH_COLLECTION, '') self.assertIsNotNone(settings.CORS) self.assertEqual(settings.CORS['Access-Control-Allow-Origin'], '*') self.assertEqual(settings.CORS['Access-Control-Allow-Methods'], 'GET,POST,PUT,PATCH,DELETE,OPTIONS') self.assertEqual( settings.CORS['Access-Control-Allow-Headers'], 'Accept,Accept-Encoding,Authorization,Content-Length,Content-Type,' 'Origin,User-Agent,X-CSRFToken,X-Requested-With') self.assertEqual(settings.CORS['Access-Control-Allow-Credentials'], 'true') self.assertEqual(settings.MIDDLEWARES, []) self.assertIsNotNone(settings.MONGODB) self.assertEqual(settings.MONGODB['URI'], '') self.assertEqual(settings.MONGODB['USERNAME'], '') self.assertEqual(settings.MONGODB['PASSWORD'], '') self.assertEqual(settings.MONGODB['HOST'], 'localhost') self.assertEqual(settings.MONGODB['HOSTS'], []) self.assertEqual(settings.MONGODB['PORT'], 27017) self.assertEqual(settings.MONGODB['PORTS'], []) self.assertEqual(settings.MONGODB['DATABASE'], 'mongorest') self.assertEqual(settings.MONGODB['OPTIONS'], []) self.assertEqual(settings.RETRY_LIMIT, 5) self.assertEqual(settings.BASE_RETRY_TIME, 2) self.assertEqual(settings.LINEAR_RETRIES, False) self.assertEqual(settings.SESSION_STORE, '')
def install_module(mod_name: str, pkg_name: str = None, global_name: str = None): if pkg_name is None: pkg_name = mod_name if global_name is None: global_name = mod_name prev_python_user_base: str = environ.pop('PYTHONUSERBASE', None) prev_pip_target: str = environ.pop('PIP_TARGET', None) environ['PYTHONUSERBASE'] = dependency_install_dir environ['PIP_TARGET'] = dependency_install_dir if not exists(dependency_install_dir): makedirs(dependency_install_dir) run(pip + [ 'install', '--target', dependency_install_dir, '--upgrade', '--force-reinstall', pkg_name ], env=environ) if prev_python_user_base is not None: environ['PYTHONUSERBASE'] = prev_python_user_base if prev_pip_target is not None: environ['PIP_TARGET'] = prev_pip_target # Invalidate the finder caches as a module has been installed since the python interpreter began invalidate_caches() # Check that the import worked. test_module_available(mod_name)
def test_init_basic_auth_env(): environ['COURIER_AUTH_TOKEN'] = "abcd" environ.pop('COURIER_AUTH_TOKEN') environ['COURIER_AUTH_USERNAME'] = '******' environ['COURIER_AUTH_PASSWORD'] = '******' c = Courier() assert 'Authorization' in c.session.headers
def test_authentication_middleware_adds_authorization_header_to_response_authorized_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' request.environ['collection'] = 'collection' 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 __set_mode(mode: str) -> None: # Remove potentially set environments. COMPLUS_ENVIRONMENTS = [ 'COMPlus_JITMinOpts', 'COMPlus_ReadyToRun', 'COMPlus_TieredCompilation', 'COMPlus_ZapDisable', ] for complus_environment in COMPLUS_ENVIRONMENTS: if complus_environment in environ: environ.pop(complus_environment) # Configure .NET Runtime if mode == CompilationAction.TIERED: environ['COMPlus_TieredCompilation'] = '1' elif mode == CompilationAction.NO_TIERING: environ['COMPlus_TieredCompilation'] = '0' elif mode == CompilationAction.FULLY_JITTED_NO_TIERING: environ['COMPlus_ReadyToRun'] = '0' environ['COMPlus_TieredCompilation'] = '0' environ['COMPlus_ZapDisable'] = '1' elif mode == CompilationAction.MIN_OPT: environ['COMPlus_JITMinOpts'] = '1' environ['COMPlus_TieredCompilation'] = '0' elif mode != CompilationAction.DEFAULT: raise ArgumentTypeError('Unknown mode: {}'.format(mode))
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 _sanitize(self): self.token = None sess_var_name = 'OP_SESSION_{}'.format(self.account_shorthand) try: env.pop(sess_var_name) except KeyError: pass
async def run(self): """ If includes is specified, then only sync those,else try to sync all other packages """ # TODO Change Bandersnatch internal API to take proxy settings in from config parameters if self.remote.proxy_url: environ['http_proxy'] = self.remote.proxy_url # local & global timeouts defaults to 10secs and 5 hours async with Master(self.remote.url) as master: if self.remote.proxy_url: environ.pop('http_proxy') deferred_download = self.remote.policy != Remote.IMMEDIATE workers = self.remote.download_concurrency or self.remote.DEFAULT_DOWNLOAD_CONCURRENCY with ProgressReport( message="Fetching Project Metadata", code="sync.fetching.project" ) as p: pmirror = PulpMirror( serial=0, # Serial currently isn't supported by Pulp master=master, workers=workers, deferred_download=deferred_download, python_stage=self, progress_report=p, ) packages_to_sync = None if self.remote.includes: packages_to_sync = [ Requirement(pkg).name for pkg in self.remote.includes ] await pmirror.synchronize(packages_to_sync)
def call_unset(args): """ Call unset built_in function @param: args: arguments of unset funtion """ for arg in args: if arg in environ.keys(): environ.pop(arg)
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 unsetenv(self, key): if environ.get(key) is not None: environ.pop(key) if WINDOWS: keyrm = "%s=" % key # pylint: disable=protected-access self.msvcrt._putenv(keyrm.encode("utf-8"))
def set_env(key, value): old = environ.get(key) environ[key] = value yield if old is None: environ.pop(key) else: environ[key] = old
def instance_path(): """Fixture for creating an instance path.""" path = tempfile.mkdtemp() environ.update( INVENIO_INSTANCE_PATH=environ.get('INSTANCE_PATH', path), ) yield path environ.pop('INVENIO_INSTANCE_PATH', None) shutil.rmtree(path)
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 __update_environment(self): from os import chdir from os import environ as env from os import pathsep as sep # set workspace chdir(self._svc_cwd_) # update environment path env['PATH'] = f"{self._svc_env_}\Scripts{sep}{env['PATH']}" # remove pythonhome from environment env.pop('PYTHONHOME', None)
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 delete(self, key): """Deletes an old, persisted config_value. Args: Returns: None """ environ.pop(key, None) ConfigValue.query.filter_by(key=key).delete() db.session.commit()
def git_environ(): conf = read_conf() username = conf.get('git_username') or \ click.prompt('Enter your Git Username:'******'git_password') or \ click.prompt('Enter your Git Password', type=str) environ['GIT_USERNAME'] = username environ['GIT_PASSWORD'] = password yield environ.pop('GIT_USERNAME', None) environ.pop('GIT_PASSWORD', None)
def test_load_xml_search_arts_path(self): """Test loading file from ARTS_DATA_PATH""" backup_path = environ.get("ARTS_DATA_PATH") environ["ARTS_DATA_PATH"] = self.ref_dir xml.load("vector.xml") if backup_path: environ["ARTS_DATA_PATH"] = backup_path else: environ.pop("ARTS_DATA_PATH")
def _set_environ(self, key: str, value) -> None: """Set key in environment to value. Note: If value is None the key is removed from the environment. """ if value is not None: environ[key] = value else: environ.pop(key, None)
def test_gae(): environ["GAE_ENV"] = "standard" try: reload(lumapps.api.utils) assert (type(lumapps.api.utils._discovery_cache) == lumapps.api.utils.DiscoveryCacheDict) finally: environ.pop("GAE_ENV", None) reload(lumapps.api.utils) invalidate_caches() assert (type(lumapps.api.utils._discovery_cache) == lumapps.api.utils.DiscoveryCacheSqlite)
def test_health(self): app = self.mk_app(self.workspace, settings=self.settings) environ['MARATHON_APP_ID'] = 'marathon-app-id' environ['MARATHON_APP_VERSION'] = 'marathon-app-version' resp = app.get('/health/', status=200) data = json.loads(resp.body) self.assertEqual(data, { 'id': 'marathon-app-id', 'version': 'marathon-app-version', }) environ.pop('MARATHON_APP_ID') environ.pop('MARATHON_APP_VERSION')
def test_storage_options_local(): env['BAG_STORAGE_KIND'] = 'local' conf = config.DumpBagConfig() env.pop('BAG_STORAGE_LOCAL_DIR', None) with pytest.raises(exception.DumpConfigurationError): conf.storage_options() env['BAG_STORAGE_LOCAL_DIR'] = 'foo' options = conf.storage_options() assert type(options) == storage.LocalOptions assert options.storage_dir == 'foo'
def test_encryption_options_gpg(): env['BAG_ENCRYPTION_KIND'] = 'gpg' conf = config.DumpBagConfig() env.pop('BAG_GPG_RECIPIENTS', None) with pytest.raises(exception.DumpConfigurationError): conf.encryption_options() env['BAG_GPG_RECIPIENTS'] = '*****@*****.**' options = conf.encryption_options() assert type(options) == encryption.GPGKeysOptions assert options.recipients == ['*****@*****.**']
def test_authentication_middleware_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_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 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 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_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_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_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')
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_develop_theme(self): ''' Check if the rules are developed ''' # First we check the status of our environment variables var_name = 'DIAZO_ALWAYS_CACHE_RULES' env_had_var = var_name in environ # and clean it up env_var_backup = environ.pop(var_name, None) transform = ThemeTransform(None, {}) # This evaluates to True because we set # getConfiguration().debug_mode to True in the test setup self.assertTrue(transform.develop_theme()) # But we can anyway force the cache environ[var_name] = 'true' self.assertFalse(transform.develop_theme()) # If we require to debug.diazo the variable will be ignored transform = ThemeTransform(None, {'diazo.debug': '1'}) self.assertTrue(transform.develop_theme()) # Then we reset our env variables before leaving if env_had_var: environ[var_name] = env_var_backup else: del environ[var_name]
def test_upload_to_s3(self): environ['AWS_SESSION_TOKEN'] = 'Good Times' environ.pop('AWS_ACCESS_KEY_ID', None) with mock.patch('boto3.session.Session') as resource: _upload_to_s3('oa.mbtiles', 'xxx', 'yyy', 'zzz', 'bbb', 'kkk') self.assertEqual(len(resource.mock_calls), 4) self.assertEqual(resource.mock_calls[0][1], ('yyy', 'zzz', 'xxx')) self.assertEqual(resource.mock_calls[1][1], ('s3', )) self.assertEqual(resource.mock_calls[2][0], '().resource().Bucket') self.assertEqual(resource.mock_calls[2][1], ('bbb', )) self.assertEqual(resource.mock_calls[3][0], '().resource().Bucket().upload_file') self.assertEqual(resource.mock_calls[3][1], ('oa.mbtiles', 'kkk')) self.assertEqual(environ['AWS_SESSION_TOKEN'], 'Good Times') self.assertNotIn('AWS_ACCESS_KEY_ID', environ)
def test_header6(): """ Test environment variable QSTAT_HEADER_FULL """ delim = ':' callbacks = [ # <cb function> <cb args (tuple) > ( cb_debug , () ), ( cb_split , (delim,) ) ] environ.pop('CQSTAT_HEADER_FULL') parser = ArgParse(__doc__, callbacks) parser.parse_it(['-f']) # parse the command line h = header_info(parser) if h.header == ['custom','qheader','full']: good = True else: good = False assert good, "Wrong value for header: %s" % str(h.header)
def test_settings_default_values(self): environ.pop('MONGOREST_SETTINGS_MODULE', None) self.assertEqual(settings.AUTH_COLLECTION, '') self.assertIsNotNone(settings.CORS) self.assertEqual( settings.CORS['Access-Control-Allow-Origin'], '*' ) self.assertEqual( settings.CORS['Access-Control-Allow-Methods'], 'GET,POST,PUT,PATCH,DELETE,OPTIONS' ) self.assertEqual( settings.CORS['Access-Control-Allow-Headers'], 'Accept,Accept-Encoding,Authorization,Content-Length,Content-Type,' 'Origin,User-Agent,X-CSRFToken,X-Requested-With' ) self.assertEqual( settings.CORS['Access-Control-Allow-Credentials'], 'true' ) self.assertEqual(settings.MIDDLEWARES, []) self.assertIsNotNone(settings.MONGODB) self.assertEqual(settings.MONGODB['URI'], '') self.assertEqual(settings.MONGODB['USERNAME'], '') self.assertEqual(settings.MONGODB['PASSWORD'], '') self.assertEqual(settings.MONGODB['HOST'], 'localhost') self.assertEqual(settings.MONGODB['HOSTS'], []) self.assertEqual(settings.MONGODB['PORT'], 27017) self.assertEqual(settings.MONGODB['PORTS'], []) self.assertEqual(settings.MONGODB['DATABASE'], 'mongorest') self.assertEqual(settings.MONGODB['OPTIONS'], []) self.assertEqual(settings.RETRY_LIMIT, 5) self.assertEqual(settings.BASE_RETRY_TIME, 2) self.assertEqual(settings.LINEAR_RETRIES, False) self.assertEqual(settings.SESSION_STORE, '')
def _get_uid(self): old_lang = environ.get('LANG') environ['LANG'] = 'C' ioreg_process = Popen(["ioreg", "-l"], stdout=PIPE) grep_process = Popen( ["grep", "IOPlatformSerialNumber"], stdin=ioreg_process.stdout, stdout=PIPE ) ioreg_process.stdout.close() output = grep_process.communicate()[0] if old_lang is None: environ.pop('LANG') else: environ['LANG'] = old_lang result = None if output: result = output.split()[3][1:-1] return result
def test_env_var_config_no_split_sequence(self): def make_key(appname, key): return "{0}_{1}".format(appname.upper(), key.upper()) appname = "myapp" test_dict = {} test_dict[make_key(appname, 'channels')] = 'channel1' try: environ.update(test_dict) assert 'MYAPP_CHANNELS' in environ config = SampleConfiguration()._set_env_vars(appname) assert config.channels == ('channel1',) finally: [environ.pop(key) for key in test_dict]
def test_env_var_config_alias(self): def make_key(appname, key): return "{0}_{1}".format(appname.upper(), key.upper()) appname = "myapp" test_dict = {} test_dict[make_key(appname, 'yes')] = 'yes' test_dict[make_key(appname, 'changeps1')] = 'false' try: environ.update(test_dict) assert 'MYAPP_YES' in environ config = SampleConfiguration()._set_env_vars(appname) assert config.always_yes is True assert config.changeps1 is False finally: [environ.pop(key) for key in test_dict]
def test_env_var_config(self): def make_key(appname, key): return "{0}_{1}".format(appname.upper(), key.upper()) appname = "myapp" test_dict = {} test_dict[make_key(appname, 'always_yes')] = 'yes' test_dict[make_key(appname, 'changeps1')] = 'false' try: environ.update(test_dict) assert 'MYAPP_ALWAYS_YES' in environ raw_data = load_from_string_data('file1', 'file2') config = TestConfiguration(app_name=appname)._add_raw_data(raw_data) assert config.changeps1 is False assert config.always_yes is True finally: [environ.pop(key) for key in test_dict]
def test_an_invalid_setting_will_raise_error(self): environ.pop('MONGOREST_SETTINGS_MODULE', None) with self.assertRaises(AttributeError): return settings.i_am_an_invalid_setting
def test_a_new_setting_value_can_be_added(self): environ.pop('MONGOREST_SETTINGS_MODULE', None) environ['MONGOREST_SETTINGS_MODULE'] = 'tests.fixtures.settings_test_settings' self.assertEqual(settings.TEST, 'test')
def main(): parser = get_parser() args = parser.parse_args() vxlDir = path_join(env['VIP_VXL_BUILD_DIR'], env['VIP_VXL_BUILD_TYPE']) mkpath(vxlDir); os.chdir(vxlDir); if os.name == 'nt': if not os.path.exists(env['VIP_GLEW_INCLUDE_DIR']): print "You are missing Glew" from voxel_globe.tools.wget import download print "Downloading..." zipFile = os.path.join(env['VIP_GLEW_INCLUDE_DIR'], '../../glew.zip') dater = download('http://downloads.sourceforge.net/project/glew/glew/' '1.12.0/glew-1.12.0-win32.zip', zipFile) print "Unpacking..." subprocess.Popen(['7z.exe', 'x', zipFile], cwd=os.path.join(env['VIP_GLEW_INCLUDE_DIR'], '../..')).wait(); from distutils.msvc9compiler import find_vcvarsall platform = env.get('VIP_CMAKE_PLATFORM', None) if 'VCVARSALL' not in env: if platform and platform.lower().startswith('visual'): msvcVersion = int(platform.split(' ')[2]) vcvarall = find_vcvarsall(msvcVersion) else: for v in range(14, 8, -1): #Start with version 2015(14), and got back to (8), #before that its 32 bit only, and we don't care about that vcvarall = find_vcvarsall(v) if not vcvarall is None: if platform.lower() != 'ninja': platform = 'Visual Studio %d Win64' % v break env['VCVARSALL'] = vcvarall else: platform = env['VIP_CMAKE_PLATFORM'] if not args.rebuild: cmake_options = []; cmake_options += ['-G', platform] #HIGHLY recommended for ninja if 'VIP_CMAKE_MAKE_PROGRAM' in env: cmake_options += ['-D', 'CMAKE_MAKE_PROGRAM='+\ env['VIP_CMAKE_MAKE_PROGRAM']] #More or less required for ninja in windows if 'VIP_CMAKE_COMPILER' in env: cmake_options += ['-D', 'CMAKE_C_COMPILER='+env['VIP_CMAKE_COMPILER']] cmake_options += ['-D', 'CMAKE_CXX_COMPILER='+ env['VIP_CMAKE_COMPILER']] cmake_options += ['-D', 'CMAKE_BUILD_TYPE='+env['VIP_VXL_BUILD_TYPE']]; if 'VIP_OPENCL_INCLUDE_PATH' in env: cmake_options += ['-D', 'OPENCL_INCLUDE_PATH='+ env['VIP_OPENCL_INCLUDE_PATH']] if 'VIP_OPENCL_LIBRARY_PATH' in env: cmake_options += ['-D', 'OPENCL_LIBRARY_PATH='+ env['VIP_OPENCL_LIBRARY_PATH']] if 'VIP_OPENCL_NVIDIA_LIBRARY_PATH' in env: cmake_options += ['-D', 'OPENCL_NVIDIA_LIBRARY_PATH='+ env['VIP_OPENCL_NVIDIA_LIBRARY_PATH']] if 'VIP_GLEW_INCLUDE_DIR' in env: cmake_options += ['-D', 'GLEW_INCLUDE_DIR='+env['VIP_GLEW_INCLUDE_DIR']] if 'VIP_GLEW_LIBRARY' in env: cmake_options += ['-D', 'GLEW_LIBRARY='+env['VIP_GLEW_LIBRARY']] if platform=="Eclipse CDT4 - Unix Makefiles": cmake_options += ['-D', 'CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT=True'] cmake_options += ['-D', 'CMAKE_INSTALL_PREFIX='+ path_join(vxlDir, 'install')]; cmake_options += ['-D', 'EXECUTABLE_OUTPUT_PATH='+ path_join(vxlDir, 'bin')]; cmake_options += ['-D', 'PYTHON_INCLUDE_DIR='+ env['VIP_PYTHON_INCLUDE_DIR'], '-D', 'PYTHON_LIBRARY='+ env['VIP_PYTHON_LIBRARY'], '-D', 'PYTHON_INCLUDE_DIR2='+ env['VIP_PYTHON_INCLUDE_DIR'], '-D', 'PYTHON_EXECUTABLE='+ env['VIP_PYTHON_EXECUTABLE']]; tmp = env.pop('VIP_CMAKE_ECLIPSE', None); if tmp: cmake_options += ['-D', 'CMAKE_ECLIPSE_EXECUTABLE='+tmp]; # Pretty open options section. User can in theory, override anything here tmp = env.pop('VIP_VXL_CMAKE_OPTIONS', None); if tmp: cmake_options += literal_eval('[' + tmp + ']'); #Sure, this may be generally unsafe, but only the user administrating the #computer should be able to set and run this, so I choose to trust them #Update. literal_eval should be "safe"...er tmp = env.pop('VIP_VXL_CMAKE_ENTRIES', None); if tmp: tmp = literal_eval('[' + tmp + ']'); for entry in tmp: cmake_options += ['-D', entry]; #Run CMake if os.name=='nt': if platform.lower()=='ninja': args = [ntpath.normpath(os.path.join(env['VIP_INSTALL_DIR'], 'run_vcvarsall.bat'))] pid = subprocess.Popen(args+[env['VIP_CMAKE']] + cmake_options + [env['VIP_VXL_SRC_DIR']]) else: pid = subprocess.Popen([env['VIP_CMAKE']] + cmake_options + [env['VIP_VXL_SRC_DIR']]) else: pid = subprocess.Popen([env['VIP_CMAKE']] + cmake_options + [env['VIP_VXL_SRC_DIR']]) pid.wait() if args.cmake: return #Make it if os.name=='nt': if platform.lower()=='ninja': cmd = [ntpath.normpath(os.path.join(env['VIP_INSTALL_DIR'], 'run_vcvarsall.bat')), env['VIP_CMAKE_NINJA']] else: cmd = [ntpath.normpath(os.path.join(env['VIP_INSTALL_DIR'], 'run_vcvarsall.bat')), 'devenv', 'vxl.sln', '/Build', env['VIP_VXL_BUILD_TYPE']+'^^^|x64'] #The ^^^ is for Stupid batch escape limitation with | Thank you windows! :( if platform.lower() != 'ninja': if args.verbose: pass #No idea right now print "Loading vxl solution... This may take a few minutes." else: cmd = [env['VIP_CMAKE_MAKE_PROGRAM'], '-j', '10'] if args.verbose: if platform.lower() != 'ninja': cmd += ['VERBOSE=1'] if args.verbose: if platform.lower() == 'ninja': cmd += ['-v'] pid = subprocess.Popen(cmd, cwd=vxlDir); pid.wait();
import re from copy import copy from os import mkdir, environ from os.path import dirname, join, realpath, exists, basename from hotqueue import HotQueue from ConfigParser import ConfigParser from time import sleep buildenv = copy(environ) environ.pop("http_proxy", None) import subprocess import requests # reading the configuration config = ConfigParser() config.read(join(dirname(__file__), "config.cfg")) # start the queue qjob = HotQueue( "jobsubmit", host=config.get("hotqueue", "host"), port=config.getint("hotqueue", "port"), db=config.getint("hotqueue", "db"), password=config.get("hotqueue", "password"), ) qlog = HotQueue( "joblog", host=config.get("hotqueue", "host"), port=config.getint("hotqueue", "port"),
def tearDown(self): environ.pop('ACS_LOG_CENTRAL') reload(Log)
def __enter__(self): from os import environ self.orig = environ.pop('PIP_INDEX_URL', None)
def tearDown(self): environ.pop('ACS_LOG_STDOUT') reload(Log)