# release_robot.py
#
# SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# for a copy of the GNU General Public License
# and for a copy of the Apache
# License, Version 2.0.
#
"""Tests for release_robot."""
import datetime
import logging
import os
import re
import shutil
import sys
import tempfile
import time
import unittest
from typing import ClassVar, Optional
from unittest.mock import MagicMock, patch
from dulwich.contrib import release_robot
from dulwich.repo import Repo
from dulwich.tests.utils import make_commit, make_tag
BASEDIR = os.path.abspath(os.path.dirname(__file__)) # this directory
def gmtime_to_datetime(gmt):
return datetime.datetime(*time.gmtime(gmt)[:6])
class TagPatternTests(unittest.TestCase):
"""test tag patterns."""
def test_tag_pattern(self) -> None:
"""Test tag patterns."""
test_cases = {
"0.3": "0.3",
"v0.3": "0.3",
"release0.3": "0.3",
"Release-0.3": "0.3",
"v0.3rc1": "0.3rc1",
"v0.3-rc1": "0.3-rc1",
"v0.3-rc.1": "0.3-rc.1",
"version 0.3": "0.3",
"version_0.3_rc_1": "0.3_rc_1",
"v1": "1",
"0.3rc1": "0.3rc1",
}
for testcase, version in test_cases.items():
matches = re.match(release_robot.PATTERN, testcase)
self.assertEqual(matches.group(1), version)
def test_pattern_no_match(self) -> None:
"""Test tags that don't match the pattern."""
test_cases = [
"master",
"HEAD",
"feature-branch",
"no-numbers",
"_",
]
for testcase in test_cases:
matches = re.match(release_robot.PATTERN, testcase)
self.assertIsNone(matches)
class GetRecentTagsTest(unittest.TestCase):
"""test get recent tags."""
# Git repo for dulwich project
test_repo = os.path.join(BASEDIR, "dulwich_test_repo.zip")
committer = b"Mark Mikofski "
test_tags: ClassVar[list[bytes]] = [b"v0.1a", b"v0.1"]
tag_test_data: ClassVar[
dict[bytes, tuple[int, bytes, Optional[tuple[int, bytes]]]]
] = {
test_tags[0]: (1484788003, b"3" * 40, None),
test_tags[1]: (1484788314, b"1" * 40, (1484788401, b"2" * 40)),
}
@classmethod
def setUpClass(cls) -> None:
cls.projdir = tempfile.mkdtemp() # temporary project directory
cls.repo = Repo.init(cls.projdir) # test repo
obj_store = cls.repo.object_store # test repo object store
# commit 1 ('2017-01-19T01:06:43')
cls.c1 = make_commit(
id=cls.tag_test_data[cls.test_tags[0]][1],
commit_time=cls.tag_test_data[cls.test_tags[0]][0],
message=b"unannotated tag",
author=cls.committer,
)
obj_store.add_object(cls.c1)
# tag 1: unannotated
cls.t1 = cls.test_tags[0]
cls.repo[b"refs/tags/" + cls.t1] = cls.c1.id # add unannotated tag
# commit 2 ('2017-01-19T01:11:54')
cls.c2 = make_commit(
id=cls.tag_test_data[cls.test_tags[1]][1],
commit_time=cls.tag_test_data[cls.test_tags[1]][0],
message=b"annotated tag",
parents=[cls.c1.id],
author=cls.committer,
)
obj_store.add_object(cls.c2)
# tag 2: annotated ('2017-01-19T01:13:21')
cls.t2 = make_tag(
cls.c2,
id=cls.tag_test_data[cls.test_tags[1]][2][1],
name=cls.test_tags[1],
tag_time=cls.tag_test_data[cls.test_tags[1]][2][0],
)
obj_store.add_object(cls.t2)
cls.repo[b"refs/heads/master"] = cls.c2.id
cls.repo[b"refs/tags/" + cls.t2.name] = cls.t2.id # add annotated tag
@classmethod
def tearDownClass(cls) -> None:
cls.repo.close()
shutil.rmtree(cls.projdir)
def test_get_recent_tags(self) -> None:
"""Test get recent tags."""
tags = release_robot.get_recent_tags(self.projdir) # get test tags
for tag, metadata in tags:
tag = tag.encode("utf-8")
test_data = self.tag_test_data[tag] # test data tag
# test commit date, id and author name
self.assertEqual(metadata[0], gmtime_to_datetime(test_data[0]))
self.assertEqual(metadata[1].encode("utf-8"), test_data[1])
self.assertEqual(metadata[2].encode("utf-8"), self.committer)
# skip unannotated tags
tag_obj = test_data[2]
if not tag_obj:
continue
# tag date, id and name
self.assertEqual(metadata[3][0], gmtime_to_datetime(tag_obj[0]))
self.assertEqual(metadata[3][1].encode("utf-8"), tag_obj[1])
self.assertEqual(metadata[3][2].encode("utf-8"), tag)
def test_get_recent_tags_sorting(self) -> None:
"""Test that tags are sorted by commit time from newest to oldest."""
tags = release_robot.get_recent_tags(self.projdir)
# v0.1 should be first as it's newer
self.assertEqual(tags[0][0], "v0.1")
# v0.1a should be second as it's older
self.assertEqual(tags[1][0], "v0.1a")
def test_get_recent_tags_non_tag_refs(self) -> None:
"""Test that non-tag refs are ignored."""
# Create a commit on a branch to test that it's not included
branch_commit = make_commit(
message=b"branch commit",
author=self.committer,
commit_time=int(time.time()),
)
self.repo.object_store.add_object(branch_commit)
self.repo[b"refs/heads/test-branch"] = branch_commit.id
# Get tags and ensure only the actual tags are returned
tags = release_robot.get_recent_tags(self.projdir)
self.assertEqual(len(tags), 2) # Still only 2 tags
tag_names = [tag[0] for tag in tags]
self.assertIn("v0.1", tag_names)
self.assertIn("v0.1a", tag_names)
self.assertNotIn("test-branch", tag_names)
class GetCurrentVersionTests(unittest.TestCase):
"""Test get_current_version function."""
def setUp(self):
"""Set up a test repository for each test."""
self.projdir = tempfile.mkdtemp()
self.repo = Repo.init(self.projdir)
self.addCleanup(self.cleanup)
def cleanup(self):
"""Clean up after test."""
self.repo.close()
shutil.rmtree(self.projdir)
def test_no_tags(self):
"""Test behavior when repo has no tags."""
# Create a repo with no tags
result = release_robot.get_current_version(self.projdir)
self.assertIsNone(result)
def test_tag_with_pattern_match(self):
"""Test with a tag that matches the pattern."""
# Create a test commit and tag
c = make_commit(message=b"Test commit")
self.repo.object_store.add_object(c)
self.repo[b"refs/tags/v1.2.3"] = c.id
self.repo[b"HEAD"] = c.id
# Test that the version is extracted correctly
result = release_robot.get_current_version(self.projdir)
self.assertEqual("1.2.3", result)
def test_tag_no_pattern_match(self):
"""Test with a tag that doesn't match the pattern."""
# Create a test commit and tag that won't match the default pattern
c = make_commit(message=b"Test commit")
self.repo.object_store.add_object(c)
self.repo[b"refs/tags/no-version-tag"] = c.id
self.repo[b"HEAD"] = c.id
# Test that the full tag is returned when no match
result = release_robot.get_current_version(self.projdir)
self.assertEqual("no-version-tag", result)
def test_with_logger(self):
"""Test with a logger when regex match fails."""
# Create a test commit and tag that won't match the pattern
c = make_commit(message=b"Test commit")
self.repo.object_store.add_object(c)
self.repo[b"refs/tags/no-version-tag"] = c.id
self.repo[b"HEAD"] = c.id
# Create a logger
logger = logging.getLogger("test_logger")
# Test with the logger
result = release_robot.get_current_version(self.projdir, logger=logger)
self.assertEqual("no-version-tag", result)
def test_custom_pattern(self):
"""Test with a custom regex pattern."""
# Create a test commit and tag
c = make_commit(message=b"Test commit")
self.repo.object_store.add_object(c)
self.repo[b"refs/tags/CUSTOM-99.88.77"] = c.id
self.repo[b"HEAD"] = c.id
# Test with a custom pattern
custom_pattern = r"CUSTOM-([\d\.]+)"
result = release_robot.get_current_version(self.projdir, pattern=custom_pattern)
self.assertEqual("99.88.77", result)
def test_with_logger_debug_call(self):
"""Test that the logger.debug method is actually called."""
# Create a test commit and tag that won't match the pattern
c = make_commit(message=b"Test commit")
self.repo.object_store.add_object(c)
self.repo[b"refs/tags/no-version-tag"] = c.id
self.repo[b"HEAD"] = c.id
# Create a mock logger
mock_logger = MagicMock()
# Test with the mock logger
result = release_robot.get_current_version(self.projdir, logger=mock_logger)
# Verify logger.debug was called
mock_logger.debug.assert_called_once()
# Check the tag name is in the debug message
self.assertIn("no-version-tag", mock_logger.debug.call_args[0][2])
# The result should still be the full tag
self.assertEqual("no-version-tag", result)
def test_multiple_tags(self):
"""Test behavior with multiple tags to ensure we get the most recent."""
# Create multiple commits and tags with different timestamps
c1 = make_commit(message=b"First commit", commit_time=1000)
c2 = make_commit(message=b"Second commit", commit_time=2000, parents=[c1.id])
self.repo.object_store.add_object(c1)
self.repo.object_store.add_object(c2)
# Add tags with older commit first
self.repo[b"refs/tags/v0.9.0"] = c1.id
self.repo[b"refs/tags/v1.0.0"] = c2.id
self.repo[b"HEAD"] = c2.id
# Get the current version - should be from the most recent commit
result = release_robot.get_current_version(self.projdir)
self.assertEqual("1.0.0", result)
class MainFunctionTests(unittest.TestCase):
"""Test the __main__ block."""
def setUp(self):
"""Set up a test repository."""
self.projdir = tempfile.mkdtemp()
self.repo = Repo.init(self.projdir)
# Create a test commit and tag
c = make_commit(message=b"Test commit")
self.repo.object_store.add_object(c)
self.repo[b"refs/tags/v3.2.1"] = c.id
self.repo[b"HEAD"] = c.id
self.addCleanup(self.cleanup)
def cleanup(self):
"""Clean up after test."""
self.repo.close()
shutil.rmtree(self.projdir)
@patch.object(sys, "argv", ["release_robot.py"])
@patch("builtins.print")
def test_main_default_dir(self, mock_print):
"""Test main function with default directory."""
# Run the __main__ block code with mocked environment
module_globals = {
"__name__": "__main__",
"sys": sys,
"get_current_version": lambda projdir: "3.2.1",
"PROJDIR": ".",
}
exec(
compile(
"if __name__ == '__main__':\n if len(sys.argv) > 1:\n _PROJDIR = sys.argv[1]\n else:\n _PROJDIR = PROJDIR\n print(get_current_version(projdir=_PROJDIR))",
"",
"exec",
),
module_globals,
)
# Check that print was called with the version
mock_print.assert_called_once_with("3.2.1")
@patch.object(sys, "argv", ["release_robot.py", "/custom/path"])
@patch("builtins.print")
@patch("dulwich.contrib.release_robot.get_current_version")
def test_main_custom_dir(self, mock_get_version, mock_print):
"""Test main function with custom directory from command line."""
mock_get_version.return_value = "4.5.6"
# Run the __main__ block code with mocked environment
module_globals = {
"__name__": "__main__",
"sys": sys,
"get_current_version": mock_get_version,
"PROJDIR": ".",
}
exec(
compile(
"if __name__ == '__main__':\n if len(sys.argv) > 1:\n _PROJDIR = sys.argv[1]\n else:\n _PROJDIR = PROJDIR\n print(get_current_version(projdir=_PROJDIR))",
"",
"exec",
),
module_globals,
)
# Check that get_current_version was called with the right arg
mock_get_version.assert_called_once_with(projdir="/custom/path")
mock_print.assert_called_once_with("4.5.6")