def test_load_fail_if_unknown_driver(self):
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(
self.context,
"unknown_driver",
"x86_64"
)
def test_load_fail_if_unknown_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {}
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(
self.context,
"unknown_driver",
"x86_64"
)
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
def create(cls, config, repotype, repoarch):
"""Creates the repository API instance.
:param config: the configuration
:param repotype: the kind of repository(deb, yum, etc)
:param repoarch: the architecture of repository (x86_64 or i386)
"""
context = config if isinstance(config, Context) else Context(config)
return cls(RepositoryController.load(context, repotype, repoarch))
def create(cls, config, repotype, repoarch):
"""Creates the repository API instance.
:param config: the configuration
:param repotype: the kind of repository(deb, yum, etc)
:param repoarch: the architecture of repository (x86_64 or i386)
"""
context = config if isinstance(config, Context) else Context(config)
return cls(RepositoryController.load(context, repotype, repoarch))
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
stevedore.ExtensionManager.assert_called_once_with(
"packetary.repository_drivers", invoke_on_load=True)
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
stevedore.ExtensionManager.assert_called_once_with(
"packetary.repository_drivers", invoke_on_load=True
)
def test_load_fail_if_unknown_driver(self):
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(self.context, "unknown_driver", "x86_64")
def setUp(self):
self.driver = mock.MagicMock(spec=RepositoryDriverBase)
self.context = mock.MagicMock()
self.context.async_section.return_value = Executor()
self.ctrl = RepositoryController(self.context, self.driver, "x86_64")
class TestRepositoryController(base.TestCase):
def setUp(self):
self.driver = mock.MagicMock(spec=RepositoryDriverBase)
self.context = mock.MagicMock()
self.context.async_section.return_value = Executor()
self.ctrl = RepositoryController(self.context, self.driver, "x86_64")
def test_load_fail_if_unknown_driver(self):
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(self.context, "unknown_driver", "x86_64")
@mock.patch("packetary.controllers.repository.stevedore")
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
def test_load_repositories(self):
repo_data = {"name": "test", "uri": "file:///test1"}
repo = gen_repository(**repo_data)
self.driver.get_repository = CallbacksAdapter()
self.driver.get_repository.side_effect = [repo]
repos = self.ctrl.load_repositories([repo_data])
self.driver.get_repository.assert_called_once_with(
self.context.connection, repo_data, self.ctrl.arch)
self.assertEqual([repo], repos)
def test_load_packages(self):
repo = mock.MagicMock()
consumer = mock.MagicMock()
self.ctrl.load_packages(repo, consumer)
self.driver.get_packages.assert_called_once_with(
self.context.connection, repo, consumer)
@mock.patch("packetary.controllers.repository.os")
def test_assign_packages(self, os):
repo = gen_repository(url="/test/repo")
packages = {
gen_package(name="test1", repository=repo),
gen_package(name="test2", repository=repo)
}
os.path.join = lambda *x: "/".join(x)
self.ctrl.assign_packages(repo, packages)
self.driver.add_packages.assert_called_once_with(
self.ctrl.context.connection, repo, packages)
@mock.patch("packetary.controllers.repository.os")
def test_fork_repository(self, os):
os.path.join.side_effect = lambda *args: "/".join(args)
repo = gen_repository(name="test1", url="file:///test")
clone = copy.copy(repo)
clone.url = "/root/repo"
self.driver.fork_repository.return_value = clone
self.context.connection.retrieve.side_effect = [0, 10]
self.ctrl.fork_repository(repo, "./repo", False, False)
self.driver.fork_repository.assert_called_once_with(
self.context.connection, repo, "./repo/test", False, False)
repo.path = "os"
self.ctrl.fork_repository(repo, "./repo", False, False)
self.driver.fork_repository.assert_called_with(self.context.connection,
repo, "./repo/os",
False, False)
def test_copy_packages(self):
repo = gen_repository(url="file:///repo/")
packages = [
gen_package(name="test1", repository=repo, filesize=10),
gen_package(name="test2", repository=repo, filesize=-1)
]
target = gen_repository(url="/test/repo/")
self.context.connection.retrieve.side_effect = [0, 10]
observer = mock.MagicMock()
self.ctrl._copy_packages(target, packages, observer)
observer.assert_any_call(0)
observer.assert_any_call(10)
self.context.connection.retrieve.assert_any_call(
"file:///repo/test1.pkg", "/test/repo/test1.pkg", size=10)
self.context.connection.retrieve.assert_any_call(
"file:///repo/test2.pkg", "/test/repo/test2.pkg", size=-1)
def test_copy_packages_does_not_affect_packages_in_same_repo(self):
repo = gen_repository(url="file:///repo/")
packages = [
gen_package(name="test1", repository=repo, filesize=10),
gen_package(name="test2", repository=repo, filesize=-1)
]
observer = mock.MagicMock()
self.ctrl._copy_packages(repo, packages, observer)
self.assertFalse(self.context.connection.retrieve.called)
def test_copy_free_package(self):
repo = gen_repository(url="file:///repo/")
package = gen_package(name="test1",
filename="file:///root/test.pkg",
repository=None,
filesize=10)
self.driver.get_relative_path.side_effect = ["pool/t/test1.pkg"]
self.ctrl._copy_package(repo, package, None)
self.context.connection.retrieve.assert_called_once_with(
"file:///root/test.pkg", "/repo/pool/t/test1.pkg", size=10)
def test_create_repository(self):
repository_data = {
"name": "Test",
"uri": "file:///repo/",
"section": ("trusty", "main"),
"origin": "Test"
}
repo = gen_repository(**repository_data)
packages_list = ['/tmp/test1.pkg']
packages = [gen_package(name="test2", repository=repo)]
self.driver.create_repository.return_value = repo
self.driver.load_package_from_file.side_effect = packages
self.driver.get_relative_path.side_effect = ["pool/t/test1.pkg"]
self.ctrl.create_repository(repository_data, packages_list)
self.driver.create_repository.assert_called_once_with(
self.context.connection, repository_data, self.ctrl.arch)
self.driver.get_relative_path.assert_called_once_with(
repo, "test1.pkg")
self.context.connection.retrieve.assert_any_call(
"/tmp/test1.pkg", "/repo/pool/t/test1.pkg")
self.driver.load_package_from_file.assert_called_once_with(
repo, "pool/t/test1.pkg")
self.driver.add_packages.assert_called_once_with(
self.ctrl.context.connection, repo, set(packages))
def test_get_repository_data_schema(self):
self.assertIs(self.ctrl.driver.get_repository_data_schema(),
self.ctrl.get_repository_data_schema())
def setUp(self):
self.driver = mock.MagicMock(spec=RepositoryDriverBase)
self.context = mock.MagicMock()
self.context.async_section.return_value = Executor()
self.ctrl = RepositoryController(self.context, self.driver, "x86_64")
class TestRepositoryController(base.TestCase):
def setUp(self):
self.driver = mock.MagicMock(spec=RepositoryDriverBase)
self.context = mock.MagicMock()
self.context.async_section.return_value = Executor()
self.ctrl = RepositoryController(self.context, self.driver, "x86_64")
def test_load_fail_if_unknown_driver(self):
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(
self.context,
"unknown_driver",
"x86_64"
)
@mock.patch("packetary.controllers.repository.stevedore")
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
def test_load_repositories(self):
repo_data = {"name": "test", "uri": "file:///test1"}
repo = gen_repository(**repo_data)
self.driver.get_repository = CallbacksAdapter()
self.driver.get_repository.side_effect = [repo]
repos = self.ctrl.load_repositories([repo_data])
self.driver.get_repository.assert_called_once_with(
self.context.connection, repo_data, self.ctrl.arch
)
self.assertEqual([repo], repos)
def test_load_packages(self):
repo = mock.MagicMock()
consumer = mock.MagicMock()
self.ctrl.load_packages(repo, consumer)
self.driver.get_packages.assert_called_once_with(
self.context.connection, repo, consumer
)
@mock.patch("packetary.controllers.repository.os")
def test_assign_packages(self, os):
repo = gen_repository(url="/test/repo")
packages = {
gen_package(name="test1", repository=repo),
gen_package(name="test2", repository=repo)
}
os.path.join = lambda *x: "/".join(x)
self.ctrl.assign_packages(repo, packages)
self.driver.add_packages.assert_called_once_with(
self.ctrl.context.connection, repo, packages
)
@mock.patch("packetary.controllers.repository.os")
def test_fork_repository(self, os):
os.path.join.side_effect = lambda *args: "".join(args)
repo = gen_repository(name="test1", url="file:///test")
clone = copy.copy(repo)
clone.url = "/root/repo"
self.driver.fork_repository.return_value = clone
self.context.connection.retrieve.side_effect = [0, 10]
self.ctrl.fork_repository(repo, "./repo", False, False)
self.driver.fork_repository.assert_called_once_with(
self.context.connection, repo, "./repo/test", False, False
)
repo.path = "os"
self.ctrl.fork_repository(repo, "./repo/", False, False)
self.driver.fork_repository.assert_called_with(
self.context.connection, repo, "./repo/os", False, False
)
def test_copy_packages(self):
repo = gen_repository(url="file:///repo/")
packages = [
gen_package(name="test1", repository=repo, filesize=10),
gen_package(name="test2", repository=repo, filesize=-1)
]
target = gen_repository(url="/test/repo/")
self.context.connection.retrieve.side_effect = [0, 10]
observer = mock.MagicMock()
self.ctrl._copy_packages(target, packages, observer)
observer.assert_any_call(0)
observer.assert_any_call(10)
self.context.connection.retrieve.assert_any_call(
"file:///repo/test1.pkg",
"/test/repo/test1.pkg",
size=10
)
self.context.connection.retrieve.assert_any_call(
"file:///repo/test2.pkg",
"/test/repo/test2.pkg",
size=-1
)
def test_copy_packages_does_not_affect_packages_in_same_repo(self):
repo = gen_repository(url="file:///repo/")
packages = [
gen_package(name="test1", repository=repo, filesize=10),
gen_package(name="test2", repository=repo, filesize=-1)
]
observer = mock.MagicMock()
self.ctrl._copy_packages(repo, packages, observer)
self.assertFalse(self.context.connection.retrieve.called)
def test_copy_free_package(self):
repo = gen_repository(url="file:///repo/")
package = gen_package(name="test1", filename="file:///root/test.pkg",
repository=None, filesize=10)
self.driver.get_relative_path.side_effect = ["pool/t/test1.pkg"]
self.ctrl._copy_package(repo, package, None)
self.context.connection.retrieve.assert_called_once_with(
"file:///root/test.pkg",
"/repo/pool/t/test1.pkg",
size=10
)
def test_create_repository(self):
repository_data = {
"name": "Test", "uri": "file:///repo/",
"section": ("trusty", "main"), "origin": "Test"
}
repo = gen_repository(**repository_data)
packages_list = ['/tmp/test1.pkg']
packages = [gen_package(name="test2", repository=repo)]
self.driver.create_repository.return_value = repo
self.driver.load_package_from_file.side_effect = packages
self.driver.get_relative_path.side_effect = ["pool/t/test1.pkg"]
self.ctrl.create_repository(repository_data, packages_list)
self.driver.create_repository.assert_called_once_with(
repository_data, self.ctrl.arch
)
self.driver.get_relative_path.assert_called_once_with(
repo, "test1.pkg"
)
self.context.connection.retrieve.assert_any_call(
"/tmp/test1.pkg",
"/repo/pool/t/test1.pkg"
)
self.driver.load_package_from_file.assert_called_once_with(
repo, "pool/t/test1.pkg"
)
self.driver.add_packages.assert_called_once_with(
self.ctrl.context.connection, repo, set(packages)
)
def test_get_repository_data_schema(self):
self.assertIs(
self.ctrl.driver.get_repository_data_schema(),
self.ctrl.get_repository_data_schema()
)
def test_load_fail_if_unknown_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {}
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(self.context, "unknown_driver", "x86_64")
class TestRepositoryController(base.TestCase):
def setUp(self):
self.driver = mock.MagicMock()
self.context = mock.MagicMock()
self.context.async_section.return_value = Executor()
self.ctrl = RepositoryController(self.context, self.driver, "x86_64")
def test_load_fail_if_unknown_driver(self):
with self.assertRaisesRegexp(NotImplementedError, "unknown_driver"):
RepositoryController.load(
self.context,
"unknown_driver",
"x86_64"
)
@mock.patch("packetary.controllers.repository.stevedore")
def test_load_driver(self, stevedore):
stevedore.ExtensionManager.return_value = {
"test": mock.MagicMock(obj=self.driver)
}
RepositoryController._drivers = None
controller = RepositoryController.load(self.context, "test", "x86_64")
self.assertIs(self.driver, controller.driver)
def test_load_repositories(self):
self.driver.parse_urls.return_value = ["test1"]
consumer = mock.MagicMock()
self.ctrl.load_repositories("file:///test1", consumer)
self.driver.parse_urls.assert_called_once_with(["file:///test1"])
self.driver.get_repository.assert_called_once_with(
self.context.connection, "test1", "x86_64", consumer
)
for url in [six.u("file:///test1"), ["file:///test1"]]:
self.driver.reset_mock()
self.ctrl.load_repositories(url, consumer)
if not isinstance(url, list):
url = [url]
self.driver.parse_urls.assert_called_once_with(url)
def test_load_packages(self):
repo = mock.MagicMock()
consumer = mock.MagicMock()
self.ctrl.load_packages([repo], consumer)
self.driver.get_packages.assert_called_once_with(
self.context.connection, repo, consumer
)
@mock.patch("packetary.controllers.repository.os")
def test_assign_packages(self, os):
repo = gen_repository(url="/test/repo")
packages = [
gen_package(name="test1", repository=repo),
gen_package(name="test2", repository=repo)
]
existed_packages = [
gen_package(name="test3", repository=repo),
gen_package(name="test2", repository=repo)
]
os.path.join = lambda *x: "/".join(x)
self.driver.get_packages = CallbacksAdapter()
self.driver.get_packages.return_value = existed_packages
self.ctrl.assign_packages(repo, packages, True)
os.remove.assert_not_called()
all_packages = set(packages + existed_packages)
self.driver.rebuild_repository.assert_called_once_with(
repo, all_packages
)
self.driver.rebuild_repository.reset_mock()
self.ctrl.assign_packages(repo, packages, False)
self.driver.rebuild_repository.assert_called_once_with(
repo, set(packages)
)
os.remove.assert_called_once_with("/test/repo/test3.pkg")
def test_copy_packages(self):
repo = gen_repository(url="file:///repo/")
packages = [
gen_package(name="test1", repository=repo, filesize=10),
gen_package(name="test2", repository=repo, filesize=-1)
]
target = gen_repository(url="/test/repo")
self.context.connection.retrieve.side_effect = [0, 10]
observer = mock.MagicMock()
self.ctrl.copy_packages(target, packages, True, observer)
observer.assert_has_calls([mock.call(0), mock.call(10)])
self.context.connection.retrieve.assert_any_call(
"file:///repo/test1.pkg",
"/test/repo/test1.pkg",
size=10
)
self.context.connection.retrieve.assert_any_call(
"file:///repo/test2.pkg",
"/test/repo/test2.pkg",
size=-1
)
self.driver.rebuild_repository.assert_called_once_with(
target, set(packages)
)
@mock.patch("packetary.controllers.repository.os")
def test_clone_repository(self, os):
os.path.abspath.return_value = "/root/repo"
repos = [
gen_repository(name="test1"),
gen_repository(name="test2")
]
clones = [copy.copy(x) for x in repos]
self.driver.fork_repository.side_effect = clones
mirrors = self.ctrl.clone_repositories(repos, "./repo")
for r in repos:
self.driver.fork_repository.assert_any_call(
self.context.connection, r, "/root/repo", False, False
)
self.assertEqual(mirrors, dict(zip(repos, clones)))
