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])