def test_api_token_authentication(self): # Given yaml_string = textwrap.dedent("""\ authentication: kind: token api_token: ulysse """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual(config.auth, APITokenAuth("ulysse")) # Given yaml_string = textwrap.dedent("""\ authentication: api_token: ulysse """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual(config.auth, APITokenAuth("ulysse"))
def test_files_cache(self): # Given yaml_string = textwrap.dedent("""\ files_cache: "/foo/bar" """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual(config.repository_cache, "/foo/bar") # Given yaml_string = textwrap.dedent("""\ files_cache: "~/foo/bar/{PLATFORM}" """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual( config.repository_cache, os.path.expanduser("~/foo/bar/{0}".format(custom_plat)))
def test_max_retries_setup(self): # When config = Configuration() # Then self.assertEqual(config.max_retries, 0) # Given data = StringIO("max_retries = 1") # When config = Configuration.from_file(data) # Then self.assertEqual(config.max_retries, 1) # Given data = StringIO("max_retries = 0") # When config = Configuration.from_file(data) # Then self.assertEqual(config.max_retries, 0) # Given data = StringIO("max_retries = 'a'") # When/Then with self.assertRaises(InvalidConfiguration): Configuration.from_file(data)
class MockedPrint(object): def __init__(self): self.s = StringIO() def __call__(self, *a): self.s.write(" ".join(str(_) for _ in a) + "\n") @property def value(self): return self.s.getvalue()
class MockedPrint(object): def __init__(self): self.s = StringIO() def __call__(self, *a): self.s.write(" ".join(str(_) for _ in a) + "\n") @property def value(self): return self.s.getvalue()
def test_both_auth_set(self): # Given data = "EPD_auth = '{0}'\napi_token = 'token'" data = StringIO(data.format(FAKE_CREDS)) msg = "Both 'EPD_auth' and 'api_token' set in configuration." \ "\nYou should remove one of those for consistent " \ "behaviour." # When with self.assertWarnsRegex(Warning, msg): Configuration.from_file(data)
def test_both_auth_set(self): # Given data = "EPD_auth = '{0}'\napi_token = 'token'" data = StringIO(data.format(FAKE_CREDS)) msg = "Both 'EPD_auth' and 'api_token' set in configuration." \ "\nYou should remove one of those for consistent " \ "behaviour." # When with self.assertWarnsRegex(Warning, msg): Configuration.from_file(data)
def test_use_epd_username(self): data = "EPD_auth = '{0}'".format(FAKE_CREDS) self.assertFalse(_is_using_epd_username(StringIO(data))) data = "#EPD_auth = '{0}'".format(FAKE_CREDS) self.assertFalse(_is_using_epd_username(StringIO(data))) data = textwrap.dedent("""\ #EPD_auth = '{0}' EPD_username = '******' """).format(FAKE_CREDS, FAKE_USER) self.assertTrue(_is_using_epd_username(StringIO(data)))
def test_from_file_complete_combination2(self): # Given if sys.platform == "win32": r_prefix = "C:\\tmp" else: r_prefix = "/tmp" r_repository_cache = r_prefix fp = StringIO( textwrap.dedent("""\ EPD_auth = "{creds}" repository_cache = {prefix!r} prefix = {prefix!r} use_webservice = False store_url = "http://acme.com" use_pypi = True autoupdate = True noapp = True """.format(creds=FAKE_CREDS, prefix=r_prefix))) # When config = Configuration.from_file(fp) # Then self.assertEqual(config.auth, FAKE_AUTH) self.assertSamePath(config.repository_cache, r_repository_cache) self.assertSamePath(config.prefix, r_prefix) self.assertEqual(config.use_webservice, False) self.assertEqual(config.store_url, "http://acme.com") self.assertEqual(config.use_pypi, True) self.assertEqual(config.autoupdate, True) self.assertEqual(config.noapp, True)
def test_simple(self): # Given yaml_string = textwrap.dedent("""\ store_url: "http://acme.com" repositories: - enthought/free - enthought/commercial """) platform = custom_plat r_indices = tuple( (('http://acme.com/repo/enthought/free/{0}/index.json'.format( platform), 'http://acme.com/repo/enthought/free/{0}/index.json'.format( platform)), ('http://acme.com/repo/enthought/commercial/{0}/index.json'. format(platform), 'http://acme.com/repo/enthought/commercial/{0}/index.json'. format(platform)))) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual(config.store_url, "http://acme.com") self.assertEqual(config.indices, r_indices) self.assertEqual(config.max_retries, 0) self.assertTrue(config.verify_ssl)
def test_epd_auth(self): """ Ensure config auth information is properly set-up when using EPD_auth """ s = StringIO("EPD_auth = '{0}'".format(FAKE_CREDS)) config = Configuration.from_file(s) self.assertEqual(config.auth, FAKE_AUTH)
def test_parse_simple_unsupported_entry(self): # XXX: ideally, we would like something like with self.assertWarns to # check for the warning, but backporting the python 3.3 code to # unittest2 is a bit painful. with mock.patch("enstaller.config.warnings.warn") as m: Configuration.from_file(StringIO("nono = 'le petit robot'")) m.assert_called_with( 'Unsupported configuration setting nono, ignored')
def test_epd_username_wo_keyring(self): """ Ensure config auth correctly reports itself as non configured when using EPD_username but keyring is not available to get password. """ s = StringIO("EPD_username = '******'".format(FAKE_USER)) config = Configuration.from_file(s) self.assertIsNone(config.auth)
def update_index(dir_path, force=False, verbose=False): """ Updates index-depend.txt and index-depend.bz2 in the directory specified. If index-depend.txt already exists, its content (which contains modification time stamps) is used to create the updated file. This can be disabled using the force option. """ txt_path = join(dir_path, 'index-depend.txt') if verbose: print("Updating:", txt_path) if force or not isfile(txt_path): section = {} else: section = parse_index(open(txt_path).read()) # since generating the new data may take a while, we first write to memory # and then write the file afterwards. faux = StringIO() for fn in sorted(os.listdir(dir_path), key=string.lower): if not fn.endswith('.egg'): continue if not is_valid_eggname(fn): print("WARNING: ignoring invalid egg name:", fn) continue path = join(dir_path, fn) if fn in section: spec = parse_data(section[fn], index=True) if spec.get('mtime') == getmtime(path): faux.write('==> %s <==\n' % fn) faux.write(section[fn] + '\n') continue faux.write(index_section(path)) if verbose: sys.stdout.write('.') sys.stdout.flush() if verbose: print() write_txt_bz2(txt_path, faux.getvalue()) faux.close() import enstaller.egg_meta enstaller.egg_meta.update_index(dir_path, force, verbose)
def test_invalid_format(self): # Given yaml_string = textwrap.dedent("""\ repositoriess: - enthought/commercial """) # When/Then with self.assertRaises(InvalidConfiguration): Configuration.from_yaml_filename(StringIO(yaml_string))
def test_epd_username(self): with fake_keyring_context() as mocked_keyring: mocked_keyring.set_password(KEYRING_SERVICE_NAME, FAKE_USER, FAKE_PASSWORD) s = StringIO("EPD_username = '******'".format(FAKE_USER)) config = Configuration.from_file(s) self.assertEqual(config.auth, FAKE_AUTH) self.assertEqual(config.auth._encoded_auth, FAKE_CREDS)
def test_store_kind(self): """ Ensure config auth information is properly set-up when using EPD_auth """ # Given config = Configuration() # When config.update(store_url="http://acme.com") # Then self.assertEqual(config.store_kind, "legacy") self.assertEqual(config.store_url, "http://acme.com") # Given config = Configuration() # When config.update(store_url="brood+http://acme.com") # Then self.assertEqual(config.store_kind, "brood") self.assertEqual(config.store_url, "http://acme.com") # Given s = StringIO("store_url = 'http://acme.com'") # When config = Configuration.from_file(s) # Then self.assertEqual(config.store_kind, "legacy") self.assertEqual(config.store_url, "http://acme.com") # Given s = StringIO("store_url = 'brood+http://acme.com'") # When config = Configuration.from_file(s) # Then self.assertEqual(config.store_kind, "brood") self.assertEqual(config.store_url, "http://acme.com")
def test_default(self): # Given/When config = Configuration.from_yaml_filename(StringIO("")) # Then self.assertFalse(config.use_webservice) self.assertFalse(config.indices, []) self.assertEqual(config.repository_cache, os.path.join(sys.prefix, "LOCAL-REPO")) self.assertEqual(config.store_kind, "brood")
def test_quiet(self, install_req): # Given args = ["foo"] # When with mock.patch("sys.stdout", new=StringIO()) as m: main(args) # Then self.assertNotEqual(m.getvalue(), "") # Given args = ["foo", "--quiet"] # When with mock.patch("sys.stdout", new=StringIO()) as m: main(args) # Then self.assertEqual(m.getvalue(), "")
def test_max_retries(self): # Given yaml_string = textwrap.dedent("""\ max_retries: 1 """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertEqual(config.max_retries, 1)
def test_invalid_syntax(self): # Given data = "store_url = http://acme.com" r_message = "Could not parse configuration file (invalid python " \ "syntax at line 1: expression 'store_url = " \ "http://acme.com')" # When with self.assertRaises(InvalidConfiguration) as e: Configuration.from_file(StringIO(data)) # Then self.assertMultiLineEqual(str(e.exception), r_message)
def test_parse_simple(self): r_data = {"IndexedRepos": ["http://acme.com/{SUBDIR}"], "webservice_entry_point": "http://acme.com/eggs/{PLATFORM}/"} s = textwrap.dedent("""\ IndexedRepos = [ "http://acme.com/{SUBDIR}", ] webservice_entry_point = "http://acme.com/eggs/{PLATFORM}/" """) data = parse_assignments(StringIO(s)) self.assertEqual(data, r_data)
def test_verify_ssl(self): # Given yaml_string = textwrap.dedent("""\ verify_ssl: True """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertTrue(config.verify_ssl) # Given yaml_string = textwrap.dedent("""\ verify_ssl: False """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.verify_ssl)
def test_verify_ssl_setup(self): # When config = Configuration() # Then self.assertTrue(config.verify_ssl) # Given data = StringIO("verify_ssl = True") # When config = Configuration.from_file(data) # Then self.assertTrue(config.verify_ssl) # Given data = StringIO("verify_ssl = False") # When config = Configuration.from_file(data) # Then self.assertFalse(config.verify_ssl)
def test_unsupported_syntax(self): # Given data = textwrap.dedent("""\ store_url = 'http://acme' store_url += '.com' """) r_message = "Could not parse configuration file (error at line 2: " \ "expression \"store_url += '.com'\" not supported)" # When with self.assertRaises(InvalidConfiguration) as e: Configuration.from_file(StringIO(data)) # Then self.assertMultiLineEqual(str(e.exception), r_message)
def test_basic_authentication(self): # Given yaml_string = textwrap.dedent("""\ authentication: kind: basic auth: {0} """.format(UserPasswordAuth("*****@*****.**", "ulysse")._encoded_auth)) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual(config.auth, UserPasswordAuth("*****@*****.**", "ulysse"))
def test_simple_authentication(self): # Given yaml_string = textwrap.dedent("""\ authentication: kind: simple username: [email protected] password: ulysse """) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertFalse(config.use_webservice) self.assertEqual(config.auth, UserPasswordAuth("*****@*****.**", "ulysse"))
def test_api_token(self): # Given config = Configuration() # When config.update(auth=APITokenAuth("dummy token")) # Then self.assertEqual(config.auth, APITokenAuth("dummy token")) # Given data = StringIO("api_token = 'yoyo'") # When config = Configuration.from_file(data) # Then self.assertEqual(config.auth, APITokenAuth("yoyo"))
def test_repositories(self): # Given yaml_string = textwrap.dedent("""\ store_url: "http://www.acme.com" repositories: - "enthought/free" - "file:///foo" """) r_repositories = ( "http://www.acme.com/repo/enthought/free/{0}/".format(custom_plat), "file:///foo/".format(custom_plat), ) # When config = Configuration.from_yaml_filename(StringIO(yaml_string)) # Then self.assertEqual(config.indexed_repositories, r_repositories)
def test_simple(self): if sys.platform == "win32": q = "\"" else: q = "" r_cli_entry_point = """\ #!{q}{executable}{q} # This script was created by egginst when installing: # # dummy.egg # if __name__ == '__main__': import sys from dummy import main_cli sys.exit(main_cli()) """.format(executable=sys.executable, q=q) entry_points = """\ [console_scripts] dummy = dummy:main_cli [gui_scripts] dummy-gui = dummy:main_gui """ s = StringIO(entry_points) config = configparser.ConfigParser() config.readfp(s) with mkdtemp() as d: egginst = EggInst("dummy.egg", d) create(egginst, config) if sys.platform == "win32": entry_point = os.path.join(egginst.bin_dir, "dummy-script.py") else: entry_point = os.path.join(egginst.bin_dir, "dummy") self.assertTrue(os.path.exists(entry_point)) with open(entry_point, "rt") as fp: cli_entry_point = fp.read() self.assertMultiLineEqual(cli_entry_point, r_cli_entry_point)
def test_epd_auth_wo_keyring(self): s = StringIO("EPD_auth = '{0}'".format(FAKE_CREDS)) config = Configuration.from_file(s) self.assertEqual(config.auth, FAKE_AUTH)
def test_parse_simple_unsupported_entry(self): # XXX: ideally, we would like to check for the warning, but doing so is # a bit too painful as it has not been backported to unittest2 Configuration.from_file(StringIO("nono = 'le petit robot'"))
def __init__(self): self.s = StringIO()
def test_simple_windows(self): python_executable = "C:\\Python27\\python.exe" pythonw_executable = "C:\\Python27\\pythonw.exe" r_cli_entry_point = """\ #!"{executable}" # This script was created by egginst when installing: # # dummy.egg # if __name__ == '__main__': import sys from dummy import main_cli sys.exit(main_cli()) """.format(executable=python_executable) r_gui_entry_point = """\ #!"{executable}" # This script was created by egginst when installing: # # dummy.egg # if __name__ == '__main__': import sys from dummy import main_gui sys.exit(main_gui()) """.format(executable=pythonw_executable) entry_points = """\ [console_scripts] dummy = dummy:main_cli [gui_scripts] dummy-gui = dummy:main_gui """ s = StringIO(entry_points) config = configparser.ConfigParser() config.readfp(s) with mock.patch("sys.executable", python_executable): with mkdtemp() as d: egginst = EggInst("dummy.egg", d) create(egginst, config) cli_entry_point_path = os.path.join(egginst.bin_dir, "dummy-script.py") gui_entry_point_path = os.path.join(egginst.bin_dir, "dummy-gui-script.pyw") entry_points = [ os.path.join(egginst.bin_dir, "dummy.exe"), os.path.join(egginst.bin_dir, "dummy-gui.exe"), cli_entry_point_path, gui_entry_point_path, ] for entry_point in entry_points: self.assertTrue(os.path.exists(entry_point)) with open(cli_entry_point_path, "rt") as fp: cli_entry_point = fp.read() self.assertMultiLineEqual(cli_entry_point, r_cli_entry_point) with open(gui_entry_point_path, "rt") as fp: gui_entry_point = fp.read() self.assertMultiLineEqual(gui_entry_point, r_gui_entry_point) self.assertEqual(compute_md5(os.path.join(egginst.bin_dir, "dummy.exe")), hashlib.md5(exe_data.cli).hexdigest()) self.assertEqual(compute_md5(os.path.join(egginst.bin_dir, "dummy-gui.exe")), hashlib.md5(exe_data.gui).hexdigest())