technofab/bumpver
1
0
Fork 0
mirror of https://github.com/TECHNOFAB11/bumpver.git synced 2025-12-12 14:30:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

readme updates

Browse source
This commit is contained in:
Manuel Barkhau 2020-09-17 16:24:21 +00:00
parent 32ad101b9f
commit 28e09fd60a
7 changed files with 356 additions and 214 deletions
Download patch file Download diff file Expand all files Collapse all files

4
test/test_cli.py
View file

@ -11,7 +11,7 @@ import pathlib2 as pl
from click.testing import CliRunner
import pycalver.config as config
import pycalver2.patterns as patterns
import pycalver.patterns as v1patterns
from pycalver.__main__ import cli
SETUP_CFG_FIXTURE = """
@ -81,7 +81,7 @@ def test_version(runner):
result = runner.invoke(cli, ['--version', "-vv"])
assert result.exit_code == 0
assert " version v20" in result.output
match = patterns.PYCALVER_RE.search(result.output)
match = v1patterns.PYCALVER_RE.search(result.output)
assert match

128
test/test_patterns.py
View file

@ -7,6 +7,134 @@ import pycalver2.patterns as v2patterns
# TODO (mb 2020-09-06): test for v2patterns
V2_PART_PATTERN_CASES = [
(['YYYY', 'GGGG'], "2020" , "2020"),
(['YYYY', 'GGGG'], "" , None),
(['YYYY', 'GGGG'], "A020" , None),
(['YYYY', 'GGGG'], "020" , None),
(['YYYY', 'GGGG'], "12020", None),
(['YY' , 'GG' ], "20" , "20"),
(['YY' , 'GG' ], "3" , "3"),
(['YY' , 'GG' ], "03" , None),
(['YY' , 'GG' ], "2X" , None),
(['YY' , 'GG' ], "" , None),
(['0Y' , '0G' ], "20" , "20"),
(['0Y' , '0G' ], "03" , "03"),
(['0Y' , '0G' ], "3" , None),
(['0Y' , '0G' ], "2X" , None),
(['0Y' , '0G' ], "" , None),
# quarter
(['Q'], "0", None),
(['Q'], "1", "1"),
(['Q'], "2", "2"),
(['Q'], "3", "3"),
(['Q'], "4", "4"),
(['Q'], "5", None),
(['Q'], "X", None),
# months
(['MM'], "0" , None),
(['MM'], "01", None),
(['MM'], "1" , "1"),
(['MM'], "10", "10"),
(['MM'], "12", "12"),
(['MM'], "13", None),
(['0M'], "00", None),
(['0M'], "1" , None),
(['0M'], "01", "01"),
(['MM'], "10", "10"),
(['MM'], "12", "12"),
(['MM'], "13", None),
# day of month
(['DD'], "0" , None),
(['DD'], "01", None),
(['DD'], "1" , "1"),
(['DD'], "10", "10"),
(['DD'], "31", "31"),
(['DD'], "32", None),
(['0D'], "00", None),
(['0D'], "1" , None),
(['0D'], "01", "01"),
(['0D'], "10", "10"),
(['0D'], "31", "31"),
(['0D'], "32", None),
(['DD'], "0" , None),
(['DD'], "01", None),
(['DD'], "1" , "1"),
(['DD'], "10", "10"),
(['DD'], "31", "31"),
(['DD'], "32", None),
(['0D'], "00", None),
(['0D'], "1" , None),
(['0D'], "01", "01"),
(['0D'], "10", "10"),
(['0D'], "31", "31"),
(['0D'], "32", None),
# day of year
(['JJJ'], "0" , None),
(['JJJ'], "01" , None),
(['JJJ'], "1" , "1"),
(['JJJ'], "10" , "10"),
(['JJJ'], "31" , "31"),
(['JJJ'], "32" , "32"),
(['JJJ'], "100", "100"),
(['JJJ'], "365", "365"),
(['JJJ'], "366", "366"),
(['JJJ'], "367", None),
(['00J'], "000", None),
(['00J'], "01" , None),
(['00J'], "1" , None),
(['00J'], "001", "001"),
(['00J'], "010", "010"),
(['00J'], "031", "031"),
(['00J'], "032", "032"),
(['00J'], "100", "100"),
(['00J'], "365", "365"),
(['00J'], "366", "366"),
(['00J'], "367", None),
# week numbers
(['WW', 'UU'], "00", None),
(['WW', 'UU'], "01", None),
(['WW', 'UU'], "0" , "0"),
(['WW', 'UU'], "1" , "1"),
(['WW', 'UU'], "10", "10"),
(['WW', 'UU'], "52", "52"),
(['WW', 'UU'], "53", None),
(['0W', '0U'], "00", "00"),
(['0W', '0U'], "01", "01"),
(['0W', '0U'], "0" , None),
(['0W', '0U'], "1" , None),
(['0W', '0U'], "10", "10"),
(['0W', '0U'], "52", "52"),
(['0W', '0U'], "53", None),
(['VV'], "00", None),
(['VV'], "01", None),
(['VV'], "0" , None),
(['VV'], "1" , "1"),
(['VV'], "10", "10"),
(['VV'], "52", "52"),
(['VV'], "53", "53"),
(['VV'], "54", None),
(['0V'], "00", None),
(['0V'], "01", "01"),
(['0V'], "0" , None),
(['0V'], "1" , None),
(['0V'], "10", "10"),
(['0V'], "52", "52"),
(['0V'], "53", "53"),
(['0V'], "54", None),
(['MAJOR', 'MINOR', 'PATCH', 'MICRO'], "0", "0"),
# ('TAG', ""),
# ('PYTAG', ""),
]
@pytest.mark.parametrize("parts, testcase, expected", V2_PART_PATTERN_CASES)
def test_part_patterns(parts, testcase, expected):
for part in parts:
pattern_str = v2patterns.PART_PATTERNS[part]
match = re.match("^" + pattern_str + "$", testcase)
assert (match is None and expected is None) or (match.group(0) == expected)
def _part_re_by_name(name):
return re.compile(v1patterns.PART_PATTERNS[name])

78
test/test_version.py
View file

@ -5,28 +5,30 @@ import datetime as dt
import pytest
from pycalver import version
from pycalver import patterns
import pycalver.version as v1version
import pycalver2.version as v2version
import pycalver.patterns as v1patterns
import pycalver2.patterns as v2patterns
def test_bump_beta():
cur_version = "v201712.0001-beta"
assert cur_version < version.incr(cur_version)
assert version.incr(cur_version).endswith("-beta")
assert version.incr(cur_version, release="alpha").endswith("-alpha")
assert version.incr(cur_version, release="final").endswith("0002")
assert cur_version < v1version.incr(cur_version)
assert v1version.incr(cur_version).endswith("-beta")
assert v1version.incr(cur_version, release="alpha").endswith("-alpha")
assert v1version.incr(cur_version, release="final").endswith("0002")
def test_bump_final():
cur_version = "v201712.0001"
assert cur_version < version.incr(cur_version)
assert version.incr(cur_version).endswith(".0002")
assert version.incr(cur_version, release="alpha").endswith("-alpha")
assert cur_version < v1version.incr(cur_version)
assert v1version.incr(cur_version).endswith(".0002")
assert v1version.incr(cur_version, release="alpha").endswith("-alpha")
assert version.incr(cur_version, release="final").endswith(".0002")
assert v1version.incr(cur_version, release="final").endswith(".0002")
pre_version = cur_version + "-beta"
assert version.incr(pre_version, release="final").endswith(".0002")
assert v1version.incr(pre_version, release="final").endswith(".0002")
def test_bump_future():
@ -34,7 +36,7 @@ def test_bump_future():
future_date = dt.datetime.today() + dt.timedelta(days=300)
future_calver = future_date.strftime("v%Y%m")
cur_version = future_calver + ".0001"
new_version = version.incr(cur_version)
new_version = v1version.incr(cur_version)
assert cur_version < new_version
@ -42,11 +44,11 @@ def test_bump_random(monkeypatch):
cur_date = dt.date(2016, 1, 1) + dt.timedelta(days=random.randint(1, 2000))
cur_version = cur_date.strftime("v%Y%m") + ".0001-dev"
monkeypatch.setattr(version, 'TODAY', cur_date)
monkeypatch.setattr(v1version, 'TODAY', cur_date)
for _ in range(1000):
cur_date += dt.timedelta(days=int((1 + random.random()) ** 10))
new_version = version.incr(
new_version = v1version.incr(
cur_version, release=random.choice([None, "alpha", "beta", "rc", "final", "post"])
)
assert cur_version < new_version
@ -55,7 +57,7 @@ def test_bump_random(monkeypatch):
def test_parse_version_info():
version_str = "v201712.0001-alpha"
version_info = version.parse_version_info(version_str)
version_info = v1version.parse_version_info(version_str)
# assert version_info.pep440_version == "201712.1a0"
# assert version_info.version == "v201712.0001-alpha"
@ -65,7 +67,7 @@ def test_parse_version_info():
assert version_info.tag == "alpha"
version_str = "v201712.0001"
version_info = version.parse_version_info(version_str)
version_info = v1version.parse_version_info(version_str)
# assert version_info.pep440_version == "201712.1"
# assert version_info.version == "v201712.0001"
@ -77,7 +79,7 @@ def test_parse_version_info():
def test_readme_pycalver1():
version_str = "v201712.0001-alpha"
version_info = patterns.PYCALVER_RE.match(version_str).groupdict()
version_info = v1patterns.PYCALVER_RE.match(version_str).groupdict()
assert version_info == {
'pycalver' : "v201712.0001-alpha",
@ -93,7 +95,7 @@ def test_readme_pycalver1():
def test_readme_pycalver2():
version_str = "v201712.0033"
version_info = patterns.PYCALVER_RE.match(version_str).groupdict()
version_info = v1patterns.PYCALVER_RE.match(version_str).groupdict()
assert version_info == {
'pycalver' : "v201712.0033",
@ -109,40 +111,40 @@ def test_readme_pycalver2():
def test_parse_error_empty():
try:
version.parse_version_info("")
v1version.parse_version_info("")
assert False
except version.PatternError as err:
except v1version.PatternError as err:
assert "Invalid version string" in str(err)
def test_parse_error_noprefix():
try:
version.parse_version_info("201809.0002")
v1version.parse_version_info("201809.0002")
assert False
except version.PatternError as err:
except v1version.PatternError as err:
assert "Invalid version string" in str(err)
def test_parse_error_nopadding():
try:
version.parse_version_info("v201809.2b0")
v1version.parse_version_info("v201809.2b0")
assert False
except version.PatternError as err:
except v1version.PatternError as err:
assert "Invalid version string" in str(err)
def test_part_field_mapping():
a_names = set(version.PATTERN_PART_FIELDS.keys())
b_names = set(patterns.PART_PATTERNS.keys())
c_names = set(patterns.COMPOSITE_PART_PATTERNS.keys())
def test_part_field_mapping_v1():
a_names = set(v1version.PATTERN_PART_FIELDS.keys())
b_names = set(v1patterns.PART_PATTERNS.keys())
c_names = set(v1patterns.COMPOSITE_PART_PATTERNS.keys())
a_extra_names = a_names - b_names
assert not any(a_extra_names), sorted(a_extra_names)
b_extra_names = b_names - (a_names | c_names)
assert not any(b_extra_names), sorted(b_extra_names)
a_fields = set(version.PATTERN_PART_FIELDS.values())
b_fields = set(version.VersionInfo._fields)
a_fields = set(v1version.PATTERN_PART_FIELDS.values())
b_fields = set(v1version.VersionInfo._fields)
a_extra_fields = a_fields - b_fields
b_extra_fields = b_fields - a_fields
@ -150,8 +152,18 @@ def test_part_field_mapping():
assert not any(b_extra_fields), sorted(b_extra_fields)
def test_part_field_mapping_v2():
a_names = set(v2version.PATTERN_PART_FIELDS.keys())
b_names = set(v2patterns.PART_PATTERNS.keys())
a_extra_names = a_names - b_names
assert not any(a_extra_names), sorted(a_extra_names)
b_extra_names = b_names - a_names
assert not any(b_extra_names), sorted(b_extra_names)
def vnfo(**field_values):
return version._parse_field_values(field_values)
return v1version._parse_field_values(field_values)
PARSE_VERSION_TEST_CASES = [
@ -174,7 +186,7 @@ PARSE_VERSION_TEST_CASES = [
@pytest.mark.parametrize("pattern_str, line, expected_vinfo", PARSE_VERSION_TEST_CASES)
def test_parse_versions(pattern_str, line, expected_vinfo):
pattern = patterns.compile_pattern(pattern_str)
pattern = v1patterns.compile_pattern(pattern_str)
version_match = pattern.regexp.search(line)
if expected_vinfo is None:
@ -184,6 +196,6 @@ def test_parse_versions(pattern_str, line, expected_vinfo):
assert version_match is not None
version_str = version_match.group(0)
version_info = version.parse_version_info(version_str, pattern_str)
version_info = v1version.parse_version_info(version_str, pattern_str)
assert version_info == expected_vinfo