def test_InstallerContext_os_version_and_name(): from xylem.installers import InstallerContext, TYPE_CODENAME, TYPE_VERSION context = InstallerContext() context.set_verbose(True) os_name, os_version = context.get_os_name_and_version() assert os_name is not None assert os_version is not None val = ("fakeos", "blah") context.set_os_override(*val) assert val == context.get_os_name_and_version() from mock import Mock from .os_detect import OsDetect os_detect_mock = Mock(spec=OsDetect) os_detect_mock.get_name.return_value = 'fakeos' os_detect_mock.get_version.return_value = 'fakeos-version' os_detect_mock.get_codename.return_value = 'fakeos-codename' context = InstallerContext(os_detect_mock) context.set_os_version_type('fakeos', TYPE_CODENAME) os_name, os_version = context.get_os_name_and_version() assert os_name == 'fakeos', os_name assert os_version == 'fakeos-codename', os_version context.set_os_version_type('fakeos', TYPE_VERSION) os_name, os_version = context.get_os_name_and_version() assert os_name == 'fakeos', os_name assert os_version == 'fakeos-version', os_version
def main(args=None): args = command_handle_args(args, definition) config = get_config() try: ic = InstallerContext(config=config) default_installer_name = ic.get_default_installer_name() results, errors = resolve(args.xylem_key, all_keys=args.all, config=config, installer_context=ic) if errors: error("\n".join(indent(exc_to_str(e), 2, exclude_first=True) for _, e in errors)) for key, (installer_name, resolutions) in results: if installer_name != default_installer_name or \ args.show_default_installer: installer_string = "{0}: ".format(installer_name) else: installer_string = "" resolution_string = ', '.join(map(to_str, resolutions)) info("{0} --> {1}{2}". format(ansi("cyanf") + key + ansi("reset"), ansi("bluef") + installer_string, ansi("yellowf") + resolution_string)) if errors: sys.exit(1) except (KeyboardInterrupt, EOFError): info('') sys.exit(1)
def test_setup_installers(self): config = get_default_config() config.os_override = ("ubuntu", "precise") ic = InstallerContext(config=config) assert (ic.get_default_installer_name() == 'apt') assert (ic.lookup_installer( ic.get_default_installer_name()).name == 'apt') assert (ic.core_installers == [ic.lookup_installer("apt")])
def test_InstallerContext_ctor(): from xylem.installers import InstallerContext from .os_detect import OsDetect context = InstallerContext() assert context.get_os_detect() is not None assert isinstance(context.get_os_detect(), OsDetect) detect = OsDetect() context = InstallerContext(detect) assert context.get_os_detect() == detect assert [] == context.get_installer_keys() assert [] == context.get_os_keys() context.verbose = True assert context.get_os_detect() == detect assert [] == context.get_installer_keys() assert [] == context.get_os_keys()
def test_InstallerContext_get_os_version_type(): from .os_detect import OS_UBUNTU from xylem.installers import InstallerContext, TYPE_CODENAME, TYPE_VERSION context = InstallerContext() try: context.set_os_version_type(OS_UBUNTU, 'bad') assert False, "should check type" except ValueError: pass assert TYPE_VERSION == context.get_os_version_type(OS_UBUNTU) context.set_os_version_type(OS_UBUNTU, TYPE_CODENAME) assert TYPE_CODENAME == context.get_os_version_type(OS_UBUNTU)
def main(args=None): args = command_handle_args(args, definition) config = get_config() try: # TODO: handle multiple keys in one go ic = InstallerContext(config=config) for key in args.xylem_key: result = lookup(key, compact=True, config=config, installer_context=ic) info("Rules for '{}' on '{}':\n{}".format( ansi('cyanf') + key + ansi('reset'), ansi('cyanf') + ic.get_os_string() + ansi('reset'), ansi('yellowf') + dump_yaml(result)[:-1])) except (KeyboardInterrupt, EOFError): # Note: @William why EOFError here? info('') sys.exit(1)
def lookup(xylem_key, compact=False, config=None, sources_context=None, installer_context=None): if config is None: config = get_config() sources_context = sources_context or SourcesContext(config) ic = installer_context or InstallerContext(config) database = RulesDatabase(sources_context) database.load_from_cache() installer_dict = database.lookup(xylem_key, ic) if compact: default_installer_name = ic.get_default_installer_name() compacted = compact_installer_dict(installer_dict, default_installer_name) return compacted
def test_InstallerContext_os_installers(): from xylem.installers import InstallerContext, Installer from .os_detect import OsDetect detect = OsDetect() context = InstallerContext(detect) context.verbose = True os_key = 'ubuntu' try: context.get_os_installer_keys(os_key) assert False, "should have raised" except KeyError: pass try: context.get_default_os_installer_key(os_key) assert False, "should have raised" except KeyError: pass try: context.add_os_installer_key(os_key, 'fake-key') assert False, "should have raised" except KeyError: pass try: context.set_default_os_installer_key(os_key, 'fake-key') assert False, "should have raised" except KeyError: pass try: context.get_default_os_installer_key('bad-os') assert False, "should have raised" except KeyError: pass installer_key1 = 'fake1' installer_key2 = 'fake2' class FakeInstaller(Installer): pass class FakeInstaller2(Installer): pass # configure our context with two valid installers context.set_installer(installer_key1, FakeInstaller()) context.set_installer(installer_key2, FakeInstaller2()) # start adding installers for os_key context.add_os_installer_key(os_key, installer_key1) assert context.get_os_installer_keys(os_key) == [installer_key1] # retest set_default_os_installer_key, now with installer_key not configured on os try: context.set_default_os_installer_key(os_key, installer_key2) assert False, "should have raised" except KeyError as e: assert 'add_os_installer' in str(e), e # now properly add in key2 context.add_os_installer_key(os_key, installer_key2) assert set(context.get_os_installer_keys(os_key)) == set( [installer_key1, installer_key2]) # test default assert None == context.get_default_os_installer_key(os_key) context.set_default_os_installer_key(os_key, installer_key1) assert installer_key1 == context.get_default_os_installer_key(os_key) context.set_default_os_installer_key(os_key, installer_key2) assert installer_key2 == context.get_default_os_installer_key(os_key) # retest set_default_os_installer_key, now with invalid os try: context.set_default_os_installer_key('bad-os', installer_key1) assert False, "should have raised" except KeyError: pass
def test_InstallerContext_installers(): from xylem.installers import InstallerContext, Installer from .os_detect import OsDetect detect = OsDetect() context = InstallerContext(detect) context.verbose = True key = 'fake-apt' try: installer = context.get_installer(key) assert False, "should have raised: %s" % (installer) except KeyError: pass class Foo: pass class FakeInstaller(Installer): pass class FakeInstaller2(Installer): pass # test TypeError on set_installer try: context.set_installer(key, 1) assert False, "should have raised" except TypeError: pass try: context.set_installer(key, Foo()) assert False, "should have raised" except TypeError: pass try: # must be instantiated context.set_installer(key, FakeInstaller) assert False, "should have raised" except TypeError: pass installer = FakeInstaller() installer2 = FakeInstaller2() context.set_installer(key, installer) assert context.get_installer(key) == installer assert context.get_installer_keys() == [key] # repeat with same args context.set_installer(key, installer) assert context.get_installer(key) == installer assert context.get_installer_keys() == [key] # repeat with new installer context.set_installer(key, installer2) assert context.get_installer(key) == installer2 assert context.get_installer_keys() == [key] # repeat with new key key2 = 'fake-port' context.set_installer(key2, installer2) assert context.get_installer(key2) == installer2 assert set(context.get_installer_keys()) == set([key, key2]) # test installer deletion key3 = 'fake3' context.set_installer(key3, installer2) assert context.get_installer(key3) == installer2 assert set(context.get_installer_keys()) == set([key, key2, key3]) context.set_installer(key3, None) try: context.get_installer(key3) assert False except KeyError: pass assert set(context.get_installer_keys()) == set([key, key2])