def test_keymanager_keys_file(): key_manager = _make_sample_cgap_key_manager() original_file = key_manager.keys_file assert isinstance(original_file, str) assert key_manager.keys_file == original_file with override_environ(CGAP_KEYS_FILE=None): assert os.environ.get('CGAP_KEYS_FILE') is None assert key_manager.keys_file == original_file assert key_manager.keys_file == original_file with override_environ(CGAP_KEYS_FILE=""): assert os.environ.get('CGAP_KEYS_FILE') == "" assert key_manager.keys_file == original_file assert key_manager.keys_file == original_file alternate_file = 'some-other-file' with override_environ(CGAP_KEYS_FILE=alternate_file): assert os.environ.get('CGAP_KEYS_FILE') == alternate_file key_manager = CGAPKeyManager() assert key_manager.keys_file == alternate_file key_manager = _make_sample_cgap_key_manager() assert key_manager.keys_file == original_file
def test_import_fails_without_initialization(): # Loading this library fails if proper env variables were not set up. # TODO: I'm not sure I think that's a good idea. Functions should fail, imports should not. -kmp 14-Aug-2020 with override_environ(FF_ACCESS_KEY=None): with pytest.raises(Exception) as exec_info: from dcicutils import jh_utils # NOQA assert 'ERROR USING JUPYTERHUB_UTILS!' in str(exec_info.value) with override_environ(FF_ACCESS_SECRET=None): with pytest.raises(Exception) as exec_info: from dcicutils import jh_utils # NOQA assert 'ERROR USING JUPYTERHUB_UTILS!' in str(exec_info.value)
def test_fourfront_keymanager_creation(): sample_ff_key_manager_1 = FourfrontKeyManager() assert sample_ff_key_manager_1.keys_file == FourfrontKeyManager._default_keys_file( ) sample_ff_key_manager_2 = _make_sample_fourfront_key_manager() assert sample_ff_key_manager_2.keys_file == SAMPLE_FOURFRONT_KEYS_FILE with override_environ(FF_DEFAULT_ENV=SAMPLE_FOURFRONT_LOCAL_PSEUDOENV): sample_ff_key_manager_3 = FourfrontKeyManager() assert sample_ff_key_manager_3.keys_file == FourfrontKeyManager._default_keys_file( ) # Make sure class default is different than test value. More of a test-integrity test than an absolute need. assert sample_ff_key_manager_3.keys_file != SAMPLE_FOURFRONT_KEYS_FILE other_keys_file = "other-ff-keys.json" class MyFourfrontKeyManager(FourfrontKeyManager): KEYS_FILE = other_keys_file sample_ff_key_manager_4 = MyFourfrontKeyManager( ) # Tests that no error is raised assert sample_ff_key_manager_4.keys_file == other_keys_file
def test_s3utils_s3_put_secret(): util = s3Utils(env='fourfront-mastertest') standard_algorithm = "AES256" environmental_key = 'environmental-key' with override_environ(S3_ENCRYPT_KEY=environmental_key): with mock.patch.object(util.s3, "put_object") as mock_put_object: def mocked_put_object(**kwargs): return kwargs mock_put_object.side_effect = mocked_put_object item = {'a': 1, 'b': 2} some_key = 'some-key' some_secret = 'some-secret' assert util.s3_put_secret(item, keyname=some_key) == { "Body": item, "Bucket": util.sys_bucket, "Key": some_key, "SSECustomerKey": environmental_key, "SSECustomerAlgorithm": standard_algorithm, } some_bucket = 'some-bucket' assert util.s3_put_secret(item, keyname=some_key, bucket=some_bucket) == { "Body": item, "Bucket": some_bucket, "Key": some_key, "SSECustomerKey": environmental_key, "SSECustomerAlgorithm": standard_algorithm, } assert util.s3_put_secret(item, keyname=some_key, secret=some_secret) == { "Body": item, "Bucket": util.sys_bucket, "Key": some_key, "SSECustomerKey": some_secret, "SSECustomerAlgorithm": standard_algorithm, }
def test_it(args_in, expect_exit_code, expect_called, expect_call_args=None): with override_environ(CGAP_KEYS_FILE=keyfile): with mock.patch.object( submit_genelist_module, "submit_any_ingestion") as mock_submit_any_ingestion: try: # Outside of the call, we will always see the default filename for cgap keys # but inside the call, because of a decorator, the default might be different. # See additional test below. assert KeyManager.keydicts_filename( ) == KeyManager.DEFAULT_KEYDICTS_FILENAME def mocked_submit_genelist(*args, **kwargs): ignored(args, kwargs) # We don't need to test this function's actions because we test its call args below. # However, we do need to run this one test from the same dynamic context, # so this is close enough. assert KeyManager.keydicts_filename() == ( keyfile or KeyManager.DEFAULT_KEYDICTS_FILENAME) mock_submit_any_ingestion.side_effect = mocked_submit_genelist submit_genelist_main(args_in) mock_submit_any_ingestion.assert_called_with( **expect_call_args) except SystemExit as e: assert e.code == expect_exit_code assert mock_submit_any_ingestion.call_count == ( 1 if expect_called else 0)
def test_cgap_keymanager_creation(): sample_cgap_key_manager_1 = CGAPKeyManager() assert sample_cgap_key_manager_1.keys_file == CGAPKeyManager._default_keys_file( ) sample_cgap_key_manager_2 = _make_sample_cgap_key_manager() assert sample_cgap_key_manager_2.keys_file == SAMPLE_CGAP_KEYS_FILE with override_environ(CGAP_KEYS_FILE=SAMPLE_CGAP_KEYS_FILE): sample_cgap_key_manager_3 = CGAPKeyManager() assert sample_cgap_key_manager_3.keys_file == SAMPLE_CGAP_KEYS_FILE # Make sure class default is different than test value. More of a test-integrity test than an absolute need. assert sample_cgap_key_manager_3.keys_file != CGAPKeyManager._default_keys_file( ) other_keys_file = "other-cgap-keys.json" class MyCGAPKeyManager(CGAPKeyManager): KEYS_FILE = other_keys_file sample_cgap_key_manager_4 = MyCGAPKeyManager( ) # Tests that no error is raised assert sample_cgap_key_manager_4.keys_file == other_keys_file
def default_env_for_testing(default_env): with override_environ( **{base_module.DEFAULT_ENV_VAR: default_env}): # step 1 of 2 with mock.patch.object( base_module, "DEFAULT_ENV", # step 2 of 2 base_module._compute_default_env() ): # noqa - need private function for testing yield
def build_production_ini_from_global_application_configuration(): """ This function makes a request to secrets manager for the identity passed to the container. See documentation on API in dcicutils. """ identity = assume_identity() # build production.ini with override_environ(**identity): CGAPDockerIniFileManager.build_ini_file_from_template( '/home/nginx/cgap-portal/deploy/ini_files/cgap_any_alpha.ini', '/home/nginx/cgap-portal/production.ini')
def test_keymanager(): original_file = KeyManager.keydicts_filename() assert isinstance(original_file, str) with KeyManager.alternate_keydicts_filename(None): assert KeyManager.keydicts_filename() == original_file assert KeyManager.keydicts_filename() == original_file with override_environ(CGAP_KEYS_FILE=None): assert os.environ.get('CGAP_KEYS_FILE') is None with KeyManager.alternate_keydicts_filename_from_environ(): assert KeyManager.keydicts_filename() == original_file assert KeyManager.keydicts_filename() == original_file assert KeyManager.keydicts_filename() == original_file with override_environ(CGAP_KEYS_FILE=""): assert os.environ.get('CGAP_KEYS_FILE') == "" with KeyManager.alternate_keydicts_filename_from_environ(): assert KeyManager.keydicts_filename() == original_file assert KeyManager.keydicts_filename() == original_file alternate_file = 'some-other-file' with KeyManager.alternate_keydicts_filename(alternate_file): assert KeyManager.keydicts_filename() == alternate_file assert KeyManager.keydicts_filename() == original_file with override_environ(CGAP_KEYS_FILE=alternate_file): assert os.environ.get('CGAP_KEYS_FILE') == alternate_file with KeyManager.alternate_keydicts_filename_from_environ(): assert KeyManager.keydicts_filename() == alternate_file assert KeyManager.keydicts_filename() == original_file assert KeyManager.keydicts_filename() == original_file
def test_post_ingestion_submission_wrong_project(anontestapp, institution, bgm_user, bgm_project, bgm_access_key, non_bgm_user, non_bgm_project, non_bgm_access_key): with override_environ(REMOTE_USER=None): creation_post_data = { "ingestion_type": "metadata_bundle", "institution": institution['name'], "project": non_bgm_project['name'], "processing_status": { "state": "submitted" } } keypair = (bgm_access_key['access_key_id'], bgm_access_key['secret_access_key']) creation_post_headers = { 'Content-type': 'application/json', 'Accept': 'application/json', 'Authorization': basic_auth(*keypair), } def dbg(label, x, *props): if not props: print("%s: %s" % (label, json.dumps(x, indent=2, default=str))) else: for prop in props: print( "%s[%r]: %s" % (label, prop, json.dumps( x.get(prop, "<MISSING>"), indent=2, default=str))) dbg("bgm_user", bgm_user, '@id', 'user_institution', 'project_roles') dbg("non_bgm_user", non_bgm_user, '@id', 'user_institution', 'project_roles') dbg("bgm_project", bgm_project, '@id', 'uuid', 'name') dbg("non_bgm_project", non_bgm_project, '@id', 'uuid', 'name') dbg("bgm_access_key", bgm_access_key, 'access_key_id', 'secret_access_key') dbg("non_bgm_access_key", non_bgm_access_key, 'access_key_id', 'secret_access_key') dbg("post data", creation_post_data) dbg("post headers", creation_post_headers) print("posting /IngestionSubmission, expecting 403, with keypair", keypair) response = anontestapp.post_json("/IngestionSubmission", creation_post_data, headers=creation_post_headers, status=403) ignorable(response)
def test_s3_utils_environment_variable_use(): with pytest.raises(SynonymousEnvironmentVariablesMismatched): with override_environ(GLOBAL_BUCKET_ENV='should-be-unused', GLOBAL_ENV_BUCKET='inconsistently-unused'): # If we do the simple-minded version of this, the environment variable doesn't matter s3Utils(sys_bucket='foo') with pytest.raises(SynonymousEnvironmentVariablesMismatched): # If we don't initialize the sys_bucket, we have to go through the smart protocols # and expect environment variables to be in order. s3Utils()
def test_env_manager_global_env_bucket_name(): # These tests expect to be run in an environment that does not have these buckets bound globally. assert os.environ.get('GLOBAL_ENV_BUCKET') is None assert os.environ.get('GLOBAL_BUCKET_ENV') is None with EnvManager.global_env_bucket_named(name='foo'): assert os.environ.get('GLOBAL_ENV_BUCKET') == 'foo' assert os.environ.get('GLOBAL_BUCKET_ENV') == 'foo' assert EnvManager.global_env_bucket_name() == 'foo' with override_environ(GLOBAL_BUCKET_ENV='bar'): assert os.environ.get('GLOBAL_ENV_BUCKET') == 'foo' assert os.environ.get('GLOBAL_BUCKET_ENV') == 'bar' with pytest.raises(SynonymousEnvironmentVariablesMismatched): EnvManager.global_env_bucket_name() with override_environ(GLOBAL_ENV_BUCKET='bar'): assert os.environ.get('GLOBAL_ENV_BUCKET') == 'bar' assert os.environ.get('GLOBAL_BUCKET_ENV') == 'bar' assert EnvManager.global_env_bucket_name() == 'bar' with override_environ(GLOBAL_ENV_BUCKET='bar'): assert os.environ.get('GLOBAL_ENV_BUCKET') == 'bar' assert os.environ.get('GLOBAL_BUCKET_ENV') == 'foo' with pytest.raises(SynonymousEnvironmentVariablesMismatched): EnvManager.global_env_bucket_name() with override_environ(GLOBAL_BUCKET_ENV='bar'): assert os.environ.get('GLOBAL_ENV_BUCKET') == 'bar' assert os.environ.get('GLOBAL_BUCKET_ENV') == 'bar' assert EnvManager.global_env_bucket_name() == 'bar'
def test_it(args_in, expect_exit_code, expect_called, expect_call_args=None): with override_environ(CGAP_KEYS_FILE=keyfile): with mock.patch.object( upload_item_data_module, "upload_item_data") as mock_upload_item_data: with mock.patch.object( submission_module, "get_health_page") as mock_get_health_page: mock_get_health_page.return_value = { HealthPageKey.S3_ENCRYPT_KEY_ID: mocked_s3_encrypt_key_id } with system_exit_expected(exit_code=expect_exit_code): # Outside of the call, we will always see the default filename for cgap keys # but inside the call, because of a decorator, the default might be different. # See additional test below. assert KeyManager.keydicts_filename( ) == KeyManager.DEFAULT_KEYDICTS_FILENAME def mocked_upload_item_data(*args, **kwargs): ignored(args, kwargs) # We don't need to test this function's actions because we test its call args below. # However, we do need to run this one test from the same dynamic context, # so this is close enough. if KeyManager.keydicts_filename() == ( keyfile or KeyManager.DEFAULT_KEYDICTS_FILENAME): exit(0) else: # This case is not expected to be reached but must be here for testing to catch exit(1) # pragma: no cover mock_upload_item_data.side_effect = mocked_upload_item_data upload_item_data_main(args_in) raise AssertionError( "upload_item_data_main should not exit normally." ) # pragma: no cover assert mock_upload_item_data.call_count == ( 1 if expect_called else 0)
def build_ini_file(environment, use_prod): """ Wrapper method for main functionality that can be invoked directly by others. :param environment: environment to simulate :param use_prod: an extra value that must be true to simulate staging/production :returns: True if successful, False otherwise """ if is_stg_or_prd_env(environment) and not use_prod: raise Exception( 'Tried to run on production env %s without prod identifier!' % environment) beanstalk_env = get_beanstalk_environment_variables(environment) template_file_name = ProductionIniFileManager.environment_template_filename( environment) with override_environ(**beanstalk_env): ProductionIniFileManager.build_ini_file_from_template( template_file_name, 'production.ini') return True
def test_it(args_in, expect_exit_code, expect_called, expect_call_args=None): output = [] with override_environ(CGAP_KEYS_FILE=keyfile): with mock.patch.object(show_upload_info_module, "print") as mock_print: mock_print.side_effect = lambda *args: output.append(" ".join( args)) with mock.patch.object( show_upload_info_module, "show_upload_info") as mock_show_upload_info: try: # Outside of the call, we will always see the default filename for cgap keys # but inside the call, because of a decorator, the default might be different. # See additional test below. assert KeyManager.keydicts_filename( ) == KeyManager.DEFAULT_KEYDICTS_FILENAME def mocked_show_upload_info(*args, **kwargs): ignored(args, kwargs) # We don't need to test this function's actions because we test its call args below. # However, we do need to run this one test from the same dynamic context, # so this is close enough. assert KeyManager.keydicts_filename() == ( keyfile or KeyManager.DEFAULT_KEYDICTS_FILENAME) mock_show_upload_info.side_effect = mocked_show_upload_info show_upload_info_main(args_in) raise AssertionError( "show_upload_info_main should not exit normally." ) # pragma: no cover except SystemExit as e: assert e.code == expect_exit_code assert mock_show_upload_info.call_count == ( 1 if expect_called else 0) assert output == []
def test_s3_utils_legacy_behavior(): # From https://hms-dbmi.atlassian.net/browse/C4-674 outfile_bucket = 'my-outfile-bucket' sys_bucket = 'my-system-bucket' raw_file_bucket = 'my-raw_file-bucket' def test_it(): # As long as sys_bucket= is given in the s3Utils() call, it will just fill the slots # with given values and won't try to do anything smart. s = s3Utils(outfile_bucket, sys_bucket, raw_file_bucket) assert s.outfile_bucket == outfile_bucket assert s.sys_bucket == sys_bucket assert s.raw_file_bucket == raw_file_bucket assert s.blob_bucket is None assert s.metadata_bucket is None assert s.tibanna_cwls_bucket is None assert s.tibanna_output_bucket is None s = s3Utils(sys_bucket=sys_bucket) assert s.outfile_bucket is None assert s.sys_bucket == sys_bucket assert s.raw_file_bucket is None assert s.blob_bucket is None assert s.metadata_bucket is None assert s.tibanna_cwls_bucket is None assert s.tibanna_output_bucket is None test_it() # Test that certain legacy behavior is unperturbed by GLOBAL_ENV_BUCKET (or its older name, GLOBAL_BUCKET_ENV) with override_environ(GLOBAL_BUCKET_ENV='should-be-unused', GLOBAL_ENV_BUCKET='should-be-unused'): test_it()
def test_transitional_equivalence(): """ We used to use separate files for each environment. This tests that the new any.ini technology, with a few new environment variables, will produce the same thing. This proves that if we set at least "ENCODED_ES_SERVER" and "ENCODED_BS_ENV" environment variables, or invoke generate_ini_file adding the "--es_server" nad "--bs_env" arguments, we should get a proper production.ini. """ # TODO: Once this mechanism is in place, the files cgap.ini, cgapdev.ini, cgaptest.ini, and cgapwolf.ini # can either be removed (and these transitional tests removed) or transitioned to be test data. def tester(ref_ini, bs_env, data_set, es_server, es_namespace=None, line_checker=None): print("tester entered.") print(" ref_ini=", ref_ini) print(" bs_env=", bs_env) print(" data_set=", data_set) print(" es_server=", es_server) print(" es_namespace=", es_namespace) print(" line_checker=", line_checker) assert ref_ini[:-4] == bs_env[ 10:] # "xxx.ini" needs to match "fourfront-xxx" es_namespace = es_namespace or bs_env # Test of build_ini_from_template with just 2 keyword arguments explicitly supplied (bs_env, es_server), # and others defaulted. old_output = StringIO() new_output = StringIO() build_ini_stream_from_template(os.path.join(TEMPLATE_DIR, ref_ini), old_output, bs_env=bs_env, es_server=es_server) build_ini_stream_from_template( os.path.join(TEMPLATE_DIR, "any.ini"), new_output, # data_env and es_namespace are something we should be able to default bs_env=bs_env, es_server=es_server) old_content = old_output.getvalue() new_content = new_output.getvalue() assert old_content == new_content # Test of build_ini_from_template with all 4 keyword arguments explicitly supplied (bs_env, data_set, # es_server, es_namespace), none defaulted. old_output = StringIO() new_output = StringIO() build_ini_stream_from_template(os.path.join(TEMPLATE_DIR, ref_ini), old_output, bs_env=bs_env, data_set=data_set, es_server=es_server, es_namespace=es_namespace) build_ini_stream_from_template(os.path.join(TEMPLATE_DIR, "any.ini"), new_output, bs_env=bs_env, data_set=data_set, es_server=es_server, es_namespace=es_namespace) old_content = old_output.getvalue() new_content = new_output.getvalue() assert old_content == new_content problems = [] if line_checker: for raw_line in io.StringIO(new_content): line = raw_line.rstrip() problem = line_checker.check(line) if problem: problems.append(problem) line_checker.check_finally() assert problems == [], "Problems found:\n%s" % "\n".join(problems) print("tester succeeded.") with mock.patch.object(ProductionIniFileManager, "get_app_version", return_value=MOCKED_PROJECT_VERSION): with mock.patch("toml.load", return_value={ "tool": { "poetry": { "version": MOCKED_LOCAL_GIT_VERSION } } }): class Checker: def __init__(self, expect_indexer: typing.Optional[str] = "true"): self.indexer = None self.expect_indexer = expect_indexer def check_any(self, line): if line.startswith('indexer ='): print("saw indexer line:", repr(line)) self.indexer = line.split('=')[1].strip() def check(self, line): self.check_any(line) def check_finally(self): assert self.indexer == self.expect_indexer, ( "Expected 'indexer = %s' but value seen was %r." % (self.expect_indexer, self.indexer)) class ProdChecker(Checker): def check(self, line): if 'bucket =' in line: fragment = 'fourfront-cgap' if fragment not in line: return "'%s' missing in '%s'" % (fragment, line) self.check_any(line) with override_environ( ENCODED_INDEXER=None ): # Make sure any global settings are masked. bs_env = "fourfront-cgap" data_set = data_set_for_env(bs_env) tester( ref_ini="cgap.ini", bs_env=bs_env, data_set=data_set, es_server= "search-fourfront-cgap-ewf7r7u2nq3xkgyozdhns4bkni.us-east-1.es.amazonaws.com:80", line_checker=ProdChecker()) bs_env = "fourfront-cgapdev" data_set = data_set_for_env(bs_env) tester( ref_ini="cgapdev.ini", bs_env=bs_env, data_set=data_set, es_server= "search-fourfront-cgapdev-gnv2sgdngkjbcemdadmaoxcsae.us-east-1.es.amazonaws.com:80", line_checker=Checker()) bs_env = "fourfront-cgaptest" data_set = data_set_for_env(bs_env) tester( ref_ini="cgaptest.ini", bs_env=bs_env, data_set=data_set, es_server= "search-fourfront-cgaptest-dxiczz2zv7f3nshshvevcvmpmy.us-east-1.es.amazonaws.com:80", line_checker=Checker()) bs_env = "fourfront-cgapwolf" data_set = data_set_for_env(bs_env) tester( ref_ini="cgapwolf.ini", bs_env=bs_env, data_set=data_set, es_server= "search-fourfront-cgapwolf-r5kkbokabymtguuwjzspt2kiqa.us-east-1.es.amazonaws.com:80", line_checker=Checker()) with override_environ(ENCODED_INDEXER=""): tester( ref_ini="cgap.ini", bs_env="fourfront-cgap", data_set="prod", es_server= "search-fourfront-cgap-ewf7r7u2nq3xkgyozdhns4bkni.us-east-1.es.amazonaws.com:80", line_checker=ProdChecker()) with override_environ(ENCODED_INDEXER="TRUE"): tester( ref_ini="cgap.ini", bs_env="fourfront-cgap", data_set="prod", es_server= "search-fourfront-cgap-ewf7r7u2nq3xkgyozdhns4bkni.us-east-1.es.amazonaws.com:80", line_checker=ProdChecker()) with override_environ(ENCODED_INDEXER="FALSE"): tester( ref_ini="cgap.ini", bs_env="fourfront-cgap", data_set="prod", es_server= "search-fourfront-cgap-ewf7r7u2nq3xkgyozdhns4bkni.us-east-1.es.amazonaws.com:80", line_checker=ProdChecker(expect_indexer=None))
def test_build_ini_file_from_template(): # NOTE: This implicitly also tests build_ini_file_from_stream. some_template_file_name = "mydir/whatever" some_ini_file_name = "mydir/production.ini" env_vars = dict(RDS_DB_NAME='snow_white', RDS_USERNAME='******', RDS_PASSWORD='******', RDS_HOSTNAME='unittest', RDS_PORT="6543") with override_environ(**env_vars): for env_var in env_vars: assert env_var in os.environ and os.environ[env_var] == env_vars[ env_var], ("os.environ[%r] did not get added correctly" % env_var) class MockFileStream: FILE_SYSTEM = {} @classmethod def reset(cls): cls.FILE_SYSTEM = {} def __init__(self, filename, mode): assert 'w' in mode self.filename = filename self.output_string_stream = StringIO() def __enter__(self): return self.output_string_stream def __exit__(self, type, value, traceback): self.FILE_SYSTEM[ self.filename] = self.output_string_stream.getvalue( ).strip().split('\n') def mocked_open(filename, mode='r', encoding=None): assert encoding in (None, 'utf-8') # In this test there are two opens, one for read and one for write, so we discriminate on that basis. print("Enter mock_open", filename, mode) if mode == 'r': if filename == EB_MANIFEST_FILENAME: print("reading mocked EB MANIFEST:", EB_MANIFEST_FILENAME) return StringIO( '{"Some": "Stuff", "VersionLabel": "%s", "Other": "Stuff"}\n' % MOCKED_BUNDLE_VERSION) elif filename == some_template_file_name: print("reading mocked TEMPLATE FILE", some_ini_file_name) return StringIO( '[Foo]\n' 'DATABASE = "${RDS_DB_NAME}"\n' 'SOME_URL = "http://${RDS_USERNAME}@$RDS_HOSTNAME:$RDS_PORT/"\n' 'OOPS = "$NOT_AN_ENV_VAR"\n' 'HMMM = "${NOT_AN_ENV_VAR_EITHER}"\n' 'SHHH = "$RDS_PASSWORD"\n' 'VERSION = "${APP_VERSION}"\n' 'PROJECT_VERSION = "${PROJECT_VERSION}"\n') elif filename == PYPROJECT_FILE_NAME: print("reading mocked TOML FILE", PYPROJECT_FILE_NAME) return StringIO('[something]\n' 'version = "5.6.7"\n' '[tool.poetry]\n' 'author = "somebody"\n' 'version = "%s"\n' % MOCKED_PROJECT_VERSION) else: raise AssertionError("mocked_open(%r, %r) unsupported." % (filename, mode)) else: assert mode == 'w' assert filename == some_ini_file_name return MockFileStream(filename, mode) with mock.patch("subprocess.check_output") as mock_check_output: mock_check_output.side_effect = make_mocked_check_output_for_get_version( ) with mock.patch("os.path.exists") as mock_exists: def mocked_exists(filename): return filename in [ EB_MANIFEST_FILENAME, some_template_file_name ] mock_exists.side_effect = mocked_exists with mock.patch("io.open", side_effect=mocked_open): build_ini_file_from_template(some_template_file_name, some_ini_file_name) assert MockFileStream.FILE_SYSTEM[some_ini_file_name] == [ '[Foo]', 'DATABASE = "snow_white"', 'SOME_URL = "http://user@unittest:6543/"', 'OOPS = "$NOT_AN_ENV_VAR"', 'HMMM = "${NOT_AN_ENV_VAR_EITHER}"', 'SHHH = "my-secret"', 'VERSION = "%s"' % MOCKED_BUNDLE_VERSION, 'PROJECT_VERSION = "%s"' % MOCKED_PROJECT_VERSION, ] MockFileStream.reset() with mock.patch("subprocess.check_output") as mock_check_output: mock_check_output.side_effect = make_mocked_check_output_for_get_version( ) with mock.patch("os.path.exists") as mock_exists: def mocked_exists(filename): # Important to this test: This will return False for EB_MANIFEST_FILENAME, # causing the strategy of using the version there to fall through, # so we expect to try using the git version instead. return filename in [some_template_file_name] mock_exists.side_effect = mocked_exists with mock.patch("io.open", side_effect=mocked_open): build_ini_file_from_template(some_template_file_name, some_ini_file_name) assert MockFileStream.FILE_SYSTEM[some_ini_file_name] == [ '[Foo]', 'DATABASE = "snow_white"', 'SOME_URL = "http://user@unittest:6543/"', 'OOPS = "$NOT_AN_ENV_VAR"', 'HMMM = "${NOT_AN_ENV_VAR_EITHER}"', 'SHHH = "my-secret"', 'VERSION = "%s"' % MOCKED_LOCAL_GIT_VERSION, 'PROJECT_VERSION = "%s"' % MOCKED_PROJECT_VERSION, ] MockFileStream.reset() with mock.patch("subprocess.check_output") as mock_check_output: mock_check_output.side_effect = make_mocked_check_output_for_get_version( simulate_git_command=False) with mock.patch("os.path.exists") as mock_exists: def mocked_exists(filename): # Important to this test: This will return False for EB_MANIFEST_FILENAME, # causing the strategy of using the version there to fall through, # so we expect to try using the git version instead, which will also fail # because we're simulating the absence of Git. return filename in [some_template_file_name] mock_exists.side_effect = mocked_exists class MockDateTime: DATETIME = datetime.datetime @classmethod def now(cls): return cls.DATETIME(2001, 2, 3, 4, 55, 6) with mock.patch("io.open", side_effect=mocked_open): with mock.patch.object(datetime, "datetime", MockDateTime()): build_ini_file_from_template(some_template_file_name, some_ini_file_name) assert MockFileStream.FILE_SYSTEM[some_ini_file_name] == [ '[Foo]', 'DATABASE = "snow_white"', 'SOME_URL = "http://user@unittest:6543/"', 'OOPS = "$NOT_AN_ENV_VAR"', 'HMMM = "${NOT_AN_ENV_VAR_EITHER}"', 'SHHH = "my-secret"', 'VERSION = "unknown-version-at-20010203045506000000"', # We mocked datetime.datetime.now() to get this 'PROJECT_VERSION = "%s"' % MOCKED_PROJECT_VERSION, ] MockFileStream.reset()
def test_c4_383_regression_action(): """ Check that bug C4-383 is really fixed. This bug involves resume_uploads not merging the uploaded file against the current directory when no bundle_filename or upload_folder is given. The present behavior is to merge against the parent directory. """ output = [] with override_environ(CGAP_KEYS_FILE=None): with mock.patch.object(resume_uploads_module, "print") as mock_print: mock_print.side_effect = lambda *args: output.append(" ".join(args) ) # This is the directory we expect the uploaded file to get merged against. # We want to really run the code logic to make sure it does this, # so we have to mock out all the effects. current_dir = "/my/cur/dir" with mock.patch.object(os.path, "curdir", current_dir): with mock.patch.object(submission_module, "yes_or_no", return_value=True): with mock.patch.object( submission_module, "upload_file_to_uuid") as mock_upload_file_to_uuid: with mock.patch("requests.get") as mock_requests_get: def mocked_requests_get(url, *args, **kwargs): ignored(args, kwargs) assert "ingestion-submissions" in url return MockResponse( 200, json=INGESTION_FRAGMENT_WITH_UPLOAD_INFO) mock_requests_get.side_effect = mocked_requests_get local_server = "http://localhost:8000" fake_keydict = { 'key': 'my-key', 'secret': 'my-secret', 'server': local_server, } with mock.patch.object(submission_module, "get_keydict_for_server", return_value=fake_keydict): try: # Outside of the call, we will always see the default filename for cgap keys # but inside the call, because of a decorator, the default might be different. # See additional test below. assert KeyManager.keydicts_filename( ) == KeyManager.DEFAULT_KEYDICTS_FILENAME resume_uploads_main([ "2eab76cd-666c-4b04-9335-22f9c6084303", '--server', local_server ]) except SystemExit as e: assert e.code == 0 joined_filename = os.path.join( current_dir, SAMPLE_UPLOAD_INFO[-1]['filename']) # Make sure this is dong what we expect. assert current_dir + "/" in joined_filename # Make sure the inner upload actually uploads to the current dir. mock_upload_file_to_uuid.assert_called_with( auth=fake_keydict, filename=joined_filename, uuid=SAMPLE_UPLOAD_INFO[-1]['uuid']) assert output == []