def test_append(self):
# When adding a new item to the list, the behavior is to test if
# a release with the same name and version number already exists,
# and if so, to add a new distribution for it. If the distribution type
# is already defined too, add url informations to the existing DistInfo
# object.
releases = ReleasesList("FooBar", [
ReleaseInfo("FooBar", "1.1", url="external_url",
dist_type="sdist"),
])
self.assertEqual(1, len(releases))
releases.add_release(release=ReleaseInfo("FooBar",
"1.1",
url="internal_url",
is_external=False,
dist_type="sdist"))
self.assertEqual(1, len(releases))
self.assertEqual(2, len(releases[0]['sdist'].urls))
releases.add_release(
release=ReleaseInfo("FooBar", "1.1.1", dist_type="sdist"))
self.assertEqual(2, len(releases))
# when adding a distribution whith a different type, a new distribution
# has to be added.
releases.add_release(
release=ReleaseInfo("FooBar", "1.1.1", dist_type="bdist"))
self.assertEqual(2, len(releases))
self.assertEqual(2, len(releases[1].dists))
def get_releases(self,
requirements,
prefer_final=None,
show_hidden=True,
force_update=False):
"""Return the list of existing releases for a specific project.
Cache the results from one call to another.
If show_hidden is True, return the hidden releases too.
If force_update is True, reprocess the index to update the
informations (eg. make a new XML-RPC call).
::
>>> client = Client()
>>> client.get_releases('Foo')
['1.1', '1.2', '1.3']
If no such project exists, raise a ProjectNotFound exception::
>>> client.get_project_versions('UnexistingProject')
ProjectNotFound: UnexistingProject
"""
def get_versions(project_name, show_hidden):
return self.proxy.package_releases(project_name, show_hidden)
predicate = get_version_predicate(requirements)
prefer_final = self._get_prefer_final(prefer_final)
project_name = predicate.name
if not force_update and (project_name.lower() in self._projects):
project = self._projects[project_name.lower()]
if not project.contains_hidden and show_hidden:
# if hidden releases are requested, and have an existing
# list of releases that does not contains hidden ones
all_versions = get_versions(project_name, show_hidden)
existing_versions = project.get_versions()
hidden_versions = set(all_versions) - set(existing_versions)
for version in hidden_versions:
project.add_release(release=ReleaseInfo(
project_name, version, index=self._index))
else:
versions = get_versions(project_name, show_hidden)
if not versions:
raise ProjectNotFound(project_name)
project = self._get_project(project_name)
project.add_releases([
ReleaseInfo(project_name, version, index=self._index)
for version in versions
])
project = project.filter(predicate)
if len(project) == 0:
raise ReleaseNotFound("%s" % predicate)
project.sort_releases(prefer_final)
return project
def test_comparison(self):
# Test that we can compare DistInfoributionInfoList
foo1 = ReleaseInfo("foo", "1.0")
foo2 = ReleaseInfo("foo", "2.0")
bar = ReleaseInfo("bar", "2.0")
# assert we use the version to compare
self.assertTrue(foo1 < foo2)
self.assertFalse(foo1 > foo2)
self.assertFalse(foo1 == foo2)
# assert we can't compare dists with different names
self.assertRaises(TypeError, foo1.__eq__, bar)
def test_prefer_final(self):
# Can order the distributions using prefer_final
fb10 = ReleaseInfo("FooBar", "1.0") # final distribution
fb11a = ReleaseInfo("FooBar", "1.1a1") # alpha
fb12a = ReleaseInfo("FooBar", "1.2a1") # alpha
fb12b = ReleaseInfo("FooBar", "1.2b1") # beta
dists = ReleasesList("FooBar", [fb10, fb11a, fb12a, fb12b])
dists.sort_releases(prefer_final=True)
self.assertEqual(fb10, dists[0])
dists.sort_releases(prefer_final=False)
self.assertEqual(fb12b, dists[0])
def test_filter(self):
# Test we filter the distributions the right way, using version
# predicate match method
releases = ReleasesList('FooBar', (
ReleaseInfo("FooBar", "1.1"),
ReleaseInfo("FooBar", "1.1.1"),
ReleaseInfo("FooBar", "1.2"),
ReleaseInfo("FooBar", "1.2.1"),
))
filtered = releases.filter(VersionPredicate("FooBar (<1.2)"))
self.assertNotIn(releases[2], filtered)
self.assertNotIn(releases[3], filtered)
self.assertIn(releases[0], filtered)
self.assertIn(releases[1], filtered)
def get_metadata(self, project_name, version):
"""Retrieve project metadata.
Return a ReleaseInfo object, with metadata informations filled in.
"""
# to be case-insensitive, get the informations from the XMLRPC API
projects = [
d['name'] for d in self.proxy.search({'name': project_name})
if d['name'].lower() == project_name
]
if len(projects) > 0:
project_name = projects[0]
metadata = self.proxy.release_data(project_name, version)
project = self._get_project(project_name)
if version not in project.get_versions():
project.add_release(
release=ReleaseInfo(project_name, version, index=self._index))
release = project.get_release(version)
release.set_metadata(metadata)
return release
def search_projects(self, name=None, operator="or", **kwargs):
"""Find using the keys provided in kwargs.
You can set operator to "and" or "or".
"""
for key in kwargs:
if key not in _SEARCH_FIELDS:
raise InvalidSearchField(key)
if name:
kwargs["name"] = name
projects = self.proxy.search(kwargs, operator)
for p in projects:
project = self._get_project(p['name'])
try:
project.add_release(
release=ReleaseInfo(p['name'],
p['version'],
metadata={'summary': p['summary']},
index=self._index))
except IrrationalVersionError as e:
logger.warning("Irrational version error found: %s", e)
return [self._projects[p['name'].lower()] for p in projects]
def get_distributions(self, project_name, version):
"""Grab informations about distributions from XML-RPC.
Return a ReleaseInfo object, with distribution-related informations
filled in.
"""
url_infos = self.proxy.release_urls(project_name, version)
project = self._get_project(project_name)
if version not in project.get_versions():
project.add_release(
release=ReleaseInfo(project_name, version, index=self._index))
release = project.get_release(version)
for info in url_infos:
packagetype = info['packagetype']
dist_infos = {
'url': info['url'],
'hashval': info['md5_digest'],
'hashname': 'md5',
'is_external': False,
'python_version': info['python_version']
}
release.add_distribution(packagetype, **dist_infos)
return release
def test_add_dist(self):
# empty distribution type should assume "sdist"
release = ReleaseInfo("FooBar", "1.1")
release.add_distribution(url="http://example.org/")
# should not fail
release['sdist']
def test_add_dist(self):
# empty distribution type should assume "sdist"
release = ReleaseInfo("FooBar", "1.1")
release.add_distribution(url="http://example.org/")
# should not fail
release['sdist']
def test_instantiation(self):
# Test the DistInfo class provides us the good attributes when
# given on construction
release = ReleaseInfo("FooBar", "1.1")
self.assertEqual("FooBar", release.name)
self.assertEqual("1.1", "%s" % release.version)