def test_simple_installed(self):
# Given
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2,
dependencies=["MKL 10.3"]),
]
repository = repository_factory(entries)
installed_repository = Repository()
installed_repository.add_package(
dummy_installed_package_factory("MKL", "10.3", 1)
)
expected_actions = [
('install', "numpy-1.8.0-2.egg"),
]
# When
request = Request()
request.install(Requirement("numpy"))
solver = Solver(repository, installed_repository)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, expected_actions)
def test_whats_new_no_new_epd(self):
# Given
r_output = textwrap.dedent("""\
Name installed available
============================================================
scipy 0.12.0-1 0.13.0-1
numpy 1.7.1-1 1.7.1-2
""")
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 1),
dummy_installed_package_factory("scipy", "0.12.0", 1)
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 2),
dummy_repository_package_factory("scipy", "0.13.0", 1)
]
remote, installed = create_repositories(remote_entries,
installed_entries)
# When
with mock_print() as m:
whats_new(remote, installed)
# Then
# FIXME: we splitlines and compared wo caring about order, as
# the actual line order depends on dict ordering from
# EggCollection.query_installed.
assertCountEqual(self, m.value.splitlines(), r_output.splitlines())
def test_install_from_requirements(self):
# Given
remote_entries = [
dummy_repository_package_factory("numpy", "1.8.0", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
dummy_repository_package_factory("nose", "1.2.1", 2),
dummy_repository_package_factory("nose", "1.3.0", 1)
]
requirements_file = os.path.join(self.prefix, "requirements.txt")
with open(requirements_file, "w") as fp:
fp.write("numpy 1.8.0-1\nnose 1.2.1-1")
config = Configuration()
enpkg = create_prefix_with_eggs(config, self.prefix, [],
remote_entries)
args = FakeOptions()
args.requirements = requirements_file
# When
with mock.patch(
"enstaller.cli.commands.install_req") as mocked_install_req:
install_from_requirements(enpkg, config, args)
# Then
mocked_install_req.assert_has_calls([
mock.call(enpkg, config, "numpy 1.8.0-1", args),
mock.call(enpkg, config, "nose 1.2.1-1", args)
])
def test_another_platform(self, config):
# Given
self._mock_auth()
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy", "1.8.0", 1,
dependencies=["MKL 10.3"]),
]
_mock_index(entries, "rh5-64")
_mock_index([], "rh5-32")
r_output = textwrap.dedent("""\
Resolving dependencies for numpy: numpy-1.8.0-1.egg
mkl 10.3
""")
# When
with mock_print() as m:
main(["numpy", "--platform=rh5-32"])
# Then
self.assertMultiLineEqual(m.value,
"No egg found for requirement numpy\n")
# When
with mock_print() as m:
main(["numpy", "--platform=rh5-64"])
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_recursive_install_unavailable_dependency(self):
config = Configuration()
session = Session(DummyAuthenticator(), self.prefix)
auth = ("nono", "le gros robot")
session.authenticate(auth)
config.update(auth=auth)
r_output = textwrap.dedent("""
Cannot install 'scipy', as this package (or some of its requirements) are not
available at your subscription level 'Canopy / EPD Free' (You are logged in as
'nono').
""")
self.maxDiff = None
numpy = dummy_repository_package_factory("numpy", "1.7.1", 1)
numpy.available = False
scipy = dummy_repository_package_factory("scipy", "0.12.0", 1)
scipy.packages = ["numpy 1.7.1"]
remote_entries = [numpy, scipy]
with mock.patch("enstaller.main.Enpkg.execute"):
enpkg = create_prefix_with_eggs(config, self.prefix, [],
remote_entries)
with mock_print() as m:
with self.assertRaises(SystemExit):
install_req(enpkg, config, "scipy", FakeOptions())
self.assertMultiLineEqual(m.value, r_output)
def test_update_all_epd_updates(self):
r_output = textwrap.dedent("""\
EPD 7.3-2 is available. To update to it (with confirmation warning), run 'enpkg epd'.
The following updates and their dependencies will be installed
Name installed available
============================================================
scipy 0.13.0-1 0.13.2-1
""")
config = Configuration()
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 2),
dummy_installed_package_factory("scipy", "0.13.0", 1),
dummy_installed_package_factory("epd", "7.3", 1),
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 1),
dummy_repository_package_factory("scipy", "0.13.2", 1),
dummy_repository_package_factory("epd", "7.3", 2),
]
with mkdtemp() as d:
enpkg = create_prefix_with_eggs(config, d, installed_entries,
remote_entries)
with mock.patch("enstaller.cli.commands.install_req"
) as mocked_install_req:
with mock_print() as m:
update_all(enpkg, config, FakeOptions())
self.assertMultiLineEqual(m.value, r_output)
mocked_install_req.assert_called()
def test_recursive_install_unavailable_dependency(self):
config = Configuration()
session = Session(DummyAuthenticator(), self.prefix)
auth = ("nono", "le gros robot")
session.authenticate(auth)
config.update(auth=auth)
r_output = textwrap.dedent("""
Cannot install 'scipy', as this package (or some of its requirements) are not
available at your subscription level 'Canopy / EPD Free' (You are logged in as
'nono').
""")
self.maxDiff = None
numpy = dummy_repository_package_factory("numpy", "1.7.1", 1)
numpy.available = False
scipy = dummy_repository_package_factory("scipy", "0.12.0", 1)
scipy.packages = ["numpy 1.7.1"]
remote_entries = [numpy, scipy]
with mock.patch("enstaller.main.Enpkg.execute"):
enpkg = create_prefix_with_eggs(config, self.prefix, [], remote_entries)
with mock_print() as m:
with self.assertRaises(SystemExit):
install_req(enpkg, config, "scipy", FakeOptions())
self.assertMultiLineEqual(m.value, r_output)
def test_simple_installed(self):
# Given
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy",
"1.8.0",
2,
dependencies=["MKL 10.3"]),
]
repository = repository_factory(entries)
installed_repository = Repository()
installed_repository.add_package(
dummy_installed_package_factory("MKL", "10.3", 1))
expected_actions = [
('install', "numpy-1.8.0-2.egg"),
]
# When
request = Request()
request.install(Requirement("numpy"))
solver = Solver(repository, installed_repository)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, expected_actions)
def test_update_all_epd_updates(self):
r_output = textwrap.dedent("""\
EPD 7.3-2 is available. To update to it (with confirmation warning), run 'enpkg epd'.
The following updates and their dependencies will be installed
Name installed available
============================================================
scipy 0.13.0-1 0.13.2-1
""")
config = Configuration()
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 2),
dummy_installed_package_factory("scipy", "0.13.0", 1),
dummy_installed_package_factory("epd", "7.3", 1),
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 1),
dummy_repository_package_factory("scipy", "0.13.2", 1),
dummy_repository_package_factory("epd", "7.3", 2),
]
with mkdtemp() as d:
enpkg = create_prefix_with_eggs(config, d, installed_entries, remote_entries)
with mock.patch("enstaller.cli.commands.install_req") as mocked_install_req:
with mock_print() as m:
update_all(enpkg, config, FakeOptions())
self.assertMultiLineEqual(m.value, r_output)
mocked_install_req.assert_called()
def test_install_from_requirements(self):
# Given
remote_entries = [
dummy_repository_package_factory("numpy", "1.8.0", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
dummy_repository_package_factory("nose", "1.2.1", 2),
dummy_repository_package_factory("nose", "1.3.0", 1)
]
requirements_file = os.path.join(self.prefix, "requirements.txt")
with open(requirements_file, "w") as fp:
fp.write("numpy 1.8.0-1\nnose 1.2.1-1")
config = Configuration()
enpkg = create_prefix_with_eggs(config, self.prefix, [], remote_entries)
args = FakeOptions()
args.requirements = requirements_file
# When
with mock.patch("enstaller.cli.commands.install_req") as mocked_install_req:
install_from_requirements(enpkg, config, args)
# Then
mocked_install_req.assert_has_calls(
[mock.call(enpkg, config, "numpy 1.8.0-1", args),
mock.call(enpkg, config, "nose 1.2.1-1", args)])
def test_whats_new_no_new_epd(self):
# Given
r_output = textwrap.dedent("""\
Name installed available
============================================================
scipy 0.12.0-1 0.13.0-1
numpy 1.7.1-1 1.7.1-2
""")
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 1),
dummy_installed_package_factory("scipy", "0.12.0", 1)
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 2),
dummy_repository_package_factory("scipy", "0.13.0", 1)
]
remote, installed = create_repositories(remote_entries,
installed_entries)
# When
with mock_print() as m:
whats_new(remote, installed)
# Then
# FIXME: we splitlines and compared wo caring about order, as
# the actual line order depends on dict ordering from
# EggCollection.query_installed.
assertCountEqual(self, m.value.splitlines(), r_output.splitlines())
def test_another_platform(self, config):
# Given
self._mock_auth()
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy",
"1.8.0",
1,
dependencies=["MKL 10.3"]),
]
_mock_index(entries, "rh5-64")
_mock_index([], "rh5-32")
r_output = textwrap.dedent("""\
Resolving dependencies for numpy: numpy-1.8.0-1.egg
mkl 10.3
""")
# When
with mock_print() as m:
main(["numpy", "--platform=rh5-32"])
# Then
self.assertMultiLineEqual(m.value,
"No egg found for requirement numpy\n")
# When
with mock_print() as m:
main(["numpy", "--platform=rh5-64"])
# Then
self.assertMultiLineEqual(m.value, r_output)
def test__latest_package_simple(self):
# Given
packages = [
dummy_repository_package_factory("swig", "1.3.40", 1),
dummy_repository_package_factory("swig", "1.3.40", 2),
dummy_repository_package_factory("swig", "2.0.1", 1),
]
repository = self._repository_factory(packages)
# When
resolver = Resolve(repository)
latest = resolver._latest_package(
_LegacyRequirement.from_requirement_string("swig")
)
# Then
self.assertEqual(latest.key, "swig-2.0.1-1.egg")
# When
resolver = Resolve(repository)
latest = resolver._latest_package(
_LegacyRequirement.from_requirement_string("swigg")
)
# Then
self.assertIsNone(latest)
def _index_provider(store_location):
entries = [
dummy_repository_package_factory("numpy", "1.8.0", 1,
store_location=store_location),
dummy_repository_package_factory("scipy", "0.14.0", 1,
store_location=store_location)
]
return json.dumps(dict((entry.key, entry.s3index_data) for entry in entries))
def _index_provider(repository_info):
entries = [
dummy_repository_package_factory("numpy", "1.8.0", 1,
repository_info=repository_info),
dummy_repository_package_factory("scipy", "0.14.0", 1,
repository_info=repository_info)
]
return json.dumps(dict((entry.key, entry.s3index_data) for entry in entries))
def _index_provider(store_location):
entries = [
dummy_repository_package_factory("numpy",
"1.8.0",
1,
store_location=store_location),
dummy_repository_package_factory("scipy",
"0.14.0",
1,
store_location=store_location)
]
return json.dumps(
dict((entry.key, entry.s3index_data) for entry in entries))
def test_simple_all_installed(self):
# Given
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy",
"1.8.0",
2,
dependencies=["MKL 10.3"]),
]
repository = repository_factory(entries)
installed_entries = [
dummy_installed_package_factory("MKL", "10.3", 1),
dummy_installed_package_factory("numpy", "1.8.0", 2)
]
installed_repository = Repository()
for package in installed_entries:
installed_repository.add_package(package)
# When
request = Request()
request.install(Requirement("numpy"))
solver = Solver(repository, installed_repository)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, [])
# When
solver = Solver(repository, installed_repository, force=True)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, [("remove", "numpy-1.8.0-2.egg"),
("install", "numpy-1.8.0-2.egg")])
# When
solver = Solver(repository,
installed_repository,
force=True,
forceall=True)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, [("remove", "numpy-1.8.0-2.egg"),
("remove", "MKL-10.3-1.egg"),
("install", "MKL-10.3-1.egg"),
("install", "numpy-1.8.0-2.egg")])
def test_simple_all_installed(self):
# Given
remote_mkl = dummy_repository_package_factory("MKL", "10.3", 1)
remote_numpy = dummy_repository_package_factory(
"numpy", "1.8.0", 2, dependencies=["MKL 10.3"]
)
entries = [remote_mkl, remote_numpy]
repository = repository_factory(entries)
installed_mkl = dummy_installed_package_factory("MKL", "10.3", 1)
installed_numpy = dummy_installed_package_factory("numpy", "1.8.0", 2)
installed_entries = [installed_mkl, installed_numpy]
installed_repository = Repository()
for package in installed_entries:
installed_repository.add_package(package)
# When
request = Request()
request.install(Requirement("numpy"))
solver = Solver(repository, installed_repository)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, [])
# When
solver = Solver(
repository, installed_repository, force=ForceMode.MAIN_ONLY
)
actions = solver.resolve(request)
# Then
self.assertListEqual(
actions, [("remove", installed_numpy), ("install", remote_numpy)]
)
# When
solver = Solver(repository, installed_repository, force=ForceMode.ALL)
actions = solver.resolve(request)
# Then
self.assertListEqual(
actions,
[("remove", installed_numpy), ("remove", installed_mkl),
("install", remote_mkl), ("install", remote_numpy)]
)
def test__latest_egg_multiple_python_versions(self):
# Given
packages = [
dummy_repository_package_factory("swig", "1.3.40", 1),
dummy_repository_package_factory("swig", "1.3.40", 2),
dummy_repository_package_factory("swig", "2.0.1", 1)
]
repository = self._repository_factory(packages)
# When
resolver = Resolve(repository)
latest = resolver._latest_egg(Requirement("swig"))
# Then
self.assertEqual(latest, "swig-2.0.1-1.egg")
def test_simple_all_installed(self):
# Given
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2,
dependencies=["MKL 10.3"]),
]
repository = repository_factory(entries)
installed_entries = [
dummy_installed_package_factory("MKL", "10.3", 1),
dummy_installed_package_factory("numpy", "1.8.0", 2)
]
installed_repository = Repository()
for package in installed_entries:
installed_repository.add_package(package)
# When
request = Request()
request.install(Requirement("numpy"))
solver = Solver(repository, installed_repository)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, [])
# When
solver = Solver(repository, installed_repository, force=True)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions,
[("remove", "numpy-1.8.0-2.egg"),
("install", "numpy-1.8.0-2.egg")])
# When
solver = Solver(repository, installed_repository, force=True,
forceall=True)
actions = solver.resolve(request)
# Then
self.assertListEqual(actions,
[("remove", "numpy-1.8.0-2.egg"),
("remove", "MKL-10.3-1.egg"),
("install", "MKL-10.3-1.egg"),
("install", "numpy-1.8.0-2.egg")])
def test_remove_non_existing(self):
# Given
entries = [
dummy_repository_package_factory("numpy", "1.6.1", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
]
repository = repository_factory(entries)
solver = Solver(repository, Repository._from_prefixes([self.prefix]))
request = Request()
request.remove(Requirement("numpy"))
# When/Then
with self.assertRaises(EnpkgError):
solver.resolve(request)
def test_remove_non_existing(self):
# Given
entries = [
dummy_repository_package_factory("numpy", "1.6.1", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
]
repository = repository_factory(entries)
solver = Solver(repository, Repository._from_prefixes([self.prefix]))
request = Request()
request.remove(Requirement("numpy"))
# When/Then
with self.assertRaises(EnpkgError):
solver.resolve(request)
def test_install_no_egg_entry(self):
# Given
entries = [
dummy_repository_package_factory("numpy", "1.6.1", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
]
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([self.prefix])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("scipy"))
# When/Then
with self.assertRaises(NoPackageFound):
solver.resolve(request)
def test_install_no_egg_entry(self):
# Given
entries = [
dummy_repository_package_factory("numpy", "1.6.1", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
]
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([self.prefix])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("scipy"))
# When/Then
with self.assertRaises(NoPackageFound):
solver.resolve(request)
def test_simple_install(self):
remote_entries = [dummy_repository_package_factory("nose", "1.3.0", 1)]
with mock.patch("enstaller.main.Enpkg.execute") as m:
enpkg = create_prefix_with_eggs(Configuration(), self.prefix, [],
remote_entries)
install_req(enpkg, Configuration(), "nose", FakeOptions())
m.assert_called_with([('fetch', 'nose-1.3.0-1.egg'),
('install', 'nose-1.3.0-1.egg')])
def test_install_simple(self):
entries = [
dummy_repository_package_factory("numpy", "1.6.1", 1),
dummy_repository_package_factory("numpy", "1.8.0", 2),
dummy_repository_package_factory("numpy", "1.7.1", 2),
]
r_actions = [('install', 'numpy-1.8.0-2.egg')]
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([self.prefix])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("numpy"))
actions = solver.resolve(request)
self.assertEqual(actions, r_actions)
def test_info_option(self):
self.maxDiff = None
# Given
entries = [dummy_repository_package_factory("enstaller", "4.6.2", 1),
dummy_repository_package_factory("enstaller", "4.6.3", 1)]
mtime = 0.0
r_output = textwrap.dedent("""\
Package: enstaller
Version: 4.6.2-1
Product: commercial
Available: True
Python version: {python_version}
Store location: {store_location_1}
Last modified: {last_modified}
MD5: {md5}
Size: {size}
Requirements: None
Version: 4.6.3-1
Product: commercial
Available: True
Python version: {python_version}
Store location: {store_location_2}
Last modified: {last_modified}
MD5: {md5}
Size: {size}
Requirements: None
""".format(md5=FAKE_MD5, size=FAKE_SIZE, python_version=PY_VER,
store_location_1=entries[0].source_url,
store_location_2=entries[1].source_url,
last_modified=datetime.datetime.fromtimestamp(mtime)))
remote_repository, installed_repository = \
create_repositories(remote_entries=entries)
# When
with mock_print() as m:
info_option(remote_repository, installed_repository,
"enstaller")
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_update_all_no_updates(self):
r_output = "No new version of any installed package is available\n"
config = Configuration()
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 2),
dummy_installed_package_factory("scipy", "0.13.0", 1)
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 1),
dummy_repository_package_factory("scipy", "0.12.0", 1)
]
with mkdtemp() as d:
enpkg = create_prefix_with_eggs(config, d, installed_entries,
remote_entries)
with mock_print() as m:
update_all(enpkg, config, FakeOptions())
self.assertMultiLineEqual(m.value, r_output)
def test_update_all_no_updates(self):
r_output = "No new version of any installed package is available\n"
config = Configuration()
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 2),
dummy_installed_package_factory("scipy", "0.13.0", 1)
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 1),
dummy_repository_package_factory("scipy", "0.12.0", 1)
]
with mkdtemp() as d:
enpkg = create_prefix_with_eggs(config, d,
installed_entries, remote_entries)
with mock_print() as m:
update_all(enpkg, config, FakeOptions())
self.assertMultiLineEqual(m.value, r_output)
def test_install_simple(self):
numpy_1_8_0 = dummy_repository_package_factory("numpy", "1.8.0", 2)
entries = [
dummy_repository_package_factory("numpy", "1.6.1", 1),
numpy_1_8_0,
dummy_repository_package_factory("numpy", "1.7.1", 2),
]
r_actions = [('install', numpy_1_8_0)]
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([self.prefix])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("numpy"))
actions = solver.resolve(request)
self.assertEqual(actions, r_actions)
def test_info_option(self):
self.maxDiff = None
# Given
mtime = 0.0
r_output = textwrap.dedent("""\
Package: enstaller
Version: 4.6.2-1
Product: commercial
Available: True
Python version: {2}
Store location: {3}
Last modified: {4}
MD5: {0}
Size: {1}
Requirements: None
Version: 4.6.3-1
Product: commercial
Available: True
Python version: {2}
Store location: {3}
Last modified: {4}
MD5: {0}
Size: {1}
Requirements: None
""".format(FAKE_MD5, FAKE_SIZE, PY_VER, "",
datetime.datetime.fromtimestamp(mtime)))
entries = [
dummy_repository_package_factory("enstaller", "4.6.2", 1),
dummy_repository_package_factory("enstaller", "4.6.3", 1)
]
remote_repository, installed_repository = \
create_repositories(remote_entries=entries)
# When
with mock_print() as m:
info_option(remote_repository, installed_repository, "enstaller")
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_update_check_no_new_available(self):
# Given
remote_entries = [
dummy_repository_package_factory("dummy", "1.0.0", 1),
dummy_repository_package_factory("dummy", "0.9.8", 1)
]
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
remote_repository, installed_repository = \
self._create_repositories(remote_entries, installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(EPD_update, [])
self.assertEqual(updates, [])
def test_update_check_no_new_available(self):
# Given
remote_entries = [
dummy_repository_package_factory("dummy", "1.0.0", 1),
dummy_repository_package_factory("dummy", "0.9.8", 1)
]
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
remote_repository, installed_repository = \
self._create_repositories(remote_entries, installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(EPD_update, [])
self.assertEqual(updates, [])
def test_simple(self, config):
# Given
self._mock_auth()
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy", "1.8.0", 1,
dependencies=["MKL 10.3"]),
]
_mock_index(entries)
r_output = textwrap.dedent("""\
Resolving dependencies for numpy: numpy-1.8.0-1.egg
mkl 10.3
""")
# When
with mock_print() as m:
main(["numpy"])
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_simple_install(self):
remote_entries = [
dummy_repository_package_factory("nose", "1.3.0", 1)
]
with mock.patch("enstaller.main.Enpkg.execute") as m:
enpkg = create_prefix_with_eggs(Configuration(), self.prefix, [],
remote_entries)
install_req(enpkg, Configuration(), "nose", FakeOptions())
m.assert_called_with([('fetch', 'nose-1.3.0-1.egg'),
('install', 'nose-1.3.0-1.egg')])
def test_info_option(self):
self.maxDiff = None
# Given
mtime = 0.0
r_output = textwrap.dedent("""\
Package: enstaller
Version: 4.6.2-1
Product: commercial
Available: True
Python version: {2}
Store location: {3}
Last modified: {4}
MD5: {0}
Size: {1}
Requirements: None
Version: 4.6.3-1
Product: commercial
Available: True
Python version: {2}
Store location: {3}
Last modified: {4}
MD5: {0}
Size: {1}
Requirements: None
""".format(FAKE_MD5, FAKE_SIZE, PY_VER, "",
datetime.datetime.fromtimestamp(mtime)))
entries = [dummy_repository_package_factory("enstaller", "4.6.2", 1),
dummy_repository_package_factory("enstaller", "4.6.3", 1)]
remote_repository, installed_repository = \
create_repositories(remote_entries=entries)
# When
with mock_print() as m:
info_option(remote_repository, installed_repository,
"enstaller")
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_simple_no_install_needed(self):
installed_entries = [
dummy_installed_package_factory("nose", "1.3.0", 1)
]
remote_entries = [dummy_repository_package_factory("nose", "1.3.0", 1)]
config = Configuration()
with mock.patch("enstaller.main.Enpkg.execute") as m:
enpkg = create_prefix_with_eggs(config, self.prefix,
installed_entries, remote_entries)
install_req(enpkg, config, "nose", FakeOptions())
m.assert_called_with([])
def test_simple(self):
# Given
config = Configuration()
session = Session.from_configuration(config)
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy", "1.8.0", 1,
dependencies=["MKL 10.3"]),
]
_mock_index(entries)
r_output = textwrap.dedent("""\
Resolving dependencies for numpy: numpy-1.8.0-1.egg
mkl 10.3
""")
# When
with mock_print() as m:
query_platform(session, config.repositories, "numpy", custom_plat)
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_simple(self, config):
# Given
self._mock_auth()
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy",
"1.8.0",
1,
dependencies=["MKL 10.3"]),
]
_mock_index(entries)
r_output = textwrap.dedent("""\
Resolving dependencies for numpy: numpy-1.8.0-1.egg
mkl 10.3
""")
# When
with mock_print() as m:
main(["numpy"])
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_whats_new_no_updates(self):
# Given
r_output = "No new version of any installed package is available\n"
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 2),
dummy_installed_package_factory("scipy", "0.13.0", 1)
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 1),
dummy_repository_package_factory("scipy", "0.12.0", 1)
]
remote, installed = create_repositories(remote_entries,
installed_entries)
# When
with mock_print() as m:
whats_new(remote, installed)
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_whats_new_no_updates(self):
# Given
r_output = "No new version of any installed package is available\n"
installed_entries = [
dummy_installed_package_factory("numpy", "1.7.1", 2),
dummy_installed_package_factory("scipy", "0.13.0", 1)
]
remote_entries = [
dummy_repository_package_factory("numpy", "1.7.1", 1),
dummy_repository_package_factory("scipy", "0.12.0", 1)
]
remote, installed = create_repositories(remote_entries,
installed_entries)
# When
with mock_print() as m:
whats_new(remote, installed)
# Then
self.assertMultiLineEqual(m.value, r_output)
def test__latest_egg_simple(self):
# Given
packages = [
dummy_repository_package_factory("swig", "1.3.40", 1),
dummy_repository_package_factory("swig", "1.3.40", 2),
dummy_repository_package_factory("swig", "2.0.1", 1),
]
repository = self._repository_factory(packages)
# When
resolver = Resolve(repository)
latest = resolver._latest_egg(Requirement("swig"))
# Then
self.assertEqual(latest, "swig-2.0.1-1.egg")
# When
resolver = Resolve(repository)
latest = resolver._latest_egg(Requirement("swigg"))
# Then
self.assertIsNone(latest)
def remote_enstaller_available(versions):
repository = Repository()
for version in versions:
package = dummy_repository_package_factory("enstaller", version, build=1)
repository.add_package(package)
def dec(f):
@functools.wraps(f)
def wrapper(*a, **kw):
with mock.patch("enstaller.main.repository_factory",
return_value=repository):
return f(*a, **kw)
return wrapper
return dec
def test_simple(self):
# Given
config = Configuration()
session = Session.from_configuration(config)
entries = [
dummy_repository_package_factory("MKL", "10.3", 1),
dummy_repository_package_factory("numpy",
"1.8.0",
1,
dependencies=["MKL 10.3"]),
]
_mock_index(entries)
r_output = textwrap.dedent("""\
Resolving dependencies for numpy: numpy-1.8.0-1.egg
mkl 10.3
""")
# When
with mock_print() as m:
query_platform(session, config.indices, "numpy", custom_plat)
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_simple_no_install_needed(self):
installed_entries = [
dummy_installed_package_factory("nose", "1.3.0", 1)
]
remote_entries = [
dummy_repository_package_factory("nose", "1.3.0", 1)
]
config = Configuration()
with mock.patch("enstaller.main.Enpkg.execute") as m:
enpkg = create_prefix_with_eggs(config, self.prefix,
installed_entries, remote_entries)
install_req(enpkg, config, "nose", FakeOptions())
m.assert_called_with([])
def test_update_check_new_available(self):
# Given
remote_entries = [
dummy_repository_package_factory("dummy", "1.2.0", 1),
dummy_repository_package_factory("dummy", "0.9.8", 1)
]
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
remote_repository, installed_repository = \
self._create_repositories(remote_entries, installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(EPD_update, [])
self.assertEqual(len(updates), 1)
update0 = updates[0]
assertCountEqual(self, update0.keys(), ["current", "update"])
self.assertEqual(update0["current"].version, V("1.0.1-1"))
self.assertEqual(update0["update"].version, V("1.2.0-1"))
def test_update_check_new_available(self):
# Given
remote_entries = [
dummy_repository_package_factory("dummy", "1.2.0", 1),
dummy_repository_package_factory("dummy", "0.9.8", 1)
]
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
remote_repository, installed_repository = \
self._create_repositories(remote_entries, installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(EPD_update, [])
self.assertEqual(len(updates), 1)
update0 = updates[0]
assertCountEqual(self, update0.keys(), ["current", "update"])
self.assertEqual(update0["current"].version, V("1.0.1-1"))
self.assertEqual(update0["update"].version, V("1.2.0-1"))
def test_install_missing_dependency(self):
# Given
entries = [
dummy_repository_package_factory("numpy", "1.8.0", 2,
dependencies=["MKL 10.3"]),
]
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([self.prefix])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("numpy"))
# When/Then
with self.assertRaises(MissingDependency):
solver.resolve(request)
def test_chained_override_update(self):
""" Test update to package with latest version in lower prefix
but an older version in primary prefix.
"""
# Given
l0_egg = NOSE_1_3_0
l1_egg = NOSE_1_2_1
nose = dummy_repository_package_factory(
*split_eggname(os.path.basename(l0_egg))
)
repository = repository_factory([nose])
l0 = os.path.join(self.prefix, 'l0')
l1 = os.path.join(self.prefix, 'l1')
makedirs(l0)
makedirs(l1)
l1_egg_meta_dir = os.path.join(l1, EGG_INFO, "nose")
# Install latest version in l0
EggInst(l0_egg, l0).install()
# Install older version in l1
EggInst(l1_egg, l1).install()
installed_nose = InstalledPackageMetadata.from_meta_dir(
l1_egg_meta_dir, prefix=l1
)
expected_actions = [('remove', installed_nose), ('install', nose)]
installed_repository = Repository._from_prefixes([l1])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("nose"))
# When
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, expected_actions)
def test_install_missing_dependency(self):
# Given
entries = [
dummy_repository_package_factory("numpy",
"1.8.0",
2,
dependencies=["MKL 10.3"]),
]
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([self.prefix])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("numpy"))
# When/Then
with self.assertRaises(MissingDependency):
solver.resolve(request)
def test_chained_override_update(self):
""" Test update to package with latest version in lower prefix
but an older version in primary prefix.
"""
# Given
l0_egg = NOSE_1_3_0
l1_egg = NOSE_1_2_1
expected_actions = [
('remove', os.path.basename(l1_egg)),
('install', os.path.basename(l0_egg)),
]
entries = [
dummy_repository_package_factory(
*split_eggname(os.path.basename(l0_egg))),
]
repository = repository_factory(entries)
l0 = os.path.join(self.prefix, 'l0')
l1 = os.path.join(self.prefix, 'l1')
makedirs(l0)
makedirs(l1)
# Install latest version in l0
EggInst(l0_egg, l0).install()
# Install older version in l1
EggInst(l1_egg, l1).install()
repository = repository_factory(entries)
installed_repository = Repository._from_prefixes([l1])
solver = Solver(repository, installed_repository)
request = Request()
request.install(Requirement("nose"))
# When
actions = solver.resolve(request)
# Then
self.assertListEqual(actions, expected_actions)
def test_update_check_epd(self):
# Given
remote_entries = [dummy_repository_package_factory("EPD", "7.3", 1)]
installed_entries = [dummy_installed_package_factory("EPD", "7.2", 1)]
remote_repository, installed_repository = \
self._create_repositories(remote_entries, installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(updates, [])
self.assertEqual(len(EPD_update), 1)
epd_update0 = EPD_update[0]
assertCountEqual(self, epd_update0.keys(), ["current", "update"])
self.assertEqual(epd_update0["current"].version, V("7.2-1"))
self.assertEqual(epd_update0["update"].version, V("7.3-1"))
def test_whats_new_new_epd(self):
# Given
r_output = "EPD 7.3-2 is available. To update to it (with " \
"confirmation warning), run 'enpkg epd'.\n"
installed_entries = [
dummy_installed_package_factory("EPD", "7.2", 1),
]
remote_entries = [
dummy_repository_package_factory("EPD", "7.3", 2),
]
remote, installed = create_repositories(remote_entries,
installed_entries)
# When
with mock_print() as m:
whats_new(remote, installed)
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_whats_new_new_epd(self):
# Given
r_output = "EPD 7.3-2 is available. To update to it (with " \
"confirmation warning), run 'enpkg epd'.\n"
installed_entries = [
dummy_installed_package_factory("EPD", "7.2", 1),
]
remote_entries = [
dummy_repository_package_factory("EPD", "7.3", 2),
]
remote, installed = create_repositories(remote_entries,
installed_entries)
# When
with mock_print() as m:
whats_new(remote, installed)
# Then
self.assertMultiLineEqual(m.value, r_output)
def test_update_check_epd(self):
# Given
remote_entries = [dummy_repository_package_factory("EPD", "7.3", 1)]
installed_entries = [dummy_installed_package_factory("EPD", "7.2", 1)]
remote_repository, installed_repository = \
self._create_repositories(remote_entries, installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(updates, [])
self.assertEqual(len(EPD_update), 1)
epd_update0 = EPD_update[0]
assertCountEqual(self, epd_update0.keys(), ["current", "update"])
self.assertEqual(epd_update0["current"].version, V("7.2-1"))
self.assertEqual(epd_update0["update"].version, V("7.3-1"))
def test_install_not_available(self):
# Given
config = Configuration()
config.update(auth=FAKE_AUTH)
nose = dummy_repository_package_factory("nose", "1.3.0", 1)
nose.available = False
repository = Repository()
repository.add_package(nose)
enpkg = Enpkg(repository,
mocked_session_factory(config.repository_cache),
[self.prefix])
enpkg.execute = mock.Mock()
# When/Then
with mock.patch("enstaller.config.subscription_message") as \
subscription_message:
with self.assertRaises(SystemExit) as e:
install_req(enpkg, config, "nose", FakeOptions())
subscription_message.assert_called()
self.assertEqual(e.exception.code, 1)
