blob: 3b97a40e073761e1ec2f390be11e88a0248e136e [file] [log] [blame]
Mike Frysinger1dad0972019-02-23 18:36:37 -05001// Copyright 2019 The Chromium OS Authors. All rights reserved.
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 "dev-install/dev_install.h"
6
Mike Frysinger60260f62019-02-24 02:28:23 -05007#include <unistd.h>
8
9#include <istream>
10#include <sstream>
11#include <string>
12
Mike Frysingerb9c9f6c2019-02-24 02:32:32 -050013#include <base/files/file_path.h>
14#include <base/files/file_util.h>
15#include <base/files/scoped_temp_dir.h>
Mike Frysinger1dad0972019-02-23 18:36:37 -050016#include <gmock/gmock.h>
17#include <gtest/gtest.h>
18
19using ::testing::_;
20using ::testing::Return;
21
22namespace dev_install {
23
24namespace {
25
26class DevInstallMock : public DevInstall {
27 public:
Ben Chan1ea2ba12019-09-19 11:58:03 -070028 MOCK_METHOD(bool, IsDevMode, (), (const, override));
29 MOCK_METHOD(bool,
30 PromptUser,
31 (std::istream&, const std::string&),
32 (override));
Mike Frysinger69c167f2019-02-24 05:14:57 -050033 MOCK_METHOD(bool, ClearStateDir, (const base::FilePath&), (override));
Mike Frysinger3d44f782019-02-25 23:17:08 -050034 MOCK_METHOD(bool,
35 InitializeStateDir,
36 (const base::FilePath& dir),
37 (override));
Mike Frysingerbf36e3c2019-11-02 02:47:50 -040038 MOCK_METHOD(bool,
39 DownloadAndInstallBootstrapPackages,
40 (const base::FilePath&),
41 (override));
Mike Frysinger6fc79c02019-11-04 16:35:11 -050042 MOCK_METHOD(bool, ConfigurePortage, (), (override));
Mike Frysinger2eb3afd2019-11-04 17:44:54 -050043 MOCK_METHOD(bool, InstallExtraPackages, (), (override));
Mike Frysinger1dad0972019-02-23 18:36:37 -050044};
45
46class DevInstallTest : public ::testing::Test {
Mike Frysingeree5af6e2019-02-23 23:47:03 -050047 public:
48 void SetUp() override {
49 // Set the default to dev mode enabled. Most tests want that.
50 ON_CALL(dev_install_, IsDevMode()).WillByDefault(Return(true));
Mike Frysinger69c167f2019-02-24 05:14:57 -050051
Mike Frysinger3d44f782019-02-25 23:17:08 -050052 // Ignore stateful setup for most tests.
53 ON_CALL(dev_install_, InitializeStateDir(_)).WillByDefault(Return(true));
54
Mike Frysingerbf36e3c2019-11-02 02:47:50 -040055 // Ignore bootstrap for most tests.
56 ON_CALL(dev_install_, DownloadAndInstallBootstrapPackages(_))
57 .WillByDefault(Return(true));
58
Mike Frysinger6fc79c02019-11-04 16:35:11 -050059 // Ignore portage setup for most tests.
60 ON_CALL(dev_install_, ConfigurePortage()).WillByDefault(Return(true));
61
Mike Frysinger2eb3afd2019-11-04 17:44:54 -050062 // Ignore extra setup for most tests.
63 ON_CALL(dev_install_, InstallExtraPackages()).WillByDefault(Return(true));
64
Mike Frysinger69c167f2019-02-24 05:14:57 -050065 // Most tests should run with a path that doesn't exist.
66 dev_install_.SetStateDirForTest(base::FilePath("/.path-does-not-exist"));
Mike Frysingeree5af6e2019-02-23 23:47:03 -050067 }
68
Mike Frysinger1dad0972019-02-23 18:36:37 -050069 protected:
70 DevInstallMock dev_install_;
71};
72
73} // namespace
74
75// Check default run through.
76TEST_F(DevInstallTest, Run) {
Mike Frysinger2eb3afd2019-11-04 17:44:54 -050077 EXPECT_EQ(0, dev_install_.Run());
Mike Frysinger1dad0972019-02-23 18:36:37 -050078}
79
Mike Frysingeree5af6e2019-02-23 23:47:03 -050080// Systems not in dev mode should abort.
81TEST_F(DevInstallTest, NonDevMode) {
82 EXPECT_CALL(dev_install_, IsDevMode()).WillOnce(Return(false));
Mike Frysinger69c167f2019-02-24 05:14:57 -050083 EXPECT_CALL(dev_install_, ClearStateDir(_)).Times(0);
Mike Frysingeree5af6e2019-02-23 23:47:03 -050084 EXPECT_EQ(2, dev_install_.Run());
85}
86
Mike Frysinger69c167f2019-02-24 05:14:57 -050087// Check system has been initialized.
88TEST_F(DevInstallTest, AlreadyInitialized) {
89 dev_install_.SetStateDirForTest(base::FilePath("/"));
Mike Frysinger69c167f2019-02-24 05:14:57 -050090 ASSERT_EQ(4, dev_install_.Run());
91}
92
93// Check --reinstall passed.
94TEST_F(DevInstallTest, RunReinstallWorked) {
95 dev_install_.SetReinstallForTest(true);
96 EXPECT_CALL(dev_install_, ClearStateDir(_)).WillOnce(Return(true));
Mike Frysinger2eb3afd2019-11-04 17:44:54 -050097 ASSERT_EQ(0, dev_install_.Run());
Mike Frysinger69c167f2019-02-24 05:14:57 -050098}
99
100// Check when --reinstall is requested but clearing fails.
101TEST_F(DevInstallTest, RunReinstallFails) {
102 dev_install_.SetReinstallForTest(true);
103 EXPECT_CALL(dev_install_, ClearStateDir(_)).WillOnce(Return(false));
Mike Frysinger69c167f2019-02-24 05:14:57 -0500104 ASSERT_EQ(1, dev_install_.Run());
105}
106
107// Check --uninstall passed.
108TEST_F(DevInstallTest, RunUninstall) {
109 dev_install_.SetUninstallForTest(true);
110 EXPECT_CALL(dev_install_, ClearStateDir(_)).WillOnce(Return(true));
Mike Frysinger69c167f2019-02-24 05:14:57 -0500111 ASSERT_EQ(0, dev_install_.Run());
112}
113
Mike Frysinger3d44f782019-02-25 23:17:08 -0500114// Stateful setup failures.
115TEST_F(DevInstallTest, StatefulSetupFailure) {
116 EXPECT_CALL(dev_install_, InitializeStateDir(_)).WillOnce(Return(false));
Mike Frysinger3d44f782019-02-25 23:17:08 -0500117 ASSERT_EQ(5, dev_install_.Run());
118}
119
Mike Frysingerbf36e3c2019-11-02 02:47:50 -0400120// We only bootstrap before exiting.
121TEST_F(DevInstallTest, BootstrapOnly) {
122 dev_install_.SetBootstrapForTest(true);
Mike Frysingerbf36e3c2019-11-02 02:47:50 -0400123 ASSERT_EQ(0, dev_install_.Run());
124}
125
126// Bootstrap failures.
127TEST_F(DevInstallTest, BootstrapFailure) {
128 EXPECT_CALL(dev_install_, DownloadAndInstallBootstrapPackages(_))
129 .WillOnce(Return(false));
Mike Frysingerbf36e3c2019-11-02 02:47:50 -0400130 ASSERT_EQ(7, dev_install_.Run());
131}
132
Mike Frysinger6fc79c02019-11-04 16:35:11 -0500133// Portage setup failures.
134TEST_F(DevInstallTest, PortageFailure) {
135 EXPECT_CALL(dev_install_, ConfigurePortage()).WillOnce(Return(false));
Mike Frysinger6fc79c02019-11-04 16:35:11 -0500136 ASSERT_EQ(8, dev_install_.Run());
137}
138
Mike Frysinger2eb3afd2019-11-04 17:44:54 -0500139// Extra package failures.
140TEST_F(DevInstallTest, ExtraPackagesFailure) {
141 EXPECT_CALL(dev_install_, InstallExtraPackages()).WillOnce(Return(false));
142 ASSERT_EQ(9, dev_install_.Run());
143}
144
Mike Frysinger60260f62019-02-24 02:28:23 -0500145namespace {
146
147class PromptUserTest : public ::testing::Test {
148 protected:
149 DevInstall dev_install_;
150};
151
152} // namespace
153
154// The --yes flag should pass w/out prompting the user.
155TEST_F(PromptUserTest, Forced) {
156 dev_install_.SetYesForTest(true);
157 std::stringstream stream("");
158 EXPECT_TRUE(dev_install_.PromptUser(stream, ""));
159}
160
161// EOF input should fail.
162TEST_F(PromptUserTest, Eof) {
163 std::stringstream stream("");
164 EXPECT_FALSE(dev_install_.PromptUser(stream, ""));
165}
166
167// Default input (hitting enter) should fail.
168TEST_F(PromptUserTest, Default) {
169 std::stringstream stream("\n");
170 EXPECT_FALSE(dev_install_.PromptUser(stream, ""));
171}
172
173// Entering "n" should fail.
174TEST_F(PromptUserTest, No) {
175 std::stringstream stream("n\n");
176 EXPECT_FALSE(dev_install_.PromptUser(stream, ""));
177}
178
179// Entering "y" should pass.
180TEST_F(PromptUserTest, Yes) {
181 std::stringstream stream("y\n");
182 EXPECT_TRUE(dev_install_.PromptUser(stream, ""));
183}
184
Mike Frysingerb9c9f6c2019-02-24 02:32:32 -0500185namespace {
186
187class DeletePathTest : public ::testing::Test {
188 public:
189 void SetUp() override {
190 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
191 test_dir_ = scoped_temp_dir_.GetPath();
192 dev_install_.SetStateDirForTest(test_dir_);
193 }
194
195 protected:
196 DevInstall dev_install_;
197 base::FilePath test_dir_;
198 base::ScopedTempDir scoped_temp_dir_;
199};
200
201} // namespace
202
203// Check missing dir.
204TEST_F(DeletePathTest, Missing) {
205 struct stat st = {};
206 EXPECT_TRUE(dev_install_.DeletePath(st, test_dir_.Append("foo")));
207}
208
209// Check deleting dir contents leaves the dir alone.
210TEST_F(DeletePathTest, Empty) {
211 struct stat st = {};
212 EXPECT_TRUE(dev_install_.DeletePath(st, test_dir_));
213 EXPECT_TRUE(base::PathExists(test_dir_));
214}
215
216// Check mounted deletion.
217TEST_F(DeletePathTest, Mounted) {
218 struct stat st = {};
219 const base::FilePath subdir = test_dir_.Append("subdir");
220 EXPECT_TRUE(base::CreateDirectory(subdir));
221 EXPECT_FALSE(dev_install_.DeletePath(st, test_dir_));
222 EXPECT_TRUE(base::PathExists(subdir));
223}
224
225// Check recursive deletion.
226TEST_F(DeletePathTest, Works) {
227 struct stat st;
228 EXPECT_EQ(0, stat(test_dir_.value().c_str(), &st));
229
230 EXPECT_EQ(3, base::WriteFile(test_dir_.Append("file"), "123", 3));
231 EXPECT_EQ(0, symlink("x", test_dir_.Append("broken-sym").value().c_str()));
232 EXPECT_EQ(0, symlink("file", test_dir_.Append("file-sym").value().c_str()));
233 EXPECT_EQ(0, symlink(".", test_dir_.Append("dir-sym").value().c_str()));
234 EXPECT_EQ(0, symlink("subdir", test_dir_.Append("dir-sym2").value().c_str()));
235 const base::FilePath subdir = test_dir_.Append("subdir");
236 EXPECT_TRUE(base::CreateDirectory(subdir));
237 EXPECT_EQ(3, base::WriteFile(subdir.Append("file"), "123", 3));
238 const base::FilePath subsubdir = test_dir_.Append("subdir");
239 EXPECT_TRUE(base::CreateDirectory(subsubdir));
240 EXPECT_EQ(3, base::WriteFile(subsubdir.Append("file"), "123", 3));
241
242 EXPECT_TRUE(dev_install_.DeletePath(st, test_dir_));
243 EXPECT_TRUE(base::PathExists(test_dir_));
244 EXPECT_EQ(0, rmdir(test_dir_.value().c_str()));
245}
246
Mike Frysinger69c167f2019-02-24 05:14:57 -0500247namespace {
248
Mike Frysinger3eaab632019-11-03 20:19:09 -0500249class CreateMissingDirectoryTest : public ::testing::Test {
250 public:
251 void SetUp() {
252 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
253 test_dir_ = scoped_temp_dir_.GetPath();
254 }
255
256 protected:
257 DevInstall dev_install_;
258 base::FilePath test_dir_;
259 base::ScopedTempDir scoped_temp_dir_;
260};
261
262} // namespace
263
264// Create dirs that don't yet exist.
265TEST_F(CreateMissingDirectoryTest, Works) {
266 const base::FilePath dir = test_dir_.Append("test");
267 ASSERT_TRUE(dev_install_.CreateMissingDirectory(dir));
268 int mode;
269 ASSERT_TRUE(base::GetPosixFilePermissions(dir, &mode));
270 ASSERT_EQ(0755, mode);
271 ASSERT_TRUE(dev_install_.CreateMissingDirectory(dir));
272}
273
274// If a dir already exists, should do nothing.
275TEST_F(CreateMissingDirectoryTest, Existing) {
276 ASSERT_TRUE(dev_install_.CreateMissingDirectory(test_dir_));
277 ASSERT_TRUE(dev_install_.CreateMissingDirectory(test_dir_));
278}
279
280namespace {
281
Mike Frysinger69c167f2019-02-24 05:14:57 -0500282// We could mock out DeletePath, but it's easy to lightly validate it.
283class ClearStateDirMock : public DevInstall {
284 public:
285 MOCK_METHOD(bool,
286 PromptUser,
287 (std::istream&, const std::string&),
288 (override));
289};
290
291class ClearStateDirTest : public ::testing::Test {
292 public:
293 void SetUp() {
294 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
295 test_dir_ = scoped_temp_dir_.GetPath();
296 }
297
298 protected:
299 ClearStateDirMock dev_install_;
300 base::FilePath test_dir_;
301 base::ScopedTempDir scoped_temp_dir_;
302};
303
304} // namespace
305
306// Check user rejecting things.
307TEST_F(ClearStateDirTest, Cancel) {
308 EXPECT_CALL(dev_install_, PromptUser(_, _)).WillOnce(Return(false));
309 const base::FilePath subdir = test_dir_.Append("subdir");
310 ASSERT_TRUE(base::CreateDirectory(subdir));
311 ASSERT_FALSE(dev_install_.ClearStateDir(test_dir_));
312 ASSERT_TRUE(base::PathExists(subdir));
313}
314
315// Check missing dir is handled.
316TEST_F(ClearStateDirTest, Missing) {
317 EXPECT_CALL(dev_install_, PromptUser(_, _)).WillOnce(Return(true));
318 ASSERT_TRUE(dev_install_.ClearStateDir(test_dir_.Append("subdir")));
319 ASSERT_TRUE(base::PathExists(test_dir_));
320}
321
322// Check empty dir is handled.
323TEST_F(ClearStateDirTest, Empty) {
324 EXPECT_CALL(dev_install_, PromptUser(_, _)).WillOnce(Return(true));
325 ASSERT_TRUE(dev_install_.ClearStateDir(test_dir_));
326 ASSERT_TRUE(base::PathExists(test_dir_));
327}
328
329// Check dir with contents is cleared.
330TEST_F(ClearStateDirTest, Works) {
331 EXPECT_CALL(dev_install_, PromptUser(_, _)).WillOnce(Return(true));
332 const base::FilePath subdir = test_dir_.Append("subdir");
333 ASSERT_TRUE(base::CreateDirectory(subdir));
334 ASSERT_TRUE(dev_install_.ClearStateDir(test_dir_));
335 ASSERT_FALSE(base::PathExists(subdir));
336}
337
Mike Frysinger3d44f782019-02-25 23:17:08 -0500338namespace {
339
340class InitializeStateDirTest : public ::testing::Test {
341 public:
342 void SetUp() {
343 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
344 test_dir_ = scoped_temp_dir_.GetPath();
345 }
346
347 protected:
348 DevInstall dev_install_;
349 base::FilePath test_dir_;
350 base::ScopedTempDir scoped_temp_dir_;
351};
352
353} // namespace
354
355// Check stateful is set up correctly.
356TEST_F(InitializeStateDirTest, Works) {
357 // Make sure we fully set things up.
358 ASSERT_TRUE(dev_install_.InitializeStateDir(test_dir_));
359 ASSERT_TRUE(base::IsLink(test_dir_.Append("usr")));
360 ASSERT_TRUE(base::IsLink(test_dir_.Append("local")));
361 ASSERT_TRUE(base::IsLink(test_dir_.Append("local")));
362 const base::FilePath etc = test_dir_.Append("etc");
363 ASSERT_TRUE(base::PathExists(etc));
364 ASSERT_TRUE(base::IsLink(etc.Append("passwd")));
365 ASSERT_TRUE(base::IsLink(etc.Append("group")));
Mike Frysinger6fc79c02019-11-04 16:35:11 -0500366 const base::FilePath tmp = test_dir_.Append("tmp");
367 ASSERT_TRUE(base::PathExists(tmp));
368 // Can't use base::GetPosixFilePermissions as that blocks +t mode.
369 struct stat st;
370 ASSERT_EQ(0, stat(tmp.value().c_str(), &st));
371 ASSERT_EQ(01777, st.st_mode & 07777);
Mike Frysinger3d44f782019-02-25 23:17:08 -0500372
373 // Calling a second time should be fine.
374 ASSERT_TRUE(dev_install_.InitializeStateDir(test_dir_));
375}
376
377// Check we handle errors gracefully.
378TEST_F(InitializeStateDirTest, Fails) {
379 // Create a broken /etc symlink.
380 ASSERT_TRUE(
381 base::CreateSymbolicLink(base::FilePath("foo"), test_dir_.Append("etc")));
382 ASSERT_FALSE(dev_install_.InitializeStateDir(test_dir_));
383}
384
Mike Frysingerb4aadcd2019-02-25 23:50:05 -0500385namespace {
386
387class LoadRuntimeSettingsTest : public ::testing::Test {
388 public:
389 void SetUp() {
390 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
391 test_dir_ = scoped_temp_dir_.GetPath();
392 }
393
394 protected:
395 DevInstall dev_install_;
396 base::FilePath test_dir_;
397 base::ScopedTempDir scoped_temp_dir_;
398};
399
400} // namespace
401
402// Check loading state works.
403TEST_F(LoadRuntimeSettingsTest, Works) {
404 const base::FilePath lsb_release = test_dir_.Append("lsb-release");
405 std::string data{
406 "CHROMEOS_DEVSERVER=https://foo\n"
407 "CHROMEOS_RELEASE_BOARD=betty\n"
408 "CHROMEOS_RELEASE_CHROME_MILESTONE=79\n"
409 "CHROMEOS_RELEASE_VERSION=100.10.1\n"};
410 ASSERT_EQ(base::WriteFile(lsb_release, data.c_str(), data.size()),
411 data.size());
412 ASSERT_TRUE(dev_install_.LoadRuntimeSettings(lsb_release));
413 ASSERT_EQ(dev_install_.GetDevserverUrlForTest(), "https://foo");
414 ASSERT_EQ(dev_install_.GetBoardForTest(), "betty");
415 ASSERT_EQ(dev_install_.GetBinhostVersionForTest(), "100.10.1");
416}
417
418// Check loading empty state works.
419TEST_F(LoadRuntimeSettingsTest, Empty) {
420 const base::FilePath lsb_release = test_dir_.Append("lsb-release");
421 std::string data{""};
422 ASSERT_EQ(base::WriteFile(lsb_release, data.c_str(), data.size()),
423 data.size());
424 ASSERT_TRUE(dev_install_.LoadRuntimeSettings(lsb_release));
425}
426
427// Check loading state doesn't abort with missing file.
428TEST_F(LoadRuntimeSettingsTest, Missing) {
429 ASSERT_TRUE(dev_install_.LoadRuntimeSettings(test_dir_.Append("asdf")));
430}
431
Mike Frysingerbf36e3c2019-11-02 02:47:50 -0400432namespace {
433
434class BootstrapPackagesMock : public DevInstall {
435 public:
436 MOCK_METHOD(bool,
437 DownloadAndInstallBootstrapPackage,
438 (const std::string&),
439 (override));
440};
441
442class BootstrapPackagesTest : public ::testing::Test {
443 public:
444 void SetUp() {
445 // Have the install step pass by default.
446 ON_CALL(dev_install_, DownloadAndInstallBootstrapPackage(_))
447 .WillByDefault(Return(true));
448
449 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
450 test_dir_ = scoped_temp_dir_.GetPath();
451 dev_install_.SetStateDirForTest(test_dir_);
452 }
453
454 protected:
455 BootstrapPackagesMock dev_install_;
456 base::FilePath test_dir_;
457 base::ScopedTempDir scoped_temp_dir_;
458};
459
460} // namespace
461
462// Check bootstrap works in general.
463TEST_F(BootstrapPackagesTest, Works) {
464 const base::FilePath listing = test_dir_.Append("bootstrap.packages");
465 std::string data{
466 "foo/bar-123\n"
467 "cat/pkg-1.0\n"};
468 ASSERT_EQ(base::WriteFile(listing, data.c_str(), data.size()), data.size());
469
470 ON_CALL(dev_install_, DownloadAndInstallBootstrapPackage(_))
471 .WillByDefault(Return(false));
472 EXPECT_CALL(dev_install_, DownloadAndInstallBootstrapPackage("foo/bar-123"))
473 .WillOnce(Return(true));
474 EXPECT_CALL(dev_install_, DownloadAndInstallBootstrapPackage("cat/pkg-1.0"))
475 .WillOnce(Return(true));
476
477 const base::FilePath bindir = test_dir_.Append("usr/bin");
478 ASSERT_TRUE(base::CreateDirectory(bindir));
479 ASSERT_TRUE(dev_install_.DownloadAndInstallBootstrapPackages(listing));
480
481 // We assert the symlinks exist. We assume the targets are valid for now.
482 base::FilePath target;
483 ASSERT_TRUE(base::ReadSymbolicLink(bindir.Append("python"), &target));
484 ASSERT_TRUE(base::ReadSymbolicLink(bindir.Append("python2"), &target));
485 ASSERT_TRUE(base::ReadSymbolicLink(bindir.Append("python3"), &target));
486}
487
488// Check missing bootstrap list fails.
489TEST_F(BootstrapPackagesTest, Missing) {
490 const base::FilePath listing = test_dir_.Append("bootstrap.packages");
491 ASSERT_FALSE(dev_install_.DownloadAndInstallBootstrapPackages(listing));
492}
493
494// Check empty bootstrap list fails.
495TEST_F(BootstrapPackagesTest, Empty) {
496 const base::FilePath listing = test_dir_.Append("bootstrap.packages");
497 ASSERT_EQ(base::WriteFile(listing, "", 0), 0);
498 ASSERT_FALSE(dev_install_.DownloadAndInstallBootstrapPackages(listing));
499}
500
501// Check mid-bootstrap failure behavior.
502TEST_F(BootstrapPackagesTest, PackageFailed) {
503 const base::FilePath listing = test_dir_.Append("bootstrap.packages");
504 std::string data{"cat/pkg-3"};
505 ASSERT_EQ(base::WriteFile(listing, data.c_str(), data.size()), data.size());
506
507 EXPECT_CALL(dev_install_, DownloadAndInstallBootstrapPackage("cat/pkg-3"))
508 .WillOnce(Return(false));
509
510 const base::FilePath bindir = test_dir_.Append("usr/bin");
511 ASSERT_TRUE(base::CreateDirectory(bindir));
512 ASSERT_FALSE(dev_install_.DownloadAndInstallBootstrapPackages(listing));
513}
514
Mike Frysinger6fc79c02019-11-04 16:35:11 -0500515namespace {
516
517class ConfigurePortageTest : public ::testing::Test {
518 public:
519 void SetUp() {
520 ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
521 test_dir_ = scoped_temp_dir_.GetPath();
522 dev_install_.SetStateDirForTest(test_dir_);
523 }
524
525 protected:
526 BootstrapPackagesMock dev_install_;
527 base::FilePath test_dir_;
528 base::ScopedTempDir scoped_temp_dir_;
529};
530
531} // namespace
532
533// Check setup works in general.
534TEST_F(ConfigurePortageTest, Works) {
535 EXPECT_TRUE(dev_install_.ConfigurePortage());
536 const base::FilePath portage_dir = test_dir_.Append("etc/portage");
537 EXPECT_TRUE(base::PathExists(portage_dir));
538}
539
Mike Frysinger1dad0972019-02-23 18:36:37 -0500540} // namespace dev_install