rpm-version 0.5.0

A library for dealing with RPM versions (NEVRA, EVR) correctly. Sort algorithm is identical to RPM.
Documentation 
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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

"""Tests for Evr, Nevra, evr_compare, evr_sort, and Requirement."""

from rpm_version import Evr, Nevra, evr_compare, evr_sort, nevra_sort


class TestEvr:
    def test_construct(self):
        e = Evr("1", "2.3.4", "5.el9")
        assert e.epoch == "1"
        assert e.version == "2.3.4"
        assert e.release == "5.el9"

    def test_parse(self):
        e = Evr.parse("1:2.3.4-5")
        assert e.epoch == "1"
        assert e.version == "2.3.4"
        assert e.release == "5"

    def test_parse_no_epoch(self):
        e = Evr.parse("2.3.4-5")
        assert e.epoch == ""
        assert e.version == "2.3.4"
        assert e.release == "5"

    def test_str(self):
        e = Evr("1", "2.3", "4")
        assert str(e) == "1:2.3-4"

    def test_repr(self):
        e = Evr("1", "2.3", "4")
        assert "Evr" in repr(e)

    def test_normalized_form(self):
        e = Evr("", "1.0", "1")
        assert e.evr() == "0:1.0-1"

    def test_normalized_form_with_epoch(self):
        e = Evr("2", "1.0", "1")
        assert e.evr() == "2:1.0-1"

    def test_ordering(self):
        a = Evr.parse("1.0-1")
        b = Evr.parse("2.0-1")
        assert a < b
        assert b > a
        assert a <= b
        assert b >= a

    def test_equality(self):
        a = Evr.parse("1.0-1")
        b = Evr.parse("1.0-1")
        assert a == b
        assert not (a != b)

    def test_epoch_comparison(self):
        a = Evr.parse("1:1.0-1")
        b = Evr.parse("2:1.0-1")
        assert a < b

    def test_tilde_prerelease(self):
        """Tilde (~) denotes a pre-release: 1.0~rc1 sorts before 1.0."""
        assert Evr.parse("1.0~rc1-1") < Evr.parse("1.0-1")
        assert Evr.parse("1.0~rc1-1") < Evr.parse("1.0~rc2-1")

    def test_caret_snapshot(self):
        """Caret (^) denotes a post-release snapshot: 1.0^git1 sorts after 1.0 but before 1.1."""
        assert Evr.parse("1.0-1") < Evr.parse("1.0^git1-1")
        assert Evr.parse("1.0^git1-1") < Evr.parse("1.1-1")

    def test_tilde_and_caret_combined(self):
        """Tilde and caret can combine: 1.0~rc1^git1 sorts after 1.0~rc1 but before 1.0."""
        assert Evr.parse("1.0~rc1-1") < Evr.parse("1.0~rc1^git1-1")
        assert Evr.parse("1.0~rc1^git1-1") < Evr.parse("1.0-1")


class TestEvrCompare:
    def test_less(self):
        assert evr_compare("1.0-1", "2.0-1") == -1

    def test_greater(self):
        assert evr_compare("2:1.0-1", "1:9.9-1") == 1

    def test_equal(self):
        assert evr_compare("1.0-1", "1.0-1") == 0

    def test_release_comparison(self):
        assert evr_compare("1.0-1", "1.0-2") == -1


