def test_update_package_should_call_get_package_data(fetch_pkg_mock):
PackageFactory(name='local', is_local=True)
pypi_package = PackageFactory(name='pypi', is_local=False)
tasks.refresh_repository_mirrors()
assert fetch_pkg_mock.call_count == 1
fetch_pkg_mock.assert_called_once_with(pypi_package.repository.pk, pypi_package.name)
def test_update_package_should_call_get_package_data(enqueue_mock):
PackageFactory(name='local', is_local=True)
pypi_package = PackageFactory(name='pypi', is_local=False)
tasks.update_packages()
assert enqueue_mock.call_count == 1
enqueue_mock.assert_called_once_with(tasks.fetch_package,
pypi_package.name)
def test_fetch_package_should_update_existing_package(pypi_stub):
repository = RepositoryFactory(upstream_pypi_url=pypi_stub.url)
package = PackageFactory(repository=repository, name='minibar')
ReleaseFactory(package=package, version='0.1')
ReleaseFactory(package=package, version='0.2')
fetch_package(repository.pk, 'minibar')
package = repository.packages.filter(name='minibar').first()
assert package
assert package.name == 'minibar'
assert not package.is_local
assert package.releases.count() == 3
release_1, release_2, release_3 = package.releases.all()
assert release_1.version == '0.4.0'
assert release_2.version == '0.2'
assert release_3.version == '0.1'
assert release_3.author == 'Cesar Canassa'
assert release_3.author_email == '*****@*****.**'
assert release_3.description == 'Minibar'
assert release_3.download_url == 'UNKNOWN'
assert release_3.home_page == 'https://github.com/canassa/minibar'
assert release_3.license == 'MIT'
assert release_3.metadata_version == '1.0'
assert release_3.summary == 'Simple text progress bar library'
def test_render(
self,
mock_prepare_imports,
mock_render_classes,
mock_render_module,
mock_resolver_process,
):
classes = ClassFactory.list(3)
mock_render_module.return_value = "module"
mock_prepare_imports.return_value = [
PackageFactory.create(name="foo", source="bar")
]
mock_render_classes.return_value = "classes"
iterator = DataclassGenerator().render(classes)
actual = [out for out in iterator]
self.assertEqual(1, len(actual))
self.assertEqual(3, len(actual[0]))
self.assertIsInstance(actual[0][0], Path)
self.assertTrue(actual[0][0].is_absolute())
self.assertEqual("foo.tests", actual[0][1])
self.assertEqual("foo/tests.py",
str(actual[0][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_module.return_value, actual[0][2])
mock_resolver_process.assert_called_once_with(classes)
mock_prepare_imports.assert_called_once()
mock_prepare_imports.render_classes()
mock_render_module.assert_called_once_with(
imports=mock_prepare_imports.return_value,
output=mock_render_classes.return_value,
)
def test_add_import(self):
self.assertEqual(0, len(self.resolver.imports))
package = "here.there"
foo_qname = "foo"
bar_qname = "bar"
self.resolver.add_import(foo_qname, package, False)
self.resolver.add_import(bar_qname, package, True)
first = PackageFactory.create(name="foo", source=package, alias=None)
second = PackageFactory.create(name="bar", source=package, alias="there:bar")
self.assertEqual(2, len(self.resolver.imports))
self.assertEqual(first, self.resolver.imports[0])
self.assertEqual(second, self.resolver.imports[1])
self.assertEqual({bar_qname: "there:bar"}, self.resolver.aliases)
def test_process_import(self):
package = PackageFactory.create(name="bar",
alias="foo:bar",
source="some.foo.bar")
actual = generator.process_import(package)
self.assertIs(actual, package)
self.assertEqual("Bar", package.name)
self.assertEqual("FooBar", package.alias)
self.assertEqual("some.foo.bar", package.source)
def test_sorted_imports(self):
packages = [
PackageFactory.create(name=x, alias=None, source="foo") for x in "cab"
]
self.resolver.imports = packages
result = self.resolver.sorted_imports()
self.assertIsNot(packages, result)
self.assertEqual(packages[1], result[0])
self.assertEqual(packages[2], result[1])
self.assertEqual(packages[0], result[2])
def test_process(
self, mock_create_class_map, create_class_list, mock_resolve_imports
):
classes = ClassFactory.list(3)
mock_create_class_map.return_value = {"b": classes[0]}
create_class_list.return_value = classes[::-1]
self.resolver.imports.append(PackageFactory.create(name="foo", source="bar"))
self.resolver.aliases = {"a": "a"}
self.resolver.process(classes)
self.assertEqual([], self.resolver.imports)
self.assertEqual({}, self.resolver.aliases)
self.assertEqual(mock_create_class_map.return_value, self.resolver.class_map)
self.assertEqual(create_class_list.return_value, self.resolver.class_list)
mock_resolve_imports.assert_called_once_with()
def test_prepare_imports(self, mock_process_import):
packages = [
PackageFactory.create(name="foo", source="omg"),
PackageFactory.create(name="bar", source="omg"),
PackageFactory.create(name="thug", source="life"),
]
processed = [
PackageFactory.create(name="aaa", source="a"),
PackageFactory.create(name="bbb", source="b"),
PackageFactory.create(name="ccc", source="c"),
]
mock_process_import.side_effect = processed
expected = {"omg": processed[:2], "life": processed[2:]}
actual = DataclassGenerator().prepare_imports(packages)
self.assertEqual(expected, actual)
