release-tools/tests/test_release_tag.py at 097ceeff4b6aa96efb244fa80d7adce28f75469e · hugovk/release-tools · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
import io
from subprocess import CompletedProcess

import pytest
from pytest_mock import MockerFixture

import release


def test_tag() -> None:
    # Arrange
    tag_name = "3.12.2"

    # Act
    tag = release.Tag(tag_name)

    # Assert
    assert str(tag) == "3.12.2"
    assert str(tag.next_minor_release()) == "3.13.0a0"
    assert tag.as_tuple() == (3, 12, 2, "f", 0)
    assert tag.branch == "3.12"
    assert tag.gitname == "v3.12.2"
    assert tag.long_name == "3.12.2"
    assert tag.is_alpha_release is False
    assert tag.is_feature_freeze_release is False
    assert tag.is_release_candidate is False
    assert tag.nickname == "3122"
    assert tag.normalized() == "3.12.2"


def test_tag_phase() -> None:
    # Arrange
    alpha = release.Tag("3.13.0a7")
    beta1 = release.Tag("3.13.0b1")
    beta4 = release.Tag("3.13.0b4")
    rc = release.Tag("3.13.0rc3")
    final = release.Tag("3.13.0")

    # Act / Assert
    assert alpha.is_alpha_release is True
    assert alpha.is_feature_freeze_release is False
    assert alpha.is_release_candidate is False
    assert alpha.is_final is False

    assert beta1.is_alpha_release is False
    assert beta1.is_feature_freeze_release is True
    assert beta1.is_release_candidate is False
    assert beta1.is_final is False

    assert beta4.is_alpha_release is False
    assert beta4.is_feature_freeze_release is False
    assert beta4.is_release_candidate is False
    assert beta4.is_final is False

    assert rc.is_alpha_release is False
    assert rc.is_feature_freeze_release is False
    assert rc.is_release_candidate is True
    assert rc.is_final is False

    assert final.is_alpha_release is False
    assert final.is_feature_freeze_release is False
    assert final.is_release_candidate is False
    assert final.is_final is True


def test_tag_committed_at_not_found() -> None:
    # Arrange
    tag = release.Tag("3.12.2")

    # Act / Assert
    with pytest.raises(SystemExit):
        tag.committed_at()


def test_tag_committed(mocker: MockerFixture) -> None:
    # Arrange
    tag = release.Tag("3.12.2")

    proc = CompletedProcess([], 0)
    proc.stdout = b"1707250784"
    mocker.patch("subprocess.run", return_value=proc)

    # Act / Assert
    assert str(tag.committed_at) == "2024-02-06 20:19:44+00:00"


def test_tag_dot(mocker: MockerFixture) -> None:
    # Arrange
    tag_name = "."
    mocker.patch("os.getcwd", return_value="/path/to/3.12.2")

    # Act
    tag = release.Tag(tag_name)

    # Assert
    assert str(tag) == "3.12.2"


def test_tag_invalid() -> None:
    # Arrange
    tag_name = "bleep"

    # Act / Assert
    with pytest.raises(SystemExit):
        release.Tag(tag_name)


def test_tag_docs_attributes() -> None:
    # Arrange
    alpha = release.Tag("3.13.0a7")
    beta = release.Tag("3.13.0b1")
    rc = release.Tag("3.13.0rc3")
    final_zero = release.Tag("3.13.0")
    final_3 = release.Tag("3.13.3")

    # Act / Assert
    assert alpha.includes_docs is False
    assert beta.includes_docs is False
    assert rc.includes_docs is True
    assert final_zero.includes_docs is True
    assert final_3.includes_docs is True

    assert alpha.doc_version == "3.13"
    assert beta.doc_version == "3.13"
    assert rc.doc_version == "3.13"
    assert final_zero.doc_version == "3.13"
    assert final_3.doc_version == "3.13.3"


def test_tag_long_name() -> None:
    # Arrange
    alpha = release.Tag("3.13.0a7")
    beta = release.Tag("3.13.0b1")
    rc = release.Tag("3.13.0rc3")
    final_zero = release.Tag("3.13.0")
    final_3 = release.Tag("3.13.3")

    # Act / Assert
    assert alpha.long_name == "3.13.0 alpha 7"
    assert beta.long_name == "3.13.0 beta 1"
    assert rc.long_name == "3.13.0 release candidate 3"
    assert final_zero.long_name == "3.13.0"
    assert final_3.long_name == "3.13.3"


@pytest.mark.parametrize(
    ["version", "expected"],
    [
        ("3.12.10", True),
        ("3.13.3", False),
    ],
)
def test_tag_is_security_release(
    version: str, expected: str, mocker: MockerFixture
) -> None:
    # Arrange
    mock_response = b"""
    {
        "3.13": {
            "status": "bugfix"
        },
        "3.12": {
            "status": "security"
        }
    }
    """
    mocker.patch("urllib.request.urlopen", return_value=io.BytesIO(mock_response))

    # Act
    tag = release.Tag(version)

    # Assert
    assert tag.is_security_release is expected