Compare commits
3 Commits
0.0.1.post
...
0.0.1.post
| Author | SHA1 | Date | |
|---|---|---|---|
|
014e8ac0d2 | ||
|
|
b74269b39b | ||
|
|
46ee6dec57 |
@@ -19,4 +19,4 @@ except PackageNotFoundError: # pragma: no cover
|
||||
warnings.warn("can not read __version__, assuming local test context, setting it to ?.?.?")
|
||||
__version__ = "?.?.?"
|
||||
|
||||
from .gitversionhelper import gitversionhelper
|
||||
from .gitversionhelper import gitversionhelper, gitversionhelperException
|
||||
|
||||
@@ -8,7 +8,8 @@
|
||||
|
||||
"""
|
||||
This module is the main gitversionhelper file, containing all the code.
|
||||
This project aim to be kept compact and focused on helping doing handy things with git when it deal with project versions/tags.
|
||||
This project aim to be kept compact and focused on helping doing handy
|
||||
things with git when it deal with project versions/tags.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -18,12 +19,13 @@ import os
|
||||
import subprocess
|
||||
import re
|
||||
from copy import copy
|
||||
import logging
|
||||
|
||||
from packaging.version import VERSION_PATTERN as packaging_VERSION_PATTERN
|
||||
|
||||
if TYPE_CHECKING: # Only imports the below statements during type checking
|
||||
from typing import Union
|
||||
|
||||
|
||||
def _exec(cmd: str, root: str | os.PathLike | None = None) -> list[str]:
|
||||
"""
|
||||
Helper function to handle system cmd execution
|
||||
@@ -35,20 +37,44 @@ def _exec(cmd: str, root: str | os.PathLike | None = None) -> list[str]:
|
||||
|
||||
"""
|
||||
try:
|
||||
stdout = subprocess.check_output(cmd, shell=True, text=True, cwd=root)
|
||||
#stdout = subprocess.check_output(cmd, shell=True, text=True, cwd=root)
|
||||
p = subprocess.run(cmd.split(), text=True, cwd=root, capture_output=True)
|
||||
if re.search("not a git repository",p.stderr):
|
||||
raise gitversionhelper.repository.notAGitRepository()
|
||||
if re.search("fatal:",p.stderr):
|
||||
raise gitversionhelper.unknownGITFatalError()
|
||||
if int(p.returncode) < 0:
|
||||
raise gitversionhelper.unknownGITError
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
stdout = e.output
|
||||
lines = stdout.splitlines()
|
||||
raise RuntimeError(e.output)
|
||||
|
||||
lines = p.stdout.splitlines()
|
||||
return [line.rstrip() for line in lines if line.rstrip()]
|
||||
|
||||
class gitversionhelperException(Exception):
|
||||
pass
|
||||
|
||||
class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
"""
|
||||
Main gitversionhelper class
|
||||
"""
|
||||
class wrongArguments(gitversionhelperException):
|
||||
pass
|
||||
class unknownGITError(gitversionhelperException):
|
||||
pass
|
||||
class unknownGITFatalError(unknownGITError):
|
||||
pass
|
||||
class repository:
|
||||
"""
|
||||
class containing methods focusing on repository
|
||||
"""
|
||||
class repositoryException(gitversionhelperException):
|
||||
pass
|
||||
class notAGitRepository(repositoryException):
|
||||
pass
|
||||
class repositoryDirty(repositoryException):
|
||||
pass
|
||||
@classmethod
|
||||
def isDirty(cls) -> bool:
|
||||
"""
|
||||
@@ -56,14 +82,22 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
Return:
|
||||
True if it is dirty
|
||||
"""
|
||||
return True if _exec(f"git status --short") else False
|
||||
|
||||
return True if _exec("git status --short") else False
|
||||
|
||||
class tag:
|
||||
"""
|
||||
class containing methods focusing on tags
|
||||
"""
|
||||
__OptDict = {"same_branch": "same_branch"}
|
||||
__validGitTagSort=["","v:refname","-v:refname","taggerdate","committerdate","-taggerdate","-committerdate"]
|
||||
|
||||
class tagException(gitversionhelperException):
|
||||
pass
|
||||
class tagNotFound(tagException):
|
||||
pass
|
||||
class moreThanOneTag(tagException):
|
||||
pass
|
||||
|
||||
@classmethod
|
||||
def getTags(cls,sort:str = "version:refname") -> list[str]:
|
||||
"""
|
||||
@@ -74,7 +108,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
the tags list
|
||||
"""
|
||||
if sort not in cls.__validGitTagSort:
|
||||
raise RuntimeError("sort option not in allowed list")
|
||||
raise gitversionhelper.wrongArguments("sort option not in allowed list")
|
||||
return _exec(f"git tag -l --sort={sort}")
|
||||
|
||||
@classmethod
|
||||
@@ -87,14 +121,22 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
the tag
|
||||
"""
|
||||
if ((cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True)):
|
||||
return _exec("git describe --tags --abbrev=0")[0]
|
||||
tag = _exec("git rev-list --tags --max-count=1")
|
||||
return _exec(f"git describe --tags {tag[0]}")[0]
|
||||
res = _exec("git describe --tags --abbrev=0")
|
||||
else:
|
||||
res = _exec("git rev-list --tags --max-count=1")
|
||||
if len(res)==1:
|
||||
res = _exec(f"git describe --tags {res[0]}")
|
||||
|
||||
if len(res)==0:
|
||||
raise cls.tagNotFound("no tag found in commit history")
|
||||
elif len(res)!=1:
|
||||
raise cls.moreThanOneTag("multiple tags on same commit is unsupported")
|
||||
return res[0]
|
||||
|
||||
@classmethod
|
||||
def getDistanceFromTag(cls,tag=None,**kwargs) -> int:
|
||||
"""
|
||||
retrieve the distance from tag in the repository
|
||||
retrieve the distance between HEAD and tag in the repository
|
||||
Arguments:
|
||||
tag: reference tag, if None the most recent one will be used
|
||||
Kwargs:
|
||||
@@ -102,7 +144,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
Return:
|
||||
the tag
|
||||
"""
|
||||
if (tag is None):
|
||||
if tag is None:
|
||||
tag = cls.getLastTag(**kwargs)
|
||||
return int(_exec(f"git rev-list {tag}..HEAD --count")[0])
|
||||
|
||||
@@ -113,24 +155,37 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
__OptDict = { "version_std": "version_std",
|
||||
"formated_output": "formated_output",
|
||||
"output_format": "output_format"}
|
||||
DefaultInputFormat = "PEP440"
|
||||
DefaultInputFormat = "Auto"
|
||||
VersionStds = { "SemVer" : { "regex" : r"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)"\
|
||||
r"(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)"\
|
||||
r"(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"\
|
||||
r"(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"},
|
||||
"PEP440" : { "regex" : packaging_VERSION_PATTERN }
|
||||
r"(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$",
|
||||
"regex_preversion_num": r"(?:\.)(?P<num>(?:\d+(?!\w))+)",
|
||||
"regex_build_num" : r"(?:\.)(?P<num>(?:\d+(?!\w))+)"
|
||||
|
||||
},
|
||||
"PEP440" : { "regex" : packaging_VERSION_PATTERN,
|
||||
"Auto" : None
|
||||
}
|
||||
}
|
||||
__versionReseted = False
|
||||
class versionException(gitversionhelperException):
|
||||
pass
|
||||
class noValidVersion(versionException):
|
||||
pass
|
||||
|
||||
class MetaVersion:
|
||||
"""
|
||||
generic version object
|
||||
"""
|
||||
__OptDict = { "bump_type": "bump_type",
|
||||
"bump_dev_strategy": "bump_dev_strategy"}
|
||||
__OptDict = { "bump_type": "bump_type",
|
||||
"bump_dev_strategy": "bump_dev_strategy"}
|
||||
DefaultBumpType = "patch"
|
||||
BumpTypes = ["major","minor","patch","dev"]
|
||||
DefaultBumpDevStrategy = "post"
|
||||
BumpDevStrategys = ["post","pre","force_post","force_pre"]
|
||||
BumpDevStrategys = ["post","pre-patch","pre-minor","pre-major"]
|
||||
version_std = "None"
|
||||
|
||||
major: int = 0
|
||||
minor: int = 1
|
||||
patch: int = 0
|
||||
@@ -138,8 +193,14 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
post_count:int = 0
|
||||
raw:str = "0.1.0"
|
||||
|
||||
def __init__(self,major=0,minor=1,patch=0,pre_count=0,post_count=0,raw="0.1.0"):
|
||||
self.major,self.minor,self.patch,self.pre_count,self.post_count,self.raw = major,minor,patch,pre_count,post_count,raw
|
||||
def __init__(self,version_std,major=0,minor=1,patch=0,pre_count=0,post_count=0,raw="0.1.0"):
|
||||
self.version_std = version_std
|
||||
self.major = major
|
||||
self.minor = minor
|
||||
self.patch = patch
|
||||
self.pre_count = pre_count
|
||||
self.post_count = post_count
|
||||
self.raw = raw
|
||||
|
||||
@classmethod
|
||||
def _getBumpDevStrategy(cls,**kwargs) -> str:
|
||||
@@ -155,7 +216,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
if kwargs[cls.__OptDict["bump_dev_strategy"]] in cls.BumpDevStrategys:
|
||||
BumpDevStrategy = kwargs[cls.__OptDict["bump_dev_strategy"]]
|
||||
else:
|
||||
raise RuntimeError(f"invalid {cls.__OptDict['bump_type']} requested")
|
||||
raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
|
||||
return BumpDevStrategy
|
||||
|
||||
@classmethod
|
||||
@@ -172,10 +233,10 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
if kwargs[cls.__OptDict["bump_type"]] in cls.BumpTypes:
|
||||
BumpType = kwargs[cls.__OptDict["bump_type"]]
|
||||
else:
|
||||
raise RuntimeError(f"invalid {cls.__OptDict['bump_type']} requested")
|
||||
raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
|
||||
return BumpType
|
||||
|
||||
def bump(self,**kwargs):
|
||||
def bump(self,amount:int=1,**kwargs):
|
||||
"""
|
||||
bump the version to the next one
|
||||
Kwargs:
|
||||
@@ -187,32 +248,39 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
BumpType = self._getBumpType(**kwargs)
|
||||
BumpDevStrategy=self._getBumpDevStrategy(**kwargs)
|
||||
_v=copy(self)
|
||||
|
||||
if BumpType == "dev":
|
||||
if BumpDevStrategy == "post":
|
||||
if _v.pre_count > 0:
|
||||
_v.pre_count = _v.pre_count + 1
|
||||
_v.pre_count = _v.pre_count + amount
|
||||
else:
|
||||
_v.post_count = _v.post_count + 1
|
||||
elif BumpDevStrategy == "pre":
|
||||
_v.post_count = _v.post_count + amount
|
||||
elif BumpDevStrategy in ["pre-patch","pre-minor","pre-major"]:
|
||||
if _v.post_count > 0:
|
||||
_v.post_count = _v.post_count + 1
|
||||
_v.post_count = _v.post_count + amount
|
||||
else:
|
||||
_v.pre_count = _v.pre_count + 1
|
||||
elif BumpDevStrategy == "force_post":
|
||||
pass
|
||||
elif BumpDevStrategy == "force_pre":
|
||||
pass
|
||||
if _v.pre_count == 0:
|
||||
if BumpDevStrategy == "pre-patch":
|
||||
_v.patch = _v.patch + 1
|
||||
elif BumpDevStrategy == "pre-minor":
|
||||
_v.minor = _v.minor + 1
|
||||
_v.patch = 0
|
||||
elif BumpDevStrategy == "pre-major":
|
||||
_v.major = _v.major + 1
|
||||
_v.minor = 0
|
||||
_v.patch = 0
|
||||
_v.pre_count = _v.pre_count + amount
|
||||
else:
|
||||
if BumpType == "major":
|
||||
_v.major = _v.major + 1
|
||||
_v.major = _v.major + amount
|
||||
elif BumpType == "minor":
|
||||
_v.minor = _v.minor + 1
|
||||
_v.minor = _v.minor + amount
|
||||
elif BumpType == "patch":
|
||||
_v.patch = _v.patch + 1
|
||||
_v.patch = _v.patch + amount
|
||||
_v.pre_count=0
|
||||
_v.post_count=0
|
||||
|
||||
_v.raw="{major}.{minor}.{patch}{revpattern}{revcount}".format(major=_v.major,minor=_v.minor,patch=_v.patch,revpattern="",revcount="")
|
||||
_v.raw=_v.doFormatVersion(**kwargs)
|
||||
return _v
|
||||
|
||||
def doFormatVersion(self,**kwargs):
|
||||
@@ -228,13 +296,31 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
Kwargs given version_std or the default one.
|
||||
"""
|
||||
VersionStd = cls.DefaultInputFormat
|
||||
if (cls.__OptDict["version_std"] in kwargs):
|
||||
if cls.__OptDict["version_std"] in kwargs:
|
||||
if kwargs[cls.__OptDict["version_std"]] in cls.VersionStds:
|
||||
VersionStd = kwargs[cls.__OptDict["version_std"]]
|
||||
else:
|
||||
raise RuntimeError(f"invalid {cls.__OptDict['version_std']} requested")
|
||||
raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['version_std']} requested")
|
||||
return VersionStd
|
||||
|
||||
@classmethod
|
||||
def getCurrentVersion(cls,**kwargs) -> Union[str,MetaVersion]:
|
||||
if gitversionhelper.repository.isDirty() is not False:
|
||||
raise gitversionhelper.repository.repositoryDirty("The repository is dirty and a current version can not be generated.")
|
||||
saved_kwargs = copy(kwargs)
|
||||
if "formated_output" in kwargs:
|
||||
del saved_kwargs["formated_output"]
|
||||
|
||||
_v = cls.getLastVersion(**saved_kwargs)
|
||||
|
||||
if cls.__versionReseted == False:
|
||||
amount = gitversionhelper.tag.getDistanceFromTag(_v.raw,**kwargs)
|
||||
_v = _v.bump(amount,**kwargs)
|
||||
|
||||
if ((cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True)):
|
||||
return _v.doFormatVersion(**kwargs)
|
||||
return _v
|
||||
|
||||
@classmethod
|
||||
def getLastVersion(cls,**kwargs) -> Union[str,MetaVersion]:
|
||||
"""
|
||||
@@ -247,33 +333,74 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
the last version
|
||||
"""
|
||||
VersionStd = cls._getVersionStd(**kwargs)
|
||||
_r=re.compile(r"^\s*" + cls.VersionStds[VersionStd]["regex"] + r"\s*$", re.VERBOSE | re.IGNORECASE)
|
||||
|
||||
lastTag = gitversionhelper.tag.getLastTag(**kwargs)
|
||||
bAutoVersionStd = False
|
||||
if VersionStd == "Auto":
|
||||
bAutoVersionStd = True
|
||||
|
||||
_m = re.match(_r,lastTag)
|
||||
if not _m:
|
||||
raise RuntimeError("no valid version found in tags")
|
||||
if VersionStd is "PEP440":
|
||||
ver=_m.group("release").split(".")
|
||||
ver += ["0"] * (3 - len(ver))
|
||||
ver[0]=int(ver[0])
|
||||
ver[1]=int(ver[1])
|
||||
ver[2]=int(ver[2])
|
||||
major, minor, patch = tuple(ver)
|
||||
pre_count = int(_m.group("pre_n")) if _m.group("pre_n") else 0
|
||||
post_count = int(_m.group("post_n2")) if _m.group("post_n2") else 0
|
||||
elif VersionStd is "SemVer":
|
||||
major, minor, patch = int(_m.group("major")),int(_m.group("minor")),int(_m.group("patch")),(_m.group("prerelease") if _m.group("prerelease") else ""), ""
|
||||
pre_count = 0
|
||||
post_count = 0
|
||||
lastTag=cls.MetaVersion.raw
|
||||
cls.__versionReseted = False
|
||||
try:
|
||||
lastTag = gitversionhelper.tag.getLastTag(**kwargs)
|
||||
except gitversionhelper.tag.tagNotFound:
|
||||
logging.warning('tag not found, reseting versionning')
|
||||
cls.__versionReseted = True
|
||||
|
||||
_v = cls.MetaVersion(major, minor, patch, pre_count, post_count, lastTag)
|
||||
|
||||
bFound = False
|
||||
if VersionStd == "SemVer" or (bAutoVersionStd is True) :
|
||||
_r=re.compile(r"^\s*" + cls.VersionStds["SemVer"]["regex"] + r"\s*$", re.VERBOSE | \
|
||||
re.IGNORECASE)
|
||||
_m = re.match(_r,lastTag)
|
||||
if not _m:
|
||||
pass
|
||||
else:
|
||||
major, minor, patch = int(_m.group("major")),\
|
||||
int(_m.group("minor")),\
|
||||
int(_m.group("patch"))
|
||||
|
||||
pre_count = 0
|
||||
if _pre := _m.group("prerelease"):
|
||||
if (_match := re.search (cls.VersionStds["SemVer"]["regex_preversion_num"],_pre)) is not None:
|
||||
pre_count = int(_match.group("num"))
|
||||
else:
|
||||
pre_count = 1
|
||||
|
||||
post_count = 0
|
||||
if _post := _m.group("buildmetadata"):
|
||||
if (_match := re.search (cls.VersionStds["SemVer"]["regex_build_num"],_post)) is not None:
|
||||
post_count = int(_match.group("num"))
|
||||
else:
|
||||
post_count = 1
|
||||
bFound = True
|
||||
VersionStd = "SemVer"
|
||||
|
||||
if VersionStd == "PEP440" or ( (bAutoVersionStd is True) and (bFound is not True)):
|
||||
_r=re.compile(r"^\s*" + cls.VersionStds["PEP440"]["regex"] + r"\s*$", re.VERBOSE | \
|
||||
re.IGNORECASE)
|
||||
_m = re.match(_r,lastTag)
|
||||
if not _m:
|
||||
pass
|
||||
else:
|
||||
ver=_m.group("release").split(".")
|
||||
ver += ["0"] * (3 - len(ver))
|
||||
ver[0]=int(ver[0])
|
||||
ver[1]=int(ver[1])
|
||||
ver[2]=int(ver[2])
|
||||
major, minor, patch = tuple(ver)
|
||||
pre_count = int(_m.group("pre_n")) if _m.group("pre_n") else 0
|
||||
post_count = int(_m.group("post_n2")) if _m.group("post_n2") else 0
|
||||
bFound = True
|
||||
VersionStd = "PEP440"
|
||||
|
||||
if bFound is not True:
|
||||
raise gitversionhelper.version.noValidVersion("no valid version found in tags")
|
||||
|
||||
_v = cls.MetaVersion(VersionStd,major, minor, patch, pre_count, post_count, lastTag)
|
||||
|
||||
if ((cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True)):
|
||||
return cls.doFormatVersion(_v,**kwargs)
|
||||
else:
|
||||
return _v
|
||||
return _v.doFormatVersion(**kwargs)
|
||||
return _v
|
||||
|
||||
@classmethod
|
||||
def doFormatVersion(cls,inputversion:MetaVersion,**kwargs):
|
||||
@@ -284,62 +411,37 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
|
||||
Return:
|
||||
formated version string
|
||||
"""
|
||||
VersionStd = cls._getVersionStd(**kwargs)
|
||||
|
||||
VersionStd = cls._getVersionStd(**kwargs)
|
||||
if VersionStd=="Auto" :
|
||||
VersionStd = inputversion.version_std
|
||||
|
||||
OutputFormat = None
|
||||
revpattern=""
|
||||
revcount=""
|
||||
post_count = inputversion.post_count
|
||||
pre_count = inputversion.pre_count
|
||||
patch = inputversion.patch
|
||||
|
||||
if (cls.__OptDict["output_format"] in kwargs):
|
||||
OutputFormat=kwargs[cls.__OptDict["output_format"]]
|
||||
|
||||
if OutputFormat is None:
|
||||
if VersionStd is "PEP440":
|
||||
OutputFormat = "{major}.{minor}.{patch}{revpattern}{revcount}"
|
||||
OutputFormat = "{major}.{minor}.{patch}{revpattern}{revcount}"
|
||||
if post_count > 0 and pre_count > 0:
|
||||
raise RuntimeError("pre and post release can not be present at the same time")
|
||||
if VersionStd == "PEP440":
|
||||
if post_count > 0:
|
||||
revpattern=".post"
|
||||
revcount=f"{post_count}"
|
||||
elif VersionStd is "SemVer":
|
||||
OutputFormat = "{major}.{minor}.{patch}{revpattern}{revcount}"
|
||||
if post_count > 0:
|
||||
pre_count = pre_count + post_count
|
||||
post_count = 0
|
||||
patch = patch + 1
|
||||
if pre_count > 0:
|
||||
revpattern="-pre"
|
||||
elif pre_count > 0:
|
||||
revpattern=".pre"
|
||||
revcount=f"{pre_count}"
|
||||
|
||||
elif VersionStd == "SemVer":
|
||||
if post_count > 0:
|
||||
revpattern="+post"
|
||||
revcount=f".{post_count}"
|
||||
elif pre_count > 0:
|
||||
revpattern="-pre"
|
||||
revcount=f".{pre_count}"
|
||||
return OutputFormat.format(major=inputversion.major,minor=inputversion.minor,patch=patch,revpattern=revpattern,revcount=revcount)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#print(gitversionhelper.head.isDirty())
|
||||
#print(gitversionhelper.tag.getTags())
|
||||
#print(gitversionhelper.tag.getLastTag())
|
||||
#print(gitversionhelper.tag.getLastTag(same_branch=True))
|
||||
#print(gitversionhelper.tag.getDistanceFromLastTag())
|
||||
#print(gitversionhelper.tag.getDistanceFromLastTag(same_branch=True))
|
||||
|
||||
#print(gitversionhelper.version.getLastVersion())
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440",formated_output=True))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440",formated_output=True,output_format="v{major}.{minor}.{patch}"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump())
|
||||
#print("")
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="dev").doFormatVersion(version_std="SemVer"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="patch").doFormatVersion(version_std="SemVer"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="minor").doFormatVersion(version_std="SemVer"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="major").doFormatVersion(version_std="SemVer"))
|
||||
#print("")
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="dev").doFormatVersion(version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="patch").doFormatVersion(version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="minor").doFormatVersion(version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="major").doFormatVersion(version_std="PEP440"))
|
||||
|
||||
#from setuptools_git_versioning import version_from_git
|
||||
#print(str(version_from_git(tag_filter="^\d+\.\d+\.\d+$",dev_template = "{tag}.post{ccount}",sort_by="v:refname")),end ="")
|
||||
|
||||
@@ -7,7 +7,12 @@
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
import unittest
|
||||
from io import StringIO
|
||||
|
||||
import tempfile
|
||||
import os
|
||||
import pathlib
|
||||
import re
|
||||
|
||||
from contextlib import redirect_stdout,redirect_stderr
|
||||
|
||||
print(__name__)
|
||||
@@ -15,10 +20,753 @@ print(__package__)
|
||||
|
||||
from src import pygitversionhelper
|
||||
|
||||
HelperRegex=r"^(?P<MAJ>\d+)\.(?P<MIN>\d+)\.(?P<PATCH>\d+)([\.\-\+])?(?:.*)?"
|
||||
|
||||
class Test_gitversionhelper(unittest.TestCase):
|
||||
def test_version(self):
|
||||
version = pygitversionhelper.gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440").bump(bump_type="dev").doFormatVersion(version_std="SemVer")
|
||||
self.assertNotEqual(version,"?.?.?")
|
||||
def setUp(self):
|
||||
self.TmpWorkingDir=tempfile.TemporaryDirectory()
|
||||
self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
|
||||
os.chdir(self.TmpWorkingDirPath)
|
||||
os.system("git init")
|
||||
|
||||
def _test_version_readback(self,tag:str,**kwargs):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
os.system(f"git tag {tag}")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getLastVersion(**kwargs)
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, tag)
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
|
||||
_m = re.match(HelperRegex, tag)
|
||||
self.assertEqual(int(_m.group("MAJ")),_v.major)
|
||||
self.assertEqual(int(_m.group("MIN")),_v.minor)
|
||||
self.assertEqual(int(_m.group("PATCH")),_v.patch)
|
||||
return _v
|
||||
|
||||
def _test_version_format(self,_v:pygitversionhelper.gitversionhelper.version.MetaVersion,tag:str,**kwargs):
|
||||
_f=_v.doFormatVersion(**kwargs)
|
||||
self.assertRegex(_f,HelperRegex)
|
||||
self.assertEqual(_f, tag)
|
||||
|
||||
def _test_version_readback_simple(self,tag:str,**kwargs):
|
||||
_v=self._test_version_readback(tag,**kwargs)
|
||||
self._test_version_format(_v,tag,**kwargs)
|
||||
|
||||
def test_nominal_version_auto_1(self):
|
||||
self._test_version_readback_simple("0.0.1")
|
||||
def test_nominal_version_auto_2(self):
|
||||
self._test_version_readback_simple("0.0.2")
|
||||
def test_nominal_version_auto_3(self):
|
||||
self._test_version_readback_simple("0.1.0")
|
||||
def test_nominal_version_auto_4(self):
|
||||
self._test_version_readback_simple("0.1.1")
|
||||
def test_nominal_version_auto_5(self):
|
||||
self._test_version_readback_simple("1.0.0")
|
||||
def test_nominal_version_auto_6(self):
|
||||
self._test_version_readback_simple("1.1.0")
|
||||
def test_nominal_version_auto_7(self):
|
||||
self._test_version_readback_simple("1.2.0")
|
||||
def test_nominal_version_auto_8(self):
|
||||
self._test_version_readback_simple("1.1.1")
|
||||
def test_nominal_version_auto_9(self):
|
||||
self._test_version_readback_simple("1.2.1")
|
||||
def test_nominal_version_auto_PEP440_post(self):
|
||||
self._test_version_readback_simple("1.2.1.post1")
|
||||
def test_nominal_version_auto_PEP440_pre(self):
|
||||
self._test_version_readback_simple("1.2.1.pre1")
|
||||
def test_nominal_version_auto_PEP440_post_2(self):
|
||||
self._test_version_readback_simple("1.2.1.post10")
|
||||
def test_nominal_version_auto_PEP440_pre_2(self):
|
||||
self._test_version_readback_simple("1.2.1.pre10")
|
||||
|
||||
def test_nominal_version_auto_SemVer_post(self):
|
||||
self._test_version_readback_simple("1.2.1+post.1")
|
||||
def test_nominal_version_auto_SemVer_pre(self):
|
||||
self._test_version_readback_simple("1.2.1-pre.1")
|
||||
def test_nominal_version_auto_SemVer_post_2(self):
|
||||
self._test_version_readback_simple("1.2.1+post.10")
|
||||
def test_nominal_version_auto_Semver_pre_2(self):
|
||||
self._test_version_readback_simple("1.2.1-pre.10")
|
||||
|
||||
def test_nominal_version_PEP440_1(self):
|
||||
self._test_version_readback_simple("0.0.1",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_2(self):
|
||||
self._test_version_readback_simple("0.0.2",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_3(self):
|
||||
self._test_version_readback_simple("0.1.0",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_4(self):
|
||||
self._test_version_readback_simple("0.1.1",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_5(self):
|
||||
self._test_version_readback_simple("1.0.0",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_6(self):
|
||||
self._test_version_readback_simple("1.1.0",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_7(self):
|
||||
self._test_version_readback_simple("1.2.0",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_8(self):
|
||||
self._test_version_readback_simple("1.1.1",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_9(self):
|
||||
self._test_version_readback_simple("1.2.1",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_post(self):
|
||||
self._test_version_readback_simple("1.2.1.post1",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_pre(self):
|
||||
self._test_version_readback_simple("1.2.1.pre1",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_post_2(self):
|
||||
self._test_version_readback_simple("1.2.1.post10",version_std="PEP440")
|
||||
def test_nominal_version_PEP440_pre_2(self):
|
||||
self._test_version_readback_simple("1.2.1.pre10",version_std="PEP440")
|
||||
|
||||
def test_nominal_version_SemVer_1(self):
|
||||
self._test_version_readback_simple("0.0.1",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_2(self):
|
||||
self._test_version_readback_simple("0.0.2",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_3(self):
|
||||
self._test_version_readback_simple("0.1.0",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_4(self):
|
||||
self._test_version_readback_simple("0.1.1",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_5(self):
|
||||
self._test_version_readback_simple("1.0.0",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_6(self):
|
||||
self._test_version_readback_simple("1.1.0",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_7(self):
|
||||
self._test_version_readback_simple("1.2.0",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_8(self):
|
||||
self._test_version_readback_simple("1.1.1",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_9(self):
|
||||
self._test_version_readback_simple("1.2.1",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_post(self):
|
||||
self._test_version_readback_simple("1.2.1+post.1",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_pre(self):
|
||||
self._test_version_readback_simple("1.2.1-pre.1",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_post_2(self):
|
||||
self._test_version_readback_simple("1.2.1+post.10",version_std="SemVer")
|
||||
def test_nominal_version_SemVer_pre_2(self):
|
||||
self._test_version_readback_simple("1.2.1-pre.10",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_post_PEP440_to_SemVer(self):
|
||||
_v=self._test_version_readback("1.2.1.post10",version_std="PEP440")
|
||||
self._test_version_format(_v,"1.2.1+post.10",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_post_SemVer_to_PEP440(self):
|
||||
_v=self._test_version_readback("1.2.1+post.10",version_std="SemVer")
|
||||
self._test_version_format(_v,"1.2.1.post10",version_std="PEP440")
|
||||
|
||||
def test_nominal_version_pre_PEP440_to_SemVer(self):
|
||||
_v=self._test_version_readback("1.2.1.pre10",version_std="PEP440")
|
||||
self._test_version_format(_v,"1.2.1-pre.10",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_pre_SemVer_to_PEP440(self):
|
||||
_v=self._test_version_readback("1.2.1-pre.10",version_std="SemVer")
|
||||
self._test_version_format(_v,"1.2.1.pre10",version_std="PEP440")
|
||||
|
||||
def test_nominal_version_post_SemVer_nonum(self):
|
||||
_v=self._test_version_readback("1.2.1+post",version_std="SemVer")
|
||||
self._test_version_format(_v,"1.2.1+post.1",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_post_SemVer_nonum_random(self):
|
||||
_v=self._test_version_readback("1.2.1+toto",version_std="SemVer")
|
||||
self._test_version_format(_v,"1.2.1+post.1",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_pre_SemVer_nonum(self):
|
||||
_v=self._test_version_readback("1.2.1-pre",version_std="SemVer")
|
||||
self._test_version_format(_v,"1.2.1-pre.1",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_pre_SemVer_nonum_random(self):
|
||||
_v=self._test_version_readback("1.2.1-toto",version_std="SemVer")
|
||||
self._test_version_format(_v,"1.2.1-pre.1",version_std="SemVer")
|
||||
|
||||
def test_version_pump_SemVer(self,**kwargs):
|
||||
_v = self._test_version_readback("1.0.0",version_std="SemVer")
|
||||
|
||||
_v = _v.bump()
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
self.assertEqual(_v.raw, "1.0.1")
|
||||
self.assertEqual(_v.major, 1)
|
||||
self.assertEqual(_v.minor, 0)
|
||||
self.assertEqual(_v.patch, 1)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "1.0.1")
|
||||
|
||||
_v = _v.bump(bump_type="patch")
|
||||
self.assertEqual(_v.raw, "1.0.2")
|
||||
self.assertEqual(_v.major, 1)
|
||||
self.assertEqual(_v.minor, 0)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "1.0.2")
|
||||
|
||||
_v = _v.bump(bump_type="minor")
|
||||
self.assertEqual(_v.raw, "1.1.2")
|
||||
self.assertEqual(_v.major, 1)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "1.1.2")
|
||||
|
||||
_v = _v.bump(bump_type="major")
|
||||
self.assertEqual(_v.raw, "2.1.2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.2")
|
||||
|
||||
_v = _v.bump(bump_type="dev")
|
||||
self.assertEqual(_v.raw, "2.1.2+post.1")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 1)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.2+post.1")
|
||||
|
||||
_v = _v.bump(bump_type="dev")
|
||||
self.assertEqual(_v.raw, "2.1.2+post.2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 2)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.2+post.2")
|
||||
|
||||
_v = _v.bump(bump_type="patch")
|
||||
self.assertEqual(_v.raw, "2.1.3")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 3)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.3")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
self.assertEqual(_v.raw, "2.1.4-pre.1")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 4)
|
||||
self.assertEqual(_v.pre_count, 1)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.1")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
self.assertEqual(_v.raw, "2.1.4-pre.2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 4)
|
||||
self.assertEqual(_v.pre_count, 2)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.2")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="post")
|
||||
self.assertEqual(_v.raw, "2.1.4-pre.3")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 4)
|
||||
self.assertEqual(_v.pre_count, 3)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.3")
|
||||
|
||||
_v = _v.bump(bump_type="patch")
|
||||
self.assertEqual(_v.raw, "2.1.5")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 5)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.5")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="post")
|
||||
self.assertEqual(_v.raw, "2.1.5+post.1")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 5)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 1)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.5+post.1")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
self.assertEqual(_v.raw, "2.1.5+post.2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 5)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 2)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.5+post.2")
|
||||
|
||||
def test_version_pump_PEP440(self,**kwargs):
|
||||
_v = self._test_version_readback("1.0.0",version_std="PEP440")
|
||||
|
||||
_v = _v.bump()
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
self.assertEqual(_v.raw, "1.0.1")
|
||||
self.assertEqual(_v.major, 1)
|
||||
self.assertEqual(_v.minor, 0)
|
||||
self.assertEqual(_v.patch, 1)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "1.0.1")
|
||||
|
||||
_v = _v.bump(bump_type="patch")
|
||||
self.assertEqual(_v.raw, "1.0.2")
|
||||
self.assertEqual(_v.major, 1)
|
||||
self.assertEqual(_v.minor, 0)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "1.0.2")
|
||||
|
||||
_v = _v.bump(bump_type="minor")
|
||||
self.assertEqual(_v.raw, "1.1.2")
|
||||
self.assertEqual(_v.major, 1)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "1.1.2")
|
||||
|
||||
_v = _v.bump(bump_type="major")
|
||||
self.assertEqual(_v.raw, "2.1.2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.2")
|
||||
|
||||
_v = _v.bump(bump_type="dev")
|
||||
self.assertEqual(_v.raw, "2.1.2.post1")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 1)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.2.post1")
|
||||
|
||||
_v = _v.bump(bump_type="dev")
|
||||
self.assertEqual(_v.raw, "2.1.2.post2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 2)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 2)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.2.post2")
|
||||
|
||||
_v = _v.bump(bump_type="patch")
|
||||
self.assertEqual(_v.raw, "2.1.3")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 3)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.3")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
self.assertEqual(_v.raw, "2.1.4.pre1")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 4)
|
||||
self.assertEqual(_v.pre_count, 1)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.4.pre1")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
self.assertEqual(_v.raw, "2.1.4.pre2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 4)
|
||||
self.assertEqual(_v.pre_count, 2)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.4.pre2")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="post")
|
||||
self.assertEqual(_v.raw, "2.1.4.pre3")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 4)
|
||||
self.assertEqual(_v.pre_count, 3)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.4.pre3")
|
||||
|
||||
_v = _v.bump(bump_type="patch")
|
||||
self.assertEqual(_v.raw, "2.1.5")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 5)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 0)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.5")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="post")
|
||||
self.assertEqual(_v.raw, "2.1.5.post1")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 5)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 1)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.5.post1")
|
||||
|
||||
_v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
self.assertEqual(_v.raw, "2.1.5.post2")
|
||||
self.assertEqual(_v.major, 2)
|
||||
self.assertEqual(_v.minor, 1)
|
||||
self.assertEqual(_v.patch, 5)
|
||||
self.assertEqual(_v.pre_count, 0)
|
||||
self.assertEqual(_v.post_count, 2)
|
||||
self.assertEqual(_v.doFormatVersion(), "2.1.5.post2")
|
||||
|
||||
def test_nominal_version_SemVer_zeroRev(self):
|
||||
_v=self._test_version_readback("0.0.0",version_std="SemVer")
|
||||
self._test_version_format(_v,"0.0.0",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_PEP440_zeroRev(self):
|
||||
_v=self._test_version_readback("0.0.0",version_std="PEP440")
|
||||
self._test_version_format(_v,"0.0.0",version_std="PEP440")
|
||||
|
||||
|
||||
def test_nominal_version_PEP440_noRev_noTag(self):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.1.0")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,1)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self._test_version_format(_v,"0.1.0",version_std="PEP440")
|
||||
|
||||
def test_nominal_version_SemVer_noRev_noTag(self):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="SemVer")
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.1.0")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,1)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self._test_version_format(_v,"0.1.0",version_std="SemVer")
|
||||
|
||||
def test_nominal_version_AUTO_noRev_noTag(self):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getLastVersion()
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.1.0")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,1)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self._test_version_format(_v,"0.1.0")
|
||||
|
||||
|
||||
def test_nominal_version_AUTO_bump_commits(self):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
os.system(f"git tag 0.2.0")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.2.0")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,2)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self.assertEqual(_v.pre_count,0)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"0.2.0")
|
||||
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue22")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"2nd commit\"")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.2.1")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,2)
|
||||
self.assertEqual(_v.patch,1)
|
||||
self.assertEqual(_v.pre_count,0)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"0.2.1")
|
||||
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue223")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"3rd commit\"")
|
||||
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue224")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"4th commit\"")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.2.3")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,2)
|
||||
self.assertEqual(_v.patch,3)
|
||||
self.assertEqual(_v.pre_count,0)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"0.2.3")
|
||||
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue225")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"5th commit\"")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev")
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.2.0+post.4")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,2)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self.assertEqual(_v.pre_count,0)
|
||||
self.assertEqual(_v.post_count,4)
|
||||
self._test_version_format(_v,"0.2.0+post.4")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-patch")
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.2.1-pre.4")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,2)
|
||||
self.assertEqual(_v.patch,1)
|
||||
self.assertEqual(_v.pre_count,4)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"0.2.1-pre.4")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-minor")
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.3.0-pre.4")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,3)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self.assertEqual(_v.pre_count,4)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"0.3.0-pre.4")
|
||||
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major")
|
||||
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "1.0.0-pre.4")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,1)
|
||||
self.assertEqual(_v.minor,0)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self.assertEqual(_v.pre_count,4)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"1.0.0-pre.4")
|
||||
|
||||
def test_nominal_custom_format(self):
|
||||
_v=self._test_version_readback("0.1.1",version_std="PEP440")
|
||||
|
||||
self.assertEqual("V_0_1_1____",_v.doFormatVersion(output_format="V_{major}_{minor}_{patch}____{revcount}"))
|
||||
self.assertEqual("V_0_1",_v.doFormatVersion(output_format="V_{major}_{minor}"))
|
||||
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue225")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"5th commit\"")
|
||||
|
||||
self.assertEqual("V_1_0",pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major").doFormatVersion(output_format="V_{major}_{minor}"))
|
||||
self.assertEqual("V_1_0",pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major",output_format="V_{major}_{minor}",formated_output=True))
|
||||
|
||||
|
||||
|
||||
def test_nominal_emptyrepo(self):
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
|
||||
self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
|
||||
self.assertIsInstance(_v.raw, str)
|
||||
self.assertEqual(_v.raw, "0.1.0")
|
||||
self.assertIsInstance(_v.major, int)
|
||||
self.assertIsInstance(_v.minor, int)
|
||||
self.assertIsInstance(_v.patch, int)
|
||||
self.assertIsInstance(_v.pre_count, int)
|
||||
self.assertIsInstance(_v.post_count, int)
|
||||
|
||||
self.assertEqual(_v.major,0)
|
||||
self.assertEqual(_v.minor,1)
|
||||
self.assertEqual(_v.patch,0)
|
||||
self.assertEqual(_v.pre_count,0)
|
||||
self.assertEqual(_v.post_count,0)
|
||||
self._test_version_format(_v,"0.1.0")
|
||||
|
||||
def test_defect_dirty(self):
|
||||
_v=self._test_version_readback("0.1.1",version_std="PEP440")
|
||||
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue225")
|
||||
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.repository.repositoryDirty) as context:
|
||||
pygitversionhelper.gitversionhelper.version.getCurrentVersion()
|
||||
|
||||
def test_defect_wrongargument_git_sortargs(self):
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
|
||||
pygitversionhelper.gitversionhelper.tag.getTags(sort="toto")
|
||||
|
||||
def test_defect_git_notagfound(self):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.tag.tagNotFound) as context:
|
||||
pygitversionhelper.gitversionhelper.tag.getLastTag()
|
||||
|
||||
""" This test is impossible to do
|
||||
def test_defect_git_multipletagsfound(self):
|
||||
with open("demofile.txt", "w+t") as tmpFile:
|
||||
tmpFile.write("testvalue")
|
||||
os.system("git add .")
|
||||
os.system("git commit -m \"first commit\"")
|
||||
os.system(f"git tag 0.1.0")
|
||||
os.system(f"git tag 0.2.0")
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.tag.moreThanOneTag) as context:
|
||||
pygitversionhelper.gitversionhelper.tag.getLastTag()
|
||||
"""
|
||||
|
||||
def test_defect_wrongargument_bump_type(self):
|
||||
_v=self._test_version_readback("0.1.1",version_std="PEP440")
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
|
||||
pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="toto")
|
||||
|
||||
def test_defect_wrongargument_bump_dev_strategy(self):
|
||||
_v=self._test_version_readback("0.1.1",version_std="PEP440")
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
|
||||
pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_dev_strategy="toto")
|
||||
|
||||
|
||||
|
||||
def tearDown(self):
|
||||
os.chdir("/")
|
||||
|
||||
class Test_gitversionhelperNoRepo(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.TmpWorkingDir=tempfile.TemporaryDirectory()
|
||||
self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
|
||||
os.chdir(self.TmpWorkingDirPath)
|
||||
|
||||
def test_defect_norepo(self):
|
||||
with self.assertRaises(pygitversionhelper.gitversionhelper.repository.notAGitRepository) as context:
|
||||
_v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
|
||||
|
||||
def tearDown(self):
|
||||
os.chdir("/")
|
||||
|
||||
#print(gitversionhelper.tag.getLastTag(same_branch=True))
|
||||
#print(gitversionhelper.tag.getDistanceFromLastTag(same_branch=True))
|
||||
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
|
||||
#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440"))
|
||||
Reference in New Issue
Block a user