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 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 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 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 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_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 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_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_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])
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 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 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_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])
