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