class TestNevra:
    def test_construct(self):
        n = Nevra("foo", "1", "2.3", "4", "x86_64")
        assert n.name == "foo"
        assert n.epoch == "1"
        assert n.version == "2.3"
        assert n.release == "4"
        assert n.arch == "x86_64"

    def test_parse(self):
        n = Nevra.parse("foo-1:2.3-4.x86_64")
        assert n.name == "foo"
        assert n.epoch == "1"
        assert n.version == "2.3"
        assert n.release == "4"
        assert n.arch == "x86_64"

    def test_str(self):
        n = Nevra.parse("foo-1:2.3-4.x86_64")
        assert str(n) == "foo-1:2.3-4.x86_64"

    def test_repr(self):
        n = Nevra.parse("foo-1:2.3-4.x86_64")
        assert "Nevra" in repr(n)

    def test_nvra(self):
        n = Nevra.parse("foo-1:2.3-4.x86_64")
        assert n.nvra() == "foo-2.3-4.x86_64"

    def test_nevra_short(self):
        n = Nevra.parse("foo-1:2.3-4.x86_64")
        assert n.nevra_short() == "foo-1:2.3-4.x86_64"
        n = Nevra.parse("foo-2.3-4.x86_64")
        assert n.nevra_short() == "foo-2.3-4.x86_64"

    def test_evr(self):
        n = Nevra.parse("foo-1:2.3-4.x86_64")
        evr = n.evr()
        assert isinstance(evr, Evr)
        assert evr.epoch == "1"
        assert evr.version == "2.3"

    def test_ordering(self):
        a = Nevra.parse("foo-1.0-1.x86_64")
        b = Nevra.parse("foo-2.0-1.x86_64")
        assert a < b

    def test_equality(self):
        a = Nevra.parse("foo-1.0-1.x86_64")
        b = Nevra.parse("foo-1.0-1.x86_64")
        assert a == b


class TestEvrSort:
    def test_basic_sort(self):
        result = evr_sort(["2.0-1", "1.0-1", "3.0-1"])
        assert result == ["1.0-1", "2.0-1", "3.0-1"]

    def test_epoch_sort(self):
        result = evr_sort(["2.0-1", "1:0.5-1", "1.0-1"])
        assert result == ["1.0-1", "2.0-1", "1:0.5-1"]

    def test_tilde_and_caret(self):
        result = evr_sort(["1.0^git1-1", "1.0-1", "1.0~rc1-1", "1.1-1"])
        assert result == ["1.0~rc1-1", "1.0-1", "1.0^git1-1", "1.1-1"]

    def test_empty_list(self):
        assert evr_sort([]) == []

    def test_single_element(self):
        assert evr_sort(["1.0-1"]) == ["1.0-1"]

    def test_matches_elementwise(self):
        versions = ["3.0-1", "1:0.1-1", "1.0~rc1-1", "2.0-1", "1.0-1"]
        assert evr_sort(versions) == sorted(versions, key=Evr.parse)


class TestNevraSort:
    def test_basic_sort(self):
        result = nevra_sort(
            ["foo-2.0-1.x86_64", "bar-1.0-1.x86_64", "foo-1.0-1.x86_64"]
        )
        assert result == ["bar-1.0-1.x86_64", "foo-1.0-1.x86_64", "foo-2.0-1.x86_64"]

    def test_epoch_sort(self):
        result = nevra_sort(
            ["foo-2.0-1.x86_64", "foo-1:0.5-1.x86_64", "foo-1.0-1.x86_64"]
        )
        assert result == ["foo-1.0-1.x86_64", "foo-2.0-1.x86_64", "foo-1:0.5-1.x86_64"]

    def test_different_arches(self):
        result = nevra_sort(["foo-1.0-1.x86_64", "foo-1.0-1.i686", "foo-1.0-1.noarch"])
        assert result == ["foo-1.0-1.i686", "foo-1.0-1.noarch", "foo-1.0-1.x86_64"]

    def test_empty_list(self):
        assert nevra_sort([]) == []

    def test_matches_elementwise(self):
        packages = ["foo-2.0-1.x86_64", "bar-1:0.1-1.noarch", "baz-1.0~rc1-1.i686"]
        assert nevra_sort(packages) == sorted(packages, key=Nevra.parse)


class TestHash:
    def test_evr_hashable(self):
        s = {Evr.parse("1.0-1"), Evr.parse("2.0-1")}
        assert len(s) == 2

    def test_evr_epoch_hash_consistency(self):
        a = Evr.parse("1.0-1")
        b = Evr.parse("0:1.0-1")
        assert a == b
        assert hash(a) == hash(b)

    def test_nevra_hashable(self):
        s = {Nevra.parse("foo-1.0-1.x86_64"), Nevra.parse("bar-1.0-1.x86_64")}
        assert len(s) == 2

    def test_nevra_epoch_hash_consistency(self):
        a = Nevra.parse("foo-1.0-1.x86_64")
        b = Nevra.parse("foo-0:1.0-1.x86_64")
        assert a == b
        assert hash(a) == hash(b)