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_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_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_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_find_packages_sorting(self):
# Given
entries = [
dummy_installed_package_factory("numpy", "1.6.1", 1),
dummy_installed_package_factory("numpy", "1.8.0", 2),
dummy_installed_package_factory("numpy", "1.7.1", 1),
]
repository = Repository()
for entry in entries:
repository.add_package(entry)
r_versions = [
EnpkgVersion.from_string(v)
for v in ("1.6.1-1", "1.7.1-1", "1.8.0-2")
]
# When
packages = repository.find_packages("numpy")
# Then
self.assertEqual(len(packages), 3)
self.assertEqual([p.version for p in packages], r_versions)
with self.assertWarns(DeprecationWarning):
deprecated_packages = repository.find_sorted_packages("numpy")
self.assertEqual([p.version for p in deprecated_packages], r_versions)
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_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_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_find_packages_invalid_versions(self):
# Given
entries = [
dummy_installed_package_factory("numpy", "1.6.1", 1),
dummy_installed_package_factory("numpy", "1.8k", 2),
]
repository = Repository()
for entry in entries:
repository.add_package(entry)
# When
packages = repository.find_packages("numpy")
# Then
self.assertEqual(len(packages), 2)
assertCountEqual(self, packages, entries)
def test_find_packages_invalid_versions(self):
# Given
entries = [
dummy_installed_package_factory("numpy", "1.6.1", 1),
dummy_installed_package_factory("numpy", "1.8k", 2),
]
repository = Repository()
for entry in entries:
repository.add_package(entry)
# When
packages = repository.find_packages("numpy")
# Then
self.assertEqual(len(packages), 2)
assertCountEqual(self, packages, entries)
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_sorted_packages_invalid(self):
# Given
entries = [
dummy_installed_package_factory("numpy", "1.6.1", 1),
dummy_installed_package_factory("numpy", "1.8k", 2),
]
repository = Repository()
for entry in entries:
repository.add_package(entry)
# When
packages = repository.find_sorted_packages("numpy")
# Then
self.assertEqual(len(packages), 2)
assertCountEqual(
self, [p.version for p in packages],
[EnpkgVersion.from_string(v) for v in ("1.6.1-1", "1.8k-2")])
def test_sorted_packages_invalid(self):
# Given
entries = [
dummy_installed_package_factory("numpy", "1.6.1", 1),
dummy_installed_package_factory("numpy", "1.8k", 2),
]
repository = Repository()
for entry in entries:
repository.add_package(entry)
# When
packages = repository.find_sorted_packages("numpy")
# Then
self.assertEqual(len(packages), 2)
assertCountEqual(self, [p.version for p in packages],
[EnpkgVersion.from_string(v)
for v in ("1.6.1-1", "1.8k-2")])
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_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_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_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_print_install_time(self):
with mkdtemp():
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
installed_repository = Repository()
for package in installed_entries:
installed_repository.add_package(package)
self.assertRegexpMatches(
install_time_string(installed_repository, "dummy"),
"dummy-1.0.1-1.egg was installed on:")
self.assertEqual(
install_time_string(installed_repository, "ddummy"), "")
def test_print_install_time(self):
with mkdtemp():
installed_entries = [dummy_installed_package_factory("dummy",
"1.0.1", 1)]
installed_repository = Repository()
for package in installed_entries:
installed_repository.add_package(package)
self.assertRegexpMatches(install_time_string(installed_repository,
"dummy"),
"dummy-1.0.1-1.egg was installed on:")
self.assertEqual(install_time_string(installed_repository,
"ddummy"),
"")
def test_update_check_no_available(self):
# Given
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
remote_repository, installed_repository = \
self._create_repositories([], 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_available(self):
# Given
installed_entries = [
dummy_installed_package_factory("dummy", "1.0.1", 1)
]
remote_repository, installed_repository = \
self._create_repositories([], installed_entries)
# When
updates, EPD_update = updates_check(remote_repository,
installed_repository)
# Then
self.assertEqual(EPD_update, [])
self.assertEqual(updates, [])
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_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"))
