def test_set_part(self):
self.assertEqual('rel/v2/6.2.3',
str(semantic_version('rel/v2/1.2.3').set_part(0, 6)))
self.assertEqual('rel/v2/1.6.3',
str(semantic_version('rel/v2/1.2.3').set_part(1, 6)))
self.assertEqual('rel/v2/1.2.6',
str(semantic_version('rel/v2/1.2.3').set_part(2, 6)))
def test_upgrade(self):
tmp_dir = self.make_temp_dir()
options = pip_project_options(root_dir = tmp_dir,
python_exe = python_testing._PYTHONS.ANY_PYTHON3,
debug = self.DEBUG)
project = pip_project(options = options)
project.install('pyinstaller', version = '3.5')
rv = project.call_program([ 'pyinstaller', '--version' ])
old_version = semantic_version(project.version('pyinstaller'))
self.assertEqual( '3.5', old_version )
project.upgrade('pyinstaller')
new_version = semantic_version(project.version('pyinstaller'))
self.assertTrue( new_version > old_version )
def __init__(self, version):
if check.is_python_version(version):
version = str(version)
elif check.is_int(version):
version = str(version)
self._ver = semantic_version(version)
if len(self._ver) not in (1, 2, 3):
raise python_error('Invalid python version: "{}"'.format(version))
def test__match_clause(self):
self.assertEqual(True, semantic_version('3.9').match_clause('== 3.9'))
self.assertEqual(False, semantic_version('3.9').match_clause('!= 3.9'))
self.assertEqual(False, semantic_version('3.9').match_clause('< 3.9'))
self.assertEqual(True, semantic_version('3.9').match_clause('> 3.8'))
self.assertEqual(True, semantic_version('3.9').match_clause('<= 3.9'))
self.assertEqual(True, semantic_version('3.9').match_clause('>= 3.8'))
def test_upgrade_many_packages(self):
requirements_content = '''\
idna == 2.7
chardet == 3.0.4
certifi == 2021.5.30
'''
tmp_requirements = self.make_temp_file(content=requirements_content)
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
rv = self.run_program(
self._program,
tester.make_args('install_requirements', tmp_requirements))
self.assertEqual(0, rv.exit_code)
installed_before = tester.installed_dict()
self.assertEqual('2.7', installed_before['idna'])
self.assertEqual('3.0.4', installed_before['chardet'])
self.assertEqual('2021.5.30', installed_before['certifi'])
rv = self.run_program(
self._program,
tester.make_args('upgrade', 'idna', 'chardet', 'certifi'))
self.assertEqual(0, rv.exit_code)
installed_after = tester.installed_dict()
self.assertTrue(
semantic_version(installed_after['idna']) > semantic_version('2.7')
)
self.assertTrue(
semantic_version(installed_after['chardet']) > semantic_version(
'3.0.4'))
self.assertTrue(
semantic_version(installed_after['certifi']) > semantic_version(
'2021.5.30'))
def test_upgrade_one_package(self):
tester = _pip_project_tester(self)
rv = tester.create()
self.assertEqual(0, rv.exit_code)
old_version = semantic_version('3.0.4')
rv = self.run_program(
self._program,
tester.make_args('install', 'chardet', '--version',
str(old_version)))
self.assertEqual(0, rv.exit_code)
installed_before = tester.installed_dict()
self.assertEqual(str(old_version), installed_before['chardet'])
rv = self.run_program(self._program,
tester.make_args('upgrade', 'chardet'))
self.assertEqual(0, rv.exit_code)
installed_after = tester.installed_dict()
new_version = semantic_version(installed_after['chardet'])
self.assertTrue(new_version > old_version)
def test_has_only_semantic_tokens(self):
self.assertTrue(semantic_version('1.2.3').has_only_semantic_tokens)
self.assertTrue(semantic_version('1.2;3').has_only_semantic_tokens)
self.assertTrue(semantic_version('1.2-3').has_only_semantic_tokens)
self.assertFalse(
semantic_version('1.2.alpha').has_only_semantic_tokens)
self.assertFalse(semantic_version('1.2.3a').has_only_semantic_tokens)
self.assertFalse(
semantic_version('amazing/1.2.3').has_only_semantic_tokens)
def test___gt__(self):
self.assertFalse(
semantic_version('rel/v2/1.2.1') > semantic_version(
'rel/v2/1.2.10'))
self.assertFalse(
semantic_version('rel/v2/1.2.1') > semantic_version('rel/v2/1.2.1')
)
self.assertTrue(
semantic_version('rel/v2/1.2.10') > semantic_version(
'rel/v2/1.2.1'))
def test___ne__(self):
self.assertFalse(
semantic_version('rel/v2/1.2.1') != semantic_version(
'rel/v2/1.2.1'))
self.assertTrue(
semantic_version('sel/v2/1.2.1') != semantic_version(
'rel/v2/1.2.1'))
self.assertTrue(
semantic_version('rels/v2/1.2.1') != semantic_version(
'rel/v2/1.2.1'))
def __init__(self,
clauses=None,
action=None,
category=None,
python_version=None):
check.check_string(action, allow_none=True)
check.check_string(python_version, allow_none=True)
check.check_class(category, allow_none=True)
python_version = semantic_version(python_version
or self._python_system_version())
self._matches = self._python_version_matches(python_version, clauses)
self._clauses = clauses
self._action = action
self._category = category
def _find_all_exes(clazz, sanitize_path=True):
'Return all the executables in PATH and other platform specific places'
if not sanitize_path in clazz._all_exes_cache:
exe_patterns = python_source.possible_python_exe_patterns()
extra_path = python_source.possible_python_bin_dirs()
env_path = os_env_var('PATH').path + extra_path
if sanitize_path:
sanitized_env_path = clazz._sanitize_env_path(env_path)
else:
sanitized_env_path = env_path
result = file_path.glob(sanitized_env_path, exe_patterns)
result = [f for f in result if not file_symlink.is_broken(f)]
clazz._log.log_d(' exe_patterns={}'.format(exe_patterns))
clazz._log.log_d(' env_path={}'.format(env_path))
clazz._log.log_d(' extra_path={}'.format(extra_path))
clazz._log.log_d(
'sanitized_env_path={}'.format(sanitized_env_path))
clazz._log.log_d(' result={}'.format(result))
clazz._all_exes_cache[sanitize_path] = sorted(
result,
key=lambda exe: semantic_version(str(clazz.version(exe))
)._tokens,
reverse=True)
return clazz._all_exes_cache[sanitize_path]
def test__tokens_to_string_different_delimiters(self):
self.assertEqual(
'1.0.0-4',
semantic_version._tokens_to_string(
semantic_version('1.0.0-4')._tokens))
def test__part_tokens_with_gaps(self):
self.assertEqual(
'1234',
semantic_version._tokens_to_string(
semantic_version('rel/v2/1.2.3-4')._part_tokens))
def test_parts(self):
self.assertEqual((1, 2, 3), semantic_version('rel/v2/1.2.3').parts)
self.assertEqual((1, 2), semantic_version('1.2').parts)
self.assertEqual((1, ), semantic_version('1').parts)
def test_check_with_cast(self):
self.assertEqual(semantic_version('1.2.3'),
check.check_semantic_version('1.2.3'))
def test_change_part_invalid_part(self):
with self.assertRaises(semantic_version_error) as ctx:
semantic_version('rel/v2/1.2.3').change_part(4, 1)
def test_part_value(self):
self.assertEqual(1, semantic_version('rel/v2/1.2.3').part_value(0))
self.assertEqual(2, semantic_version('rel/v2/1.2.3').part_value(1))
self.assertEqual(3, semantic_version('rel/v2/1.2.3').part_value(2))
def test_change_part_revision(self):
self.assertEqual(
'rel/v2/1.2.4',
str(semantic_version('rel/v2/1.2.3').change_part(2, 1)))
def test_change_part_minor(self):
self.assertEqual(
'rel/v2/1.3.3',
str(semantic_version('rel/v2/1.2.3').change_part(1, 1)))
def test__tokens_to_string(self):
self.assertEqual(
'1.0.0',
semantic_version._tokens_to_string(
semantic_version('1.0.0')._tokens))
def _make_list(clazz, s):
parts = [p for p in s.split(' ') if p]
return semantic_version_list([semantic_version(p) for p in parts])
def test__tokens_to_string_mixture(self):
self.assertEqual(
'rel/foo/1.2.3-4',
semantic_version._tokens_to_string(
semantic_version('rel/foo/1.2.3-4')._tokens))
def test__tokens_to_string_empty_string(self):
self.assertEqual(
'',
semantic_version._tokens_to_string(semantic_version('')._tokens))
def test___getitem__(self):
self.assertEqual(1, semantic_version('rel/v2/1.2.3')[0])
self.assertEqual(2, semantic_version('rel/v2/1.2.3')[1])
self.assertEqual(3, semantic_version('rel/v2/1.2.3')[2])
