def test_write(self):
dfn = self.temp_filename()
# Read legacy, write new
sfn = os.path.join(HERE, 'fake_dists', 'choxie-2.0.0.9.dist-info',
LEGACY_METADATA_FILENAME)
md = Metadata(path=sfn)
md.write(path=dfn)
with codecs.open(dfn, 'r', 'utf-8') as f:
data = json.load(f)
self.assertEqual(
data, {
'metadata_version': '2.0',
'generator': 'distlib (%s)' % __version__,
'name': 'choxie',
'version': '2.0.0.9',
'license': 'BSD',
'summary': 'Chocolate with a kick!',
'description': 'Chocolate with a longer kick!',
'provides': ['truffles (1.0)', 'choxie (2.0.0.9)'],
'run_requires': [{
'requires': ['towel-stuff (0.1)', 'nut']
}],
'keywords': [],
})
# Write legacy, compare with original
md.write(path=dfn, legacy=True)
nmd = Metadata(path=dfn)
d1 = md.todict()
d2 = nmd.todict()
self.assertEqual(d1, d2)
def test_init(self):
"Test initialisation"
md = Metadata()
self.assertIsNone(md._legacy)
self.assertRaises(MetadataMissingError, md.validate)
md.name = 'dummy'
self.assertRaises(MetadataMissingError, md.validate)
md.version = '0.1'
self.assertRaises(MetadataMissingError, md.validate)
md.summary = 'Summary'
md.validate()
self.assertEqual(md.name, 'dummy')
self.assertEqual(md.version, '0.1')
# Initialise from mapping
md = Metadata(
mapping={
'metadata_version': '2.0',
'name': 'foo',
'version': '0.3.4',
'summary': 'Summary',
})
md.validate()
self.assertEqual(md.name, 'foo')
self.assertEqual(md.version, '0.3.4')
self.assertEqual(md.run_requires, [])
self.assertEqual(md.meta_requires, [])
self.assertEqual(md.provides, ['foo (0.3.4)'])
# Initialise from legacy metadata
fn = os.path.join(HERE, 'fake_dists', 'choxie-2.0.0.9.dist-info',
LEGACY_METADATA_FILENAME)
md = Metadata(path=fn)
md.validate()
self.assertIsNotNone(md._legacy)
self.assertEqual(set(md.run_requires),
set(['towel-stuff (0.1)', 'nut']))
self.assertEqual(md.metadata_version, '1.2')
self.assertEqual(md.version, '2.0.0.9')
self.assertEqual(md.meta_requires, [])
self.assertEqual(set(md.provides),
set(['choxie (2.0.0.9)', 'truffles (1.0)']))
# Initialise from new metadata
fn = os.path.join(HERE, METADATA_FILENAME)
md = Metadata(path=fn)
md.validate()
self.assertIsNone(md._legacy)
self.assertEqual(md.metadata_version, '2.0')
self.assertEqual(md.name, 'foobar')
self.assertEqual(md.version, '0.1')
self.assertEqual(md.provides, ['foobar (0.1)'])
def test_add_requirements(self):
md = Metadata()
md.name = 'bar'
md.version = '0.5'
md.add_requirements(['foo (0.1.2)'])
self.assertEqual(md.run_requires, [{'requires': ['foo (0.1.2)']}])
fn = os.path.join(HERE, 'fake_dists', 'choxie-2.0.0.9.dist-info',
LEGACY_METADATA_FILENAME)
md = Metadata(path=fn)
md.add_requirements(['foo (0.1.2)'])
self.assertEqual(set(md.run_requires),
set(['towel-stuff (0.1)', 'nut', 'foo (0.1.2)']))
def convert_egg_info(libdir, prefix, options):
files = os.listdir(libdir)
ei = list(filter(lambda d: d.endswith('.egg-info'), files))[0]
olddn = os.path.join(libdir, ei)
di = EGG_INFO_RE.sub('.dist-info', ei)
newdn = os.path.join(libdir, di)
os.rename(olddn, newdn)
if options.compatible:
renames = {}
else:
renames = {
'entry_points.txt': 'EXPORTS',
}
excludes = set([
'SOURCES.txt', # of no interest in/post WHEEL
'installed-files.txt', # replaced by RECORD, so not needed
'requires.txt', # added to METADATA, so not needed
'PKG-INFO', # replaced by METADATA
'not-zip-safe', # not applicable
])
files = os.listdir(newdn)
metadata = mdname = reqts = None
for oldfn in files:
pn = os.path.join(newdn, oldfn)
if oldfn in renames:
os.rename(pn, os.path.join(newdn, renames[oldfn]))
else:
if oldfn == 'requires.txt':
with open(pn, 'r') as f:
reqts = get_requirements(f.read())
elif oldfn == 'PKG-INFO':
metadata = Metadata(path=pn)
pd = get_package_data(metadata.name, metadata.version)
metadata = Metadata(mapping=pd['index-metadata'])
mdname = os.path.join(newdn, 'pydist.json')
if oldfn in excludes or not options.compatible:
os.remove(pn)
if metadata:
# Use Metadata 1.2 or later
metadata.provides += ['%s (%s)' % (metadata.name,
metadata.version)]
# Update if not set up by get_package_data
if reqts and not metadata.run_requires:
metadata.dependencies = reqts
metadata.write(path=mdname)
manifest = Manifest(os.path.dirname(libdir))
manifest.findall()
paths = manifest.allfiles
dp = DistributionPath([libdir])
dist = next(dp.get_distributions())
dist.write_installed_files(paths, prefix)
def test_upload_documentation(self):
"Test upload of documentation"
raise unittest.SkipTest('Skipped, as pythonhosted.org is being '
'de-emphasised and this functionality may '
'no longer be available')
self.check_pypi_server_available()
self.check_testdist_available()
d = os.path.join(HERE, self.testdir)
data = self.load_package_metadata(d)
md = Metadata(mapping=data)
d = os.path.join(d, 'doc')
# Non-existent directory
self.assertRaises(DistlibException, self.index.upload_documentation,
md, d + '-random')
# Directory with no index.html
self.assertRaises(DistlibException, self.index.upload_documentation,
md, HERE)
response = self.index.upload_documentation(md, d)
self.assertEqual(response.code, 200)
if not self.run_test_server:
url = 'http://packages.python.org/%s/' % self.dist_project
response = urlopen(url)
self.assertEqual(response.code, 200)
data = response.read()
expected = b'This is dummy documentation'
self.assertIn(expected, data)
def test_valid(self):
"""
Tests to check that missing and invalid metadata is caught.
"""
md = Metadata()
self.assertRaises(MetadataMissingError, md.validate)
try:
md.name = 'Foo Bar'
except MetadataInvalidError:
pass
md.name = 'foo_bar'
# Name now OK, but version and summary to be checked
self.assertRaises(MetadataMissingError, md.validate)
try:
md.version = '1.0a'
except MetadataInvalidError:
pass
md.version = '1.0'
# Name and version now OK, but summary to be checked
self.assertRaises(MetadataMissingError, md.validate)
try:
md.summary = ''
except MetadataInvalidError:
pass
try:
md.summary = ' ' * 2048
except MetadataInvalidError:
pass
md.summary = ' ' * 2047
md.validate()
md.summary = ' '
md.validate()
def process_egg(egg):
logger.debug(egg)
pkginfo = os.path.join(egg, 'PKG-INFO')
toplevel = os.path.join(egg, 'top_level.txt')
if os.path.exists(pkginfo):
metadata = Metadata(path=pkginfo)
logger.debug(metadata.todict())
return metadata
def test_register(self):
"Test registration"
self.check_pypi_server_available()
self.check_testdist_available()
d = os.path.join(HERE, self.testdir)
data = self.load_package_metadata(d)
md = Metadata()
self.assertRaises(MetadataMissingError, self.index.register, md)
md.name = self.dist_project
self.assertRaises(MetadataMissingError, self.index.register, md)
md.version = data['version']
md.summary = data['summary']
response = self.index.register(md)
self.assertEqual(response.code, 200)
def _make_distributions(metadata_list, locator_url):
from distlib.database import Distribution
from distlib.metadata import Metadata
distributions = []
url = locator_url + "/packages/"
for md in metadata_list:
try:
wheel = md["wheel"]
except KeyError:
pass
else:
md["source_url"] = url + wheel
del md["wheel"]
distributions.append(Distribution(Metadata(mapping=md)))
return distributions
def test_get_file(self):
# Create a fake dist
temp_site_packages = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, temp_site_packages)
dist_name = 'test'
dist_info = os.path.join(temp_site_packages, 'test-0.1.dist-info')
os.mkdir(dist_info)
metadata_path = os.path.join(dist_info, 'pydist.json')
resources_path = os.path.join(dist_info, 'RESOURCES')
md = Metadata()
md.name = 'test'
md.version = '0.1'
md.summary = 'test'
md.write(path=metadata_path)
test_path = 'test.cfg'
fd, test_resource_path = tempfile.mkstemp()
os.close(fd)
self.addCleanup(os.remove, test_resource_path)
fp = open(test_resource_path, 'w')
try:
fp.write('Config')
finally:
fp.close()
fp = open(resources_path, 'w')
try:
fp.write('%s,%s' % (test_path, test_resource_path))
finally:
fp.close()
# Add fake site-packages to sys.path to retrieve fake dist
self.addCleanup(sys.path.remove, temp_site_packages)
sys.path.insert(0, temp_site_packages)
# Try to retrieve resources paths and files
d = DistributionPath()
self.assertEqual(d.get_file_path(dist_name, test_path),
test_resource_path)
self.assertRaises(KeyError, d.get_file_path, dist_name, 'i-dont-exist')
def convert_egg_info(libdir, prefix):
files = os.listdir(libdir)
ei = list(filter(lambda d: d.endswith('.egg-info'), files))[0]
olddn = os.path.join(libdir, ei)
di = EGG_INFO_RE.sub('.dist-info', ei)
newdn = os.path.join(libdir, di)
os.rename(olddn, newdn)
files = os.listdir(newdn)
for oldfn in files:
pn = os.path.join(newdn, oldfn)
if oldfn == 'PKG-INFO':
md = Metadata(path=pn)
mn = os.path.join(newdn, METADATA_FILENAME)
md.write(mn)
os.remove(pn)
manifest = Manifest(os.path.dirname(libdir))
manifest.findall()
dp = DistributionPath([libdir])
dist = next(dp.get_distributions())
dist.write_installed_files(manifest.allfiles, prefix)
def test_upload(self):
"Test upload"
self.check_pypi_server_available()
self.check_testdist_available()
if self.run_test_server:
self.remove_package(self.dist_project, self.dist_version)
d = os.path.join(HERE, self.testdir)
data = self.load_package_metadata(d)
md = Metadata(mapping=data)
self.index.gpg_home = os.path.join(HERE, 'keys')
try:
zip_name = os.path.join(HERE, '%s.zip' % self.testdir)
self.assertRaises(DistlibException, self.index.upload_file, md,
'random-' + zip_name, 'Test User', 'tuser')
response = self.index.upload_file(md, zip_name, 'Test User',
'tuser')
self.assertEqual(response.code, 200)
if self.run_test_server:
fn = os.path.join(HERE, 'packages', os.path.basename(zip_name))
self.assertTrue(os.path.exists(fn))
except HTTPError as e:
# Treat as success if it already exists
if e.getcode() != 400 or 'already exists' not in e.msg:
raise
def test_requirements(self):
fn = os.path.join(HERE, METADATA_FILENAME)
md = Metadata(path=fn)
self.assertEqual(md.meta_requires, [{'requires': ['bar (1.0)']}])
r = md.get_requirements(md.run_requires)
self.assertEqual(r, ['foo'])
r = md.get_requirements(md.run_requires, extras=['certs'])
self.assertEqual(r, ['foo', 'certifi (0.0.8)'])
r = md.get_requirements(md.run_requires, extras=['certs', 'ssl'])
if sys.platform != 'win32':
self.assertEqual(r, ['foo', 'certifi (0.0.8)'])
else:
self.assertEqual(
set(r), set(['foo', 'certifi (0.0.8)', 'wincertstore (0.1)']))
for ver in ('2.5', '2.4'):
env = {'python_version': ver}
r = md.get_requirements(md.run_requires,
extras=['certs', 'ssl'],
env=env)
if sys.platform != 'win32':
self.assertEqual(set(r),
set(['foo', 'certifi (0.0.8)', 'ssl (1.16)']))
elif ver == '2.4':
self.assertEqual(
set(r),
set([
'certifi (0.0.8)', 'ssl (1.16)', 'wincertstore (0.1)',
'foo', 'ctypes (1.0.2)'
]))
else:
self.assertEqual(
set(r),
set([
'certifi (0.0.8)', 'ssl (1.16)', 'wincertstore (0.1)',
'foo'
]))
env['sys_platform'] = 'win32'
r = md.get_requirements(md.run_requires,
extras=['certs', 'ssl'],
env=env)
self.assertEqual(
set(r),
set([
'foo', 'certifi (0.0.8)', 'ssl (1.16)', 'ctypes (1.0.2)',
'wincertstore (0.1)'
]))
env['python_version'] = '2.5'
r = md.get_requirements(md.run_requires,
extras=['certs', 'ssl'],
env=env)
self.assertEqual(
set(r),
set(['foo', 'certifi (0.0.8)', 'ssl (1.16)',
'wincertstore (0.1)']))
r = md.get_requirements(md.run_requires, extras=[':test:'])
self.assertEqual(r, ['foo', 'nose'])
r = md.get_requirements(md.run_requires, extras=[':test:', 'udp'])
self.assertEqual(set(r), set(['foo', 'nose', 'nose-udp']))
self.assertEqual(
md.dependencies, {
'provides': ['foobar (0.1)'],
'meta_requires': [{
'requires': ['bar (1.0)']
}],
'extras': ['ssl', 'certs'],
'build_requires': [],
'test_requires': [{
'requires': ['nose'],
}, {
'requires': ['nose-udp'],
'extra': 'udp',
}],
'run_requires': [{
'requires': ['foo']
}, {
'requires': ['certifi (0.0.8)'],
'extra': 'certs',
}, {
'requires': ['wincertstore (0.1)'],
'extra': 'ssl',
'environment': "sys_platform=='win32'",
}, {
'requires': ['ctypes (1.0.2)'],
'extra':
'ssl',
'environment':
"sys_platform=='win32' and "
"python_version=='2.4'",
}, {
'requires': ['ssl (1.16)'],
'extra': 'ssl',
'environment': "python_version in '2.4, 2.5'",
}]
})
def wheel_modifier_ver(self, path_map):
mdpath = path_map['dummy-0.1.dist-info/%s' % LEGACY_METADATA_FILENAME]
md = Metadata(path=mdpath)
md.version = '0.1+123'
md.write(path=mdpath, legacy=True)
return True
def wheel_modifier(self, path_map):
mdpath = path_map['dummy-0.1.dist-info/%s' % LEGACY_METADATA_FILENAME]
md = Metadata(path=mdpath)
md.add_requirements(['numpy'])
md.write(path=mdpath, legacy=True)
return True
def wheel_modifier_ver(self, path_map):
mdpath = path_map['dummy-0.1.dist-info/pydist.json']
md = Metadata(path=mdpath)
md.version = '0.1+123'
md.write(path=mdpath)
return True
def wheel_modifier(self, path_map):
mdpath = path_map['dummy-0.1.dist-info/pydist.json']
md = Metadata(path=mdpath)
md.add_requirements(['numpy'])
md.write(path=mdpath)
return True
