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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
import subprocess
from unittest import mock
import pytest
from briefcase.exceptions import BriefcaseCommandError, UnsupportedHostError
from briefcase.integrations.flatpak import Flatpak
def test_short_circuit(mock_tools):
"""Tool is not created if already cached."""
mock_tools.flatpak = "tool"
tool = Flatpak.verify(mock_tools)
assert tool == "tool"
assert tool == mock_tools.flatpak
@pytest.mark.parametrize("host_os", ["Darwin", "Windows", "wonky"])
def test_unsupported_os(mock_tools, host_os):
"""When host OS is not supported, an error is raised."""
mock_tools.host_os = host_os
with pytest.raises(
UnsupportedHostError,
match=f"{Flatpak.name} is not supported on {host_os}",
):
Flatpak.verify(mock_tools)
def test_flatpak_not_installed(mock_tools):
"""If flatpak isn't installed, an error is raised."""
# Mock the response from a missing tool
mock_tools.subprocess.check_output.side_effect = FileNotFoundError
with pytest.raises(
BriefcaseCommandError,
match=r"Briefcase requires the Flatpak toolchain, but it does not appear to be installed.",
):
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
],
any_order=False,
)
def test_flatpak_error(mock_tools):
"""If `flatpak --version` fails, an error is raised."""
# Mock the side effect of an unsuccessful call to flatpak
mock_tools.subprocess.check_output.side_effect = subprocess.CalledProcessError(
cmd="flatpak --version", returncode=1
)
with pytest.raises(
BriefcaseCommandError,
match=r"Unable to invoke flatpak.",
):
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
],
any_order=False,
)
def test_flatpak_old(mock_tools):
"""If `flatpak --version` returns an old version, an error is raised."""
# Mock the side effect of a successful call to an older version of Flatpak
mock_tools.subprocess.check_output.return_value = "Flatpak 0.10.9\n"
with pytest.raises(
BriefcaseCommandError,
match=r"Briefcase requires Flatpak 1.0 or later.",
):
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
],
any_order=False,
)
def test_flatpak_builder_not_installed(mock_tools):
"""If flatpak isn't installed, an error is raised."""
# Mock the side effect of a call to a missing flatpak-builder
mock_tools.subprocess.check_output.side_effect = [
"Flatpak 1.12.7",
FileNotFoundError,
]
with pytest.raises(
BriefcaseCommandError,
match=r"Briefcase requires the full Flatpak development toolchain, but flatpak-builder",
):
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
mock.call(["flatpak-builder", "--version"]),
],
any_order=False,
)
def test_flatpak_builder_error(mock_tools):
"""If `flatpak-builder --version` fails, an error is raised."""
# Mock the side effect of an unsuccessful call to flatpak-builder
mock_tools.subprocess.check_output.side_effect = [
"Flatpak 1.12.7",
subprocess.CalledProcessError(cmd="flatpak-builder --version", returncode=1),
]
with pytest.raises(
BriefcaseCommandError,
match=r"Unable to invoke flatpak-builder.",
):
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
mock.call(["flatpak-builder", "--version"]),
],
any_order=False,
)
def test_flatpak_builder_old(mock_tools):
"""If the version of flatpak-builder is old, an error is raised."""
# Mock the side effect of a call to a missing flatpak-builder
mock_tools.subprocess.check_output.side_effect = [
"Flatpak 1.12.7",
"flatpak-builder 0.10.9",
]
with pytest.raises(
BriefcaseCommandError,
match=r"Briefcase requires flatpak-builder 1.0 or later.",
):
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
mock.call(["flatpak-builder", "--version"]),
],
any_order=False,
)
@pytest.mark.parametrize(
"flatpak_builder_version",
[
# Ubuntu 22.04; flatpak-builder < 1.3
"flatpak-builder 1.2.2",
# Fedora 38; flatpak-builder >= 1.3
"flatpak-builder-1.3.3",
],
)
def test_installed(mock_tools, flatpak_builder_version, capsys):
"""If flatpak is installed, it can be verified."""
mock_tools.subprocess.check_output.side_effect = [
"Flatpak 1.12.7",
flatpak_builder_version,
]
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
mock.call(["flatpak-builder", "--version"]),
],
any_order=False,
)
# We shouldn't get any warnings about unknown versions.
output = capsys.readouterr()
assert (
"** WARNING: Unable to determine the version of flatpak-builder"
not in output.out
)
assert output.err == ""
@pytest.mark.parametrize(
"flatpak_version",
[
# Different tool identification
"not-flatpak 1.2.2",
# No version ID
"Flatpak",
# Non-integer version ID
"Flatpak x.y.z",
],
)
def test_installed_unknown_flatpak_version(mock_tools, flatpak_version, capsys):
"""If flatpak is installed, but the version can't be determined, a warning is
raised, but flatpak is verified."""
mock_tools.subprocess.check_output.side_effect = [
flatpak_version,
"flatpak-builder 1.2.2",
]
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
mock.call(["flatpak-builder", "--version"]),
],
any_order=False,
)
output = capsys.readouterr()
assert "** WARNING: Unable to determine the version of Flatpak" in output.out
assert output.err == ""
@pytest.mark.parametrize(
"builder_version",
[
# Different tool identification
"not-flatpak-builder 1.2.2",
# No version ID
"flatpak-builder",
# Non-integer version ID
"flatpak-builder x.y.z",
],
)
def test_installed_unknown_builder_version(mock_tools, builder_version, capsys):
"""If flatpak-builder is installed, but the version can't be determined, a warning
is raised, but flatpak is verified."""
mock_tools.subprocess.check_output.side_effect = [
"Flatpak 1.12.7",
builder_version,
]
Flatpak.verify(mock_tools)
mock_tools.subprocess.check_output.assert_has_calls(
[
mock.call(["flatpak", "--version"]),
mock.call(["flatpak-builder", "--version"]),
],
any_order=False,
)
output = capsys.readouterr()
assert (
"** WARNING: Unable to determine the version of flatpak-builder" in output.out
)
assert output.err == ""
|
