1 // Copyright 2010 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/nix/xdg_util.h"
6
7 #include <string_view>
8
9 #include "base/base_paths.h"
10 #include "base/command_line.h"
11 #include "base/environment.h"
12 #include "base/files/file_path.h"
13 #include "base/functional/callback_helpers.h"
14 #include "base/nix/scoped_xdg_activation_token_injector.h"
15 #include "base/process/launch.h"
16 #include "base/test/bind.h"
17 #include "base/test/scoped_path_override.h"
18 #include "testing/gmock/include/gmock/gmock.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20
21 using ::testing::_;
22 using ::testing::DoAll;
23 using ::testing::Eq;
24 using ::testing::Return;
25 using ::testing::SetArgPointee;
26
27 namespace base {
28 namespace nix {
29
30 namespace {
31
32 class MockEnvironment : public Environment {
33 public:
34 MOCK_METHOD2(GetVar, bool(std::string_view, std::string* result));
35 MOCK_METHOD2(SetVar, bool(std::string_view, const std::string& new_value));
36 MOCK_METHOD1(UnSetVar, bool(std::string_view));
37 };
38
39 // Needs to be const char* to make gmock happy.
40 const char* const kDesktopGnome = "gnome";
41 const char* const kDesktopGnomeFallback = "gnome-fallback";
42 const char* const kDesktopMATE = "mate";
43 const char* const kDesktopKDE4 = "kde4";
44 const char* const kDesktopKDE = "kde";
45 const char* const kDesktopXFCE = "xfce";
46 const char* const kXdgDesktopCinnamon = "X-Cinnamon";
47 const char* const kXdgDesktopDeepin = "Deepin";
48 const char* const kXdgDesktopGNOME = "GNOME";
49 const char* const kXdgDesktopGNOMEClassic = "GNOME:GNOME-Classic";
50 const char* const kXdgDesktopKDE = "KDE";
51 const char* const kXdgDesktopPantheon = "Pantheon";
52 const char* const kXdgDesktopUKUI = "UKUI";
53 const char* const kXdgDesktopUnity = "Unity";
54 const char* const kXdgDesktopUnity7 = "Unity:Unity7";
55 const char* const kXdgDesktopUnity8 = "Unity:Unity8";
56 const char* const kKDESessionKDE5 = "5";
57 const char* const kKDESessionKDE6 = "6";
58
59 const char kDesktopSession[] = "DESKTOP_SESSION";
60 const char kKDESession[] = "KDE_SESSION_VERSION";
61
62 const char* const kSessionUnknown = "invalid session";
63 const char* const kSessionUnspecified = "unspecified";
64 const char* const kSessionTty = "tty";
65 const char* const kSessionMir = "mir";
66 const char* const kSessionX11 = "x11";
67 const char* const kSessionWayland = "wayland";
68 const char* const kSessionWaylandCapital = "Wayland";
69 const char* const kSessionWaylandWhitespace = "wayland ";
70 const char* const kXdgActivationTokenFromEnv = "test token from env";
71 const char* const kXdgActivationTokenFromCmdLine = "test token from cmd line";
72
73 // This helps EXPECT_THAT(..., ElementsAre(...)) print out more meaningful
74 // failure messages.
FilePathsToStrings(const std::vector<base::FilePath> & paths)75 std::vector<std::string> FilePathsToStrings(
76 const std::vector<base::FilePath>& paths) {
77 std::vector<std::string> values;
78 for (const auto& path : paths) {
79 values.push_back(path.value());
80 }
81 return values;
82 }
83
84 } // namespace
85
TEST(XDGUtilTest,GetXDGDataWriteLocation)86 TEST(XDGUtilTest, GetXDGDataWriteLocation) {
87 // Test that it returns $XDG_DATA_HOME.
88 {
89 MockEnvironment getter;
90 EXPECT_CALL(getter, GetVar(Eq("XDG_DATA_HOME"), _))
91 .WillOnce(DoAll(SetArgPointee<1>("/user/path"), Return(true)));
92
93 ScopedPathOverride home_override(DIR_HOME, FilePath("/home/user"),
94 /*is_absolute=*/true, /*create=*/false);
95 FilePath path = GetXDGDataWriteLocation(&getter);
96 EXPECT_EQ("/user/path", path.value());
97 }
98
99 // Test that $XDG_DATA_HOME falls back to $HOME/.local/share.
100 {
101 MockEnvironment getter;
102 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
103 ScopedPathOverride home_override(DIR_HOME, FilePath("/home/user"),
104 /*is_absolute=*/true, /*create=*/false);
105 FilePath path = GetXDGDataWriteLocation(&getter);
106 EXPECT_EQ("/home/user/.local/share", path.value());
107 }
108 }
109
TEST(XDGUtilTest,GetXDGDataSearchLocations)110 TEST(XDGUtilTest, GetXDGDataSearchLocations) {
111 // Test that it returns $XDG_DATA_HOME + $XDG_DATA_DIRS.
112 {
113 MockEnvironment getter;
114 EXPECT_CALL(getter, GetVar(Eq("XDG_DATA_HOME"), _))
115 .WillOnce(DoAll(SetArgPointee<1>("/user/path"), Return(true)));
116 EXPECT_CALL(getter, GetVar(Eq("XDG_DATA_DIRS"), _))
117 .WillOnce(DoAll(SetArgPointee<1>("/system/path/1:/system/path/2"),
118 Return(true)));
119 ScopedPathOverride home_override(DIR_HOME, FilePath("/home/user"),
120 /*is_absolute=*/true, /*create=*/false);
121 EXPECT_THAT(
122 FilePathsToStrings(GetXDGDataSearchLocations(&getter)),
123 testing::ElementsAre("/user/path", "/system/path/1", "/system/path/2"));
124 }
125
126 // Test that $XDG_DATA_HOME falls back to $HOME/.local/share.
127 {
128 MockEnvironment getter;
129 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
130 EXPECT_CALL(getter, GetVar(Eq("XDG_DATA_DIRS"), _))
131 .WillOnce(DoAll(SetArgPointee<1>("/system/path/1:/system/path/2"),
132 Return(true)));
133
134 ScopedPathOverride home_override(DIR_HOME, FilePath("/home/user"),
135 /*is_absolute=*/true, /*create=*/false);
136 EXPECT_THAT(FilePathsToStrings(GetXDGDataSearchLocations(&getter)),
137 testing::ElementsAre("/home/user/.local/share",
138 "/system/path/1", "/system/path/2"));
139 }
140
141 // Test that if neither $XDG_DATA_HOME nor $HOME are specified, it still
142 // succeeds.
143 {
144 MockEnvironment getter;
145 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
146 EXPECT_CALL(getter, GetVar(Eq("XDG_DATA_DIRS"), _))
147 .WillOnce(DoAll(SetArgPointee<1>("/system/path/1:/system/path/2"),
148 Return(true)));
149 std::vector<std::string> results =
150 FilePathsToStrings(GetXDGDataSearchLocations(&getter));
151 ASSERT_EQ(3U, results.size());
152 EXPECT_FALSE(results[0].empty());
153 EXPECT_EQ("/system/path/1", results[1]);
154 EXPECT_EQ("/system/path/2", results[2]);
155 }
156
157 // Test that $XDG_DATA_DIRS falls back to the two default paths.
158 {
159 MockEnvironment getter;
160 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
161 EXPECT_CALL(getter, GetVar(Eq("XDG_DATA_HOME"), _))
162 .WillOnce(DoAll(SetArgPointee<1>("/user/path"), Return(true)));
163 ScopedPathOverride home_override(DIR_HOME, FilePath("/home/user"),
164 /*is_absolute=*/true, /*create=*/false);
165 EXPECT_THAT(
166 FilePathsToStrings(GetXDGDataSearchLocations(&getter)),
167 testing::ElementsAre("/user/path", "/usr/local/share", "/usr/share"));
168 }
169 }
170
TEST(XDGUtilTest,GetDesktopEnvironmentGnome)171 TEST(XDGUtilTest, GetDesktopEnvironmentGnome) {
172 MockEnvironment getter;
173 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
174 EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
175 .WillOnce(DoAll(SetArgPointee<1>(kDesktopGnome), Return(true)));
176
177 EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
178 }
179
TEST(XDGUtilTest,GetDesktopEnvironmentMATE)180 TEST(XDGUtilTest, GetDesktopEnvironmentMATE) {
181 MockEnvironment getter;
182 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
183 EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
184 .WillOnce(DoAll(SetArgPointee<1>(kDesktopMATE), Return(true)));
185
186 EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
187 }
188
TEST(XDGUtilTest,GetDesktopEnvironmentKDE4)189 TEST(XDGUtilTest, GetDesktopEnvironmentKDE4) {
190 MockEnvironment getter;
191 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
192 EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
193 .WillOnce(DoAll(SetArgPointee<1>(kDesktopKDE4), Return(true)));
194
195 EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE4, GetDesktopEnvironment(&getter));
196 }
197
TEST(XDGUtilTest,GetDesktopEnvironmentKDE3)198 TEST(XDGUtilTest, GetDesktopEnvironmentKDE3) {
199 MockEnvironment getter;
200 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
201 EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
202 .WillOnce(DoAll(SetArgPointee<1>(kDesktopKDE), Return(true)));
203
204 EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE3, GetDesktopEnvironment(&getter));
205 }
206
TEST(XDGUtilTest,GetDesktopEnvironmentXFCE)207 TEST(XDGUtilTest, GetDesktopEnvironmentXFCE) {
208 MockEnvironment getter;
209 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
210 EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
211 .WillOnce(DoAll(SetArgPointee<1>(kDesktopXFCE), Return(true)));
212
213 EXPECT_EQ(DESKTOP_ENVIRONMENT_XFCE, GetDesktopEnvironment(&getter));
214 }
215
TEST(XDGUtilTest,GetXdgDesktopCinnamon)216 TEST(XDGUtilTest, GetXdgDesktopCinnamon) {
217 MockEnvironment getter;
218 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
219 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
220 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopCinnamon), Return(true)));
221
222 EXPECT_EQ(DESKTOP_ENVIRONMENT_CINNAMON, GetDesktopEnvironment(&getter));
223 }
224
TEST(XDGUtilTest,GetXdgDesktopDeepin)225 TEST(XDGUtilTest, GetXdgDesktopDeepin) {
226 MockEnvironment getter;
227 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
228 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
229 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopDeepin), Return(true)));
230
231 EXPECT_EQ(DESKTOP_ENVIRONMENT_DEEPIN, GetDesktopEnvironment(&getter));
232 }
233
TEST(XDGUtilTest,GetXdgDesktopGnome)234 TEST(XDGUtilTest, GetXdgDesktopGnome) {
235 MockEnvironment getter;
236 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
237 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
238 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopGNOME), Return(true)));
239
240 EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
241 }
242
TEST(XDGUtilTest,GetXdgDesktopGnomeClassic)243 TEST(XDGUtilTest, GetXdgDesktopGnomeClassic) {
244 MockEnvironment getter;
245 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
246 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
247 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopGNOMEClassic), Return(true)));
248
249 EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
250 }
251
TEST(XDGUtilTest,GetXdgDesktopGnomeFallback)252 TEST(XDGUtilTest, GetXdgDesktopGnomeFallback) {
253 MockEnvironment getter;
254 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
255 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
256 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity), Return(true)));
257 EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
258 .WillOnce(DoAll(SetArgPointee<1>(kDesktopGnomeFallback), Return(true)));
259
260 EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
261 }
262
TEST(XDGUtilTest,GetXdgDesktopKDE5)263 TEST(XDGUtilTest, GetXdgDesktopKDE5) {
264 MockEnvironment getter;
265 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
266 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
267 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopKDE), Return(true)));
268 EXPECT_CALL(getter, GetVar(Eq(kKDESession), _))
269 .WillOnce(DoAll(SetArgPointee<1>(kKDESessionKDE5), Return(true)));
270
271 EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE5, GetDesktopEnvironment(&getter));
272 }
273
TEST(XDGUtilTest,GetXdgDesktopKDE6)274 TEST(XDGUtilTest, GetXdgDesktopKDE6) {
275 MockEnvironment getter;
276 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
277 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
278 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopKDE), Return(true)));
279 EXPECT_CALL(getter, GetVar(Eq(kKDESession), _))
280 .WillOnce(DoAll(SetArgPointee<1>(kKDESessionKDE6), Return(true)));
281
282 EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE6, GetDesktopEnvironment(&getter));
283 }
284
TEST(XDGUtilTest,GetXdgDesktopKDE4)285 TEST(XDGUtilTest, GetXdgDesktopKDE4) {
286 MockEnvironment getter;
287 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
288 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
289 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopKDE), Return(true)));
290
291 EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE4, GetDesktopEnvironment(&getter));
292 }
293
TEST(XDGUtilTest,GetXdgDesktopPantheon)294 TEST(XDGUtilTest, GetXdgDesktopPantheon) {
295 MockEnvironment getter;
296 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
297 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
298 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopPantheon), Return(true)));
299
300 EXPECT_EQ(DESKTOP_ENVIRONMENT_PANTHEON, GetDesktopEnvironment(&getter));
301 }
302
TEST(XDGUtilTest,GetXdgDesktopUKUI)303 TEST(XDGUtilTest, GetXdgDesktopUKUI) {
304 MockEnvironment getter;
305 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
306 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
307 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUKUI), Return(true)));
308
309 EXPECT_EQ(DESKTOP_ENVIRONMENT_UKUI, GetDesktopEnvironment(&getter));
310 }
311
TEST(XDGUtilTest,GetXdgDesktopUnity)312 TEST(XDGUtilTest, GetXdgDesktopUnity) {
313 MockEnvironment getter;
314 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
315 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
316 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity), Return(true)));
317
318 EXPECT_EQ(DESKTOP_ENVIRONMENT_UNITY, GetDesktopEnvironment(&getter));
319 }
320
TEST(XDGUtilTest,GetXdgDesktopUnity7)321 TEST(XDGUtilTest, GetXdgDesktopUnity7) {
322 MockEnvironment getter;
323 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
324 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
325 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity7), Return(true)));
326
327 EXPECT_EQ(DESKTOP_ENVIRONMENT_UNITY, GetDesktopEnvironment(&getter));
328 }
329
TEST(XDGUtilTest,GetXdgDesktopUnity8)330 TEST(XDGUtilTest, GetXdgDesktopUnity8) {
331 MockEnvironment getter;
332 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
333 EXPECT_CALL(getter, GetVar(Eq(kXdgCurrentDesktopEnvVar), _))
334 .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity8), Return(true)));
335
336 EXPECT_EQ(DESKTOP_ENVIRONMENT_UNITY, GetDesktopEnvironment(&getter));
337 }
338
TEST(XDGUtilTest,GetXdgSessiontypeUnset)339 TEST(XDGUtilTest, GetXdgSessiontypeUnset) {
340 MockEnvironment getter;
341 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
342
343 EXPECT_EQ(SessionType::kUnset, GetSessionType(getter));
344 }
345
TEST(XDGUtilTest,GetXdgSessionTypeOther)346 TEST(XDGUtilTest, GetXdgSessionTypeOther) {
347 MockEnvironment getter;
348 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
349 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
350 .WillOnce(DoAll(SetArgPointee<1>(kSessionUnknown), Return(true)));
351
352 EXPECT_EQ(SessionType::kOther, GetSessionType(getter));
353 }
354
TEST(XDGUtilTest,GetXdgSessionTypeUnspecified)355 TEST(XDGUtilTest, GetXdgSessionTypeUnspecified) {
356 MockEnvironment getter;
357 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
358 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
359 .WillOnce(DoAll(SetArgPointee<1>(kSessionUnspecified), Return(true)));
360
361 EXPECT_EQ(SessionType::kUnspecified, GetSessionType(getter));
362 }
363
TEST(XDGUtilTest,GetXdgSessionTypeTty)364 TEST(XDGUtilTest, GetXdgSessionTypeTty) {
365 MockEnvironment getter;
366 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
367 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
368 .WillOnce(DoAll(SetArgPointee<1>(kSessionTty), Return(true)));
369
370 EXPECT_EQ(SessionType::kTty, GetSessionType(getter));
371 }
372
TEST(XDGUtilTest,GetXdgSessionTypeMir)373 TEST(XDGUtilTest, GetXdgSessionTypeMir) {
374 MockEnvironment getter;
375 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
376 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
377 .WillOnce(DoAll(SetArgPointee<1>(kSessionMir), Return(true)));
378
379 EXPECT_EQ(SessionType::kMir, GetSessionType(getter));
380 }
381
TEST(XDGUtilTest,GetXdgSessionTypeX11)382 TEST(XDGUtilTest, GetXdgSessionTypeX11) {
383 MockEnvironment getter;
384 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
385 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
386 .WillOnce(DoAll(SetArgPointee<1>(kSessionX11), Return(true)));
387
388 EXPECT_EQ(SessionType::kX11, GetSessionType(getter));
389 }
390
TEST(XDGUtilTest,GetXdgSessionTypeWayland)391 TEST(XDGUtilTest, GetXdgSessionTypeWayland) {
392 MockEnvironment getter;
393 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
394 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
395 .WillOnce(DoAll(SetArgPointee<1>(kSessionWayland), Return(true)));
396
397 EXPECT_EQ(SessionType::kWayland, GetSessionType(getter));
398 }
399
TEST(XDGUtilTest,GetXdgSessionTypeWaylandCapital)400 TEST(XDGUtilTest, GetXdgSessionTypeWaylandCapital) {
401 MockEnvironment getter;
402 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
403 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
404 .WillOnce(DoAll(SetArgPointee<1>(kSessionWaylandCapital), Return(true)));
405
406 EXPECT_EQ(SessionType::kWayland, GetSessionType(getter));
407 }
408
TEST(XDGUtilTest,GetXdgSessionTypeWaylandWhitespace)409 TEST(XDGUtilTest, GetXdgSessionTypeWaylandWhitespace) {
410 MockEnvironment getter;
411 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
412 EXPECT_CALL(getter, GetVar(Eq(kXdgSessionTypeEnvVar), _))
413 .WillOnce(
414 DoAll(SetArgPointee<1>(kSessionWaylandWhitespace), Return(true)));
415
416 EXPECT_EQ(SessionType::kWayland, GetSessionType(getter));
417 }
418
TEST(XDGUtilTest,ExtractXdgActivationTokenFromEnvNotSet)419 TEST(XDGUtilTest, ExtractXdgActivationTokenFromEnvNotSet) {
420 MockEnvironment getter;
421 EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
422 EXPECT_EQ(std::nullopt, ExtractXdgActivationTokenFromEnv(getter));
423 EXPECT_EQ(std::nullopt, TakeXdgActivationToken());
424 }
425
TEST(XDGUtilTest,ExtractXdgActivationTokenFromEnv)426 TEST(XDGUtilTest, ExtractXdgActivationTokenFromEnv) {
427 MockEnvironment getter;
428 EXPECT_CALL(getter, GetVar(Eq("XDG_ACTIVATION_TOKEN"), _))
429 .WillOnce(
430 DoAll(SetArgPointee<1>(kXdgActivationTokenFromEnv), Return(true)));
431 EXPECT_CALL(getter, UnSetVar(Eq("XDG_ACTIVATION_TOKEN")));
432 EXPECT_EQ(kXdgActivationTokenFromEnv,
433 ExtractXdgActivationTokenFromEnv(getter));
434 EXPECT_EQ(kXdgActivationTokenFromEnv, TakeXdgActivationToken());
435 // Should be cleared after the token is taken once.
436 EXPECT_EQ(std::nullopt, TakeXdgActivationToken());
437 }
438
TEST(XDGUtilTest,ExtractXdgActivationTokenFromCmdLineNotSet)439 TEST(XDGUtilTest, ExtractXdgActivationTokenFromCmdLineNotSet) {
440 CommandLine command_line(CommandLine::NO_PROGRAM);
441 ExtractXdgActivationTokenFromCmdLine(command_line);
442 EXPECT_EQ(std::nullopt, TakeXdgActivationToken());
443 }
444
TEST(XDGUtilTest,ExtractXdgActivationTokenFromCmdLine)445 TEST(XDGUtilTest, ExtractXdgActivationTokenFromCmdLine) {
446 CommandLine command_line(CommandLine::NO_PROGRAM);
447 MockEnvironment getter;
448 // Extract activation token initially from env.
449 EXPECT_CALL(getter, GetVar(Eq("XDG_ACTIVATION_TOKEN"), _))
450 .WillOnce(
451 DoAll(SetArgPointee<1>(kXdgActivationTokenFromEnv), Return(true)));
452 EXPECT_CALL(getter, UnSetVar(Eq("XDG_ACTIVATION_TOKEN")));
453 EXPECT_EQ(kXdgActivationTokenFromEnv,
454 ExtractXdgActivationTokenFromEnv(getter));
455 // Now extract token from command line.
456 command_line.AppendSwitchASCII(kXdgActivationTokenSwitch,
457 kXdgActivationTokenFromCmdLine);
458 ExtractXdgActivationTokenFromCmdLine(command_line);
459 // It should match the one from command line, not env.
460 EXPECT_EQ(kXdgActivationTokenFromCmdLine, TakeXdgActivationToken());
461 // Should be cleared after the token is taken once.
462 EXPECT_EQ(std::nullopt, TakeXdgActivationToken());
463 }
464
TEST(XDGUtilTest,ScopedXdgActivationTokenInjector)465 TEST(XDGUtilTest, ScopedXdgActivationTokenInjector) {
466 CommandLine cmd_line(CommandLine::NO_PROGRAM);
467 MockEnvironment getter;
468 cmd_line.AppendSwitch("x");
469 cmd_line.AppendSwitch("y");
470 cmd_line.AppendSwitch("z");
471 CommandLine::SwitchMap initial_switches = cmd_line.GetSwitches();
472 // Set token value in env
473 EXPECT_CALL(getter, GetVar(Eq("XDG_ACTIVATION_TOKEN"), _))
474 .WillOnce(
475 DoAll(SetArgPointee<1>(kXdgActivationTokenFromEnv), Return(true)));
476 EXPECT_CALL(getter, UnSetVar(Eq("XDG_ACTIVATION_TOKEN")));
477 {
478 ScopedXdgActivationTokenInjector scoped_injector(cmd_line, getter);
479 for (const auto& pair : initial_switches) {
480 EXPECT_TRUE(cmd_line.HasSwitch(pair.first));
481 }
482 EXPECT_TRUE(cmd_line.HasSwitch(kXdgActivationTokenSwitch));
483 EXPECT_EQ(kXdgActivationTokenFromEnv,
484 cmd_line.GetSwitchValueASCII(kXdgActivationTokenSwitch));
485 }
486 for (const auto& pair : initial_switches) {
487 EXPECT_TRUE(cmd_line.HasSwitch(pair.first));
488 }
489 EXPECT_FALSE(cmd_line.HasSwitch(nix::kXdgActivationTokenSwitch));
490 }
491
TEST(XDGUtilTest,LaunchOptionsWithXdgActivation)492 TEST(XDGUtilTest, LaunchOptionsWithXdgActivation) {
493 bool received_empty_launch_options = false;
494 CreateLaunchOptionsWithXdgActivation(base::BindLambdaForTesting(
495 [&received_empty_launch_options](LaunchOptions options) {
496 EXPECT_TRUE(options.environment.empty());
497 received_empty_launch_options = true;
498 }));
499 EXPECT_TRUE(received_empty_launch_options);
500
501 ScopedClosureRunner reset_token_creator(base::BindOnce(
502 &SetXdgActivationTokenCreator, XdgActivationTokenCreator()));
503 SetXdgActivationTokenCreator(
504 base::BindRepeating([](XdgActivationTokenCallback callback) {
505 std::move(callback).Run(kXdgActivationTokenFromEnv);
506 }));
507
508 bool received_launch_options_with_test_token = false;
509 CreateLaunchOptionsWithXdgActivation(base::BindLambdaForTesting(
510 [&received_launch_options_with_test_token](LaunchOptions options) {
511 EXPECT_EQ(options.environment["XDG_ACTIVATION_TOKEN"],
512 kXdgActivationTokenFromEnv);
513 received_launch_options_with_test_token = true;
514 }));
515 EXPECT_TRUE(received_launch_options_with_test_token);
516 }
517
518 } // namespace nix
519 } // namespace base
520