def test(): """Global test on all types """ v = Version('test.txt', 'actual.txt', 'expected.txt') expectedFile = Path(v.expectedFile) if expectedFile.is_file(): with open(v.expectedFile, "r") as ins: x = 0 for line in ins: assert line.split()[0] == v.solutionList[x] x += 1
def test_allows(): v = Version.parse("1.2.3") assert v.allows(v) assert not v.allows(Version.parse("2.2.3")) assert not v.allows(Version.parse("1.3.3")) assert not v.allows(Version.parse("1.2.4")) assert not v.allows(Version.parse("1.2.3-dev")) assert not v.allows(Version.parse("1.2.3+build"))
def test_intersect(): v = Version.parse("1.2.3") assert v.intersect(v) == v assert v.intersect(Version.parse("1.1.4")).is_empty() assert (v.intersect( VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))) == v) assert (Version.parse("1.1.4").intersect( VersionRange(v, Version.parse("1.2.4"))).is_empty())
def test_difference(): v = Version.parse("1.2.3") assert v.difference(v).is_empty() assert v.difference(Version.parse("0.8.0")) == v assert v.difference( VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))).is_empty() assert (v.difference( VersionRange(Version.parse("1.4.0"), Version.parse("3.0.0"))) == v)
def add(self, name, version, deps=None): # type: (str, str, Optional[Dict[str, str]]) -> None if deps is None: deps = {} version = Version.parse(version) if name not in self._packages: self._packages[name] = {} if version in self._packages[name]: raise ValueError("{} ({}) already exists".format(name, version)) dependencies = [] for dep_name, spec in deps.items(): dependencies.append(Dependency(dep_name, spec)) self._packages[name][version] = dependencies
def add(self, name, extras, version, deps = None): version = Version.parse(version) if name not in self._packages: self._packages[name] = { extras: {} } if extras not in self._packages[name]: self._packages[name][extras] = {} if version in self._packages[name][extras] and not ( deps is None or self._packages[name][extras][version] is None ): raise ValueError("{} ({}) already exists".format(name, version)) if deps is None: self._packages[name][extras][version] = None else: dependencies = [] for dep in deps: dependencies.append(Dependency(dep)) self._packages[name][extras][version] = dependencies
def infer_function_environment_from_ci_environment(): import os import re from semver import Version # CircleCI is supported though contributions are welcome for other CI's. tag = os.environ["CIRCLE_TAG"] match = re.search(r"([a-z0-9-]+)@(.+)$", tag) if not match: raise ValueError( f'Malformed tag: {tag} (expected e.g. "[email protected]")') function_name, version = match.groups() if not Version.isvalid(version): raise ValueError(f"Version in tag {version} is not valid semver") return InferredFunctionEnvironment( function_name=function_name, version=version, sha1=None, )
def v200(): return Version.parse("2.0.0")
def test_version_info_should_be_accessed_with_slice_object( version, slice_object, expected): version_info = Version.parse(version) assert version_info[slice_object] == expected
from materialize import util from materialize.mzcompose import Composition, WorkflowArgumentParser from materialize.mzcompose.services import ( Kafka, Materialized, Postgres, SchemaRegistry, Testdrive, Zookeeper, ) # All released Materialize versions, in order from most to least recent. all_versions = util.known_materialize_versions() # The `materialized` options that are valid only at or above a certain version. mz_options = {Version.parse("0.9.2"): "--persistent-user-tables"} SERVICES = [ Zookeeper(), Kafka(), SchemaRegistry(), Postgres(), Materialized(options=" ".join(mz_options.values())), # N.B.: we need to use `validate_catalog=False` because testdrive uses HEAD # to load the catalog from disk but does *not* run migrations. There is no # guarantee that HEAD can load an old catalog without running migrations. # # When testdrive is targeting a HEAD materialized, we re-enable catalog # validation below by manually passing the `--validate-catalog` flag. # # Disabling catalog validation is preferable to using a versioned testdrive
def test_parse_should_return_tuple(self): for version, result in VALID_VERSIONS.items(): self.assertIsInstance(Version.parse(version), tuple, "{} should be a tuple type.".format(version))
def test_parse_constraint_multi_wilcard(input): assert parse_constraint(input) == VersionUnion( VersionRange(Version(2, 7, 0), Version(3, 0, 0), True, False), VersionRange(Version(3, 2, 0), None, True, False), )
from semver import Version from semver import VersionRange from semver import VersionUnion from semver import parse_constraint @pytest.mark.parametrize( "input,constraint", [ ("*", VersionRange()), ("*.*", VersionRange()), ("v*.*", VersionRange()), ("*.x.*", VersionRange()), ("x.X.x.*", VersionRange()), # ('!=1.0.0', Constraint('!=', '1.0.0.0')), (">1.0.0", VersionRange(min=Version(1, 0, 0))), ("<1.2.3", VersionRange(max=Version(1, 2, 3))), ("<=1.2.3", VersionRange(max=Version(1, 2, 3), include_max=True)), (">=1.2.3", VersionRange(min=Version(1, 2, 3), include_min=True)), ("=1.2.3", Version(1, 2, 3)), ("1.2.3", Version(1, 2, 3)), ("=1.0", Version(1, 0, 0)), ("1.2.3b5", Version(1, 2, 3, pre="b5")), (">= 1.2.3", VersionRange(min=Version(1, 2, 3), include_min=True)), (">dev", VersionRange(min=Version(0, 0, pre="dev"))), # Issue 206 ], ) def test_parse_constraint(input, constraint): assert parse_constraint(input) == constraint
def v300(): return Version.parse("3.0.0")
def v080(): return Version.parse("0.8.0")
def v010(): return Version.parse("0.1.0")
def test_allows_any(v003, v010, v072, v080, v114, v123, v124, v140, v200, v234, v250, v300): # disallows an empty constraint assert not VersionRange(v123, v250).allows_any(EmptyConstraint()) # allows allowed versions range = VersionRange(v123, v250, include_max=True) assert not range.allows_any(v123) assert range.allows_any(v124) assert range.allows_any(v250) assert not range.allows_any(v300) # with no min range = VersionRange(max=v200) assert range.allows_any(VersionRange(v140, v300)) assert not range.allows_any(VersionRange(v234, v300)) assert range.allows_any(VersionRange(v140)) assert not range.allows_any(VersionRange(v234)) assert range.allows_any(range) # with no max range = VersionRange(min=v072) assert range.allows_any(VersionRange(v003, v140)) assert not range.allows_any(VersionRange(v003, v010)) assert range.allows_any(VersionRange(max=v080)) assert not range.allows_any(VersionRange(max=v003)) assert range.allows_any(range) # with min and max range = VersionRange(v072, v200) assert range.allows_any(VersionRange(v003, v140)) assert range.allows_any(VersionRange(v140, v300)) assert not range.allows_any(VersionRange(v003, v010)) assert not range.allows_any(VersionRange(v234, v300)) assert not range.allows_any(VersionRange(max=v010)) assert not range.allows_any(VersionRange(v234)) assert range.allows_any(range) # allows a bordering range when both are inclusive assert not VersionRange(max=v250).allows_any(VersionRange(min=v250)) assert not VersionRange(max=v250, include_max=True).allows_any( VersionRange(min=v250)) assert not VersionRange(max=v250).allows_any( VersionRange(min=v250, include_min=True)) assert not VersionRange(min=v250).allows_any(VersionRange(max=v250)) assert VersionRange(max=v250, include_max=True).allows_any( VersionRange(min=v250, include_min=True)) # allows unions that are partially contained' range = VersionRange(v114, v200) assert range.allows_any(VersionRange(v010, v080).union(v140)) assert range.allows_any(VersionRange(v123, v234).union(v300)) assert not range.allows_any(VersionRange(v234, v300).union(v010)) # pre-release min does not allow lesser than itself range = VersionRange(Version.parse("1.9b1"), include_min=True) assert not range.allows_any( VersionRange( Version.parse("1.8.0"), Version.parse("1.9.0"), include_min=True, always_include_max_prerelease=True, ))
def get_latest_version(versions: Iterable[str]) -> str: try: versions = [Version.parse(version) for version in versions] except ValueError: return "couldn't determine: Not all versions are valid semver" return str(max(versions))
def test_version_info_should_throw_index_error_when_negative_index( version, index): version_info = Version.parse(version) with pytest.raises(IndexError, match=r"Version index cannot be negative"): version_info[index]
def test_version_info_should_throw_index_error(version, index): version_info = Version.parse(version) with pytest.raises(IndexError, match=r"Version part undefined"): version_info[index]
def v234(): return Version.parse("2.3.4")
def v250(): return Version.parse("2.5.0")
def v072(): return Version.parse("0.7.2")
def v003(): return Version.parse("0.0.3")
def v114(): return Version.parse("1.1.4")
def test_parse_constraint_multi(input): assert parse_constraint(input) == VersionRange(Version(2, 0, 0), Version(3, 0, 0), include_min=False, include_max=True)
def v124(): return Version.parse("1.2.4")
def test_successful_parse(self): for version, result in VALID_VERSIONS.items(): self.assertTupleEqual(Version.parse(version), result, "{} should be equal to {}.".format(version, result))
def v130(): return Version.parse("1.3.0")
def test_parse_tuple_should_contain_ints(self): for version in VALID_VERSIONS.keys(): for i in Version.parse(version): self.assertIsInstance(i, int, "{} in {} should be in integer.".format(i, version))
def v140(): return Version.parse("1.4.0")
def v123(): return Version.parse("1.2.3")
def test_version_info_should_be_accessed_with_index(version, index, expected): version_info = Version.parse(version) assert version_info[index] == expected