blob: ee8880bfab3acb293789900437b259dc3523c7ed [file] [log] [blame]
// Copyright 2017 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#if defined(_WIN32)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#endif
#include "src/main/cpp/rc_file.h"
#include <memory>
#include "src/main/cpp/bazel_startup_options.h"
#include "src/main/cpp/blaze_util.h"
#include "src/main/cpp/blaze_util_platform.h"
#include "src/main/cpp/option_processor-internal.h"
#include "src/main/cpp/option_processor.h"
#include "src/main/cpp/util/file.h"
#include "src/main/cpp/util/file_platform.h"
#include "src/main/cpp/util/path.h"
#include "src/main/cpp/util/path_platform.h"
#include "src/main/cpp/workspace_layout.h"
#include "googlemock/include/gmock/gmock.h"
#include "googletest/include/gtest/gtest.h"
namespace blaze {
using ::testing::ContainsRegex;
using ::testing::ElementsAre;
using ::testing::HasSubstr;
using ::testing::IsEmpty;
using ::testing::MatchesRegex;
using ::testing::Pointee;
#if defined(_WIN32) || defined(__CYGWIN__)
constexpr const char* kNullDevice = "NUL";
#else // Assume POSIX if not Windows.
constexpr const char* kNullDevice = "/dev/null";
#endif
// Matches an RcFile's canonical source paths list.
MATCHER_P(CanonicalSourcePathsAre, paths_matcher, "") {
return ExplainMatchResult(ElementsAre(paths_matcher),
arg.canonical_source_paths(), result_listener);
}
class RcFileTest : public ::testing::Test {
protected:
RcFileTest()
: workspace_(blaze_util::JoinPath(blaze::GetPathEnv("TEST_TMPDIR"),
"workspace")),
cwd_(blaze_util::JoinPath(blaze::GetPathEnv("TEST_TMPDIR"), "cwd")),
home_(blaze_util::JoinPath(blaze::GetPathEnv("TEST_TMPDIR"), "home")),
binary_dir_(
blaze_util::JoinPath(blaze::GetPathEnv("TEST_TMPDIR"), "bazeldir")),
binary_path_(blaze_util::JoinPath(binary_dir_, "bazel")),
workspace_layout_(new WorkspaceLayout()) {}
void SetUp() override {
ASSERT_TRUE(blaze_util::MakeDirectories(workspace_, 0755));
ASSERT_TRUE(blaze_util::MakeDirectories(cwd_, 0755));
ASSERT_TRUE(blaze_util::ChangeDirectory(cwd_));
ASSERT_TRUE(blaze_util::MakeDirectories(home_, 0755));
#if defined(_WIN32)
ASSERT_NE(::SetEnvironmentVariable("HOME", home_.c_str()), 0);
#else
ASSERT_EQ(setenv("HOME", home_.c_str(), 1), 0);
#endif
#if defined(_WIN32) || defined(__CYGWIN__)
// GetCwd returns a short path on Windows, so we store this expectation now
// to keep assertions sane in the tests.
std::string short_cwd;
std::string error;
ASSERT_TRUE(blaze_util::AsShortWindowsPath(cwd_, &short_cwd, &error))
<< error;
cwd_ = short_cwd;
#endif
ASSERT_TRUE(blaze_util::MakeDirectories(binary_dir_, 0755));
option_processor_.reset(new OptionProcessor(
workspace_layout_.get(),
std::unique_ptr<StartupOptions>(
new BazelStartupOptions(workspace_layout_.get())),
"bazel.bazelrc"));
}
void TearDown() override {
// TODO(bazel-team): The code below deletes all the files in the workspace
// and other rc-related directories, but it intentionally skips directories.
// As a consequence, there may be empty directories from test to test.
// Remove this once blaze_util::DeleteDirectories(path) exists.
std::vector<std::string> files;
blaze_util::GetAllFilesUnder(workspace_, &files);
for (const std::string& file : files) {
blaze_util::UnlinkPath(file);
}
blaze_util::GetAllFilesUnder(cwd_, &files);
for (const std::string& file : files) {
blaze_util::UnlinkPath(file);
}
blaze_util::GetAllFilesUnder(home_, &files);
for (const std::string& file : files) {
blaze_util::UnlinkPath(file);
}
blaze_util::GetAllFilesUnder(binary_dir_, &files);
for (const std::string& file : files) {
blaze_util::UnlinkPath(file);
}
}
bool SetUpSystemRcFile(const std::string& contents,
std::string* rcfile_path) const {
const std::string system_rc_path =
blaze_util::ConvertPath(blaze_util::JoinPath(cwd_, "bazel.bazelrc"));
if (blaze_util::WriteFile(contents, system_rc_path, 0755)) {
*rcfile_path = blaze_util::MakeCanonical(system_rc_path.c_str());
return true;
}
return false;
}
bool SetUpWorkspaceRcFile(const std::string& contents,
std::string* rcfile_path) const {
const std::string workspace_user_rc_path =
blaze_util::JoinPath(workspace_, ".bazelrc");
if (blaze_util::WriteFile(contents, workspace_user_rc_path, 0755)) {
*rcfile_path = blaze_util::MakeCanonical(workspace_user_rc_path.c_str());
return true;
}
return false;
}
bool SetUpHomeRcFile(const std::string& contents,
std::string* rcfile_path) const {
const std::string home_rc_path = blaze_util::JoinPath(home_, ".bazelrc");
if (blaze_util::WriteFile(contents, home_rc_path, 0755)) {
*rcfile_path = blaze_util::MakeCanonical(home_rc_path.c_str());
return true;
}
return false;
}
bool SetUpLegacyMasterRcFileInWorkspace(const std::string& contents,
std::string* rcfile_path) const {
const std::string tools_dir = blaze_util::JoinPath(workspace_, "tools");
const std::string workspace_rc_path =
blaze_util::JoinPath(tools_dir, "bazel.rc");
if (blaze_util::MakeDirectories(tools_dir, 0755) &&
blaze_util::WriteFile(contents, workspace_rc_path, 0755)) {
*rcfile_path = workspace_rc_path;
return true;
}
return false;
}
bool SetUpLegacyMasterRcFileAlongsideBinary(const std::string& contents,
std::string* rcfile_path) const {
const std::string binary_rc_path =
blaze_util::JoinPath(binary_dir_, "bazel.bazelrc");
if (blaze_util::WriteFile(contents, binary_rc_path, 0755)) {
*rcfile_path = binary_rc_path;
return true;
}
return false;
}
const std::string workspace_;
std::string cwd_;
const std::string home_;
const std::string binary_dir_;
const std::string binary_path_;
const std::unique_ptr<WorkspaceLayout> workspace_layout_;
const std::string old_system_bazelrc_path_;
std::unique_ptr<OptionProcessor> option_processor_;
};
using GetRcFileTest = RcFileTest;
TEST_F(GetRcFileTest, GetRcFilesLoadsAllDefaultBazelrcs) {
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("", &system_rc));
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("", &workspace_rc));
std::string home_rc;
ASSERT_TRUE(SetUpHomeRcFile("", &home_rc));
const CommandLine cmd_line = CommandLine(binary_path_, {}, "build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
// There should be 2 rc files: the system one and the workspace one. --bazelrc
// is not passed and therefore is not relevant.
EXPECT_THAT(parsed_rcs,
ElementsAre(Pointee(CanonicalSourcePathsAre(system_rc)),
Pointee(CanonicalSourcePathsAre(workspace_rc)),
Pointee(CanonicalSourcePathsAre(home_rc))));
}
TEST_F(GetRcFileTest, GetRcFilesRespectsNoSystemRc) {
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("", &system_rc));
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("", &workspace_rc));
std::string home_rc;
ASSERT_TRUE(SetUpHomeRcFile("", &home_rc));
const CommandLine cmd_line =
CommandLine(binary_path_, {"--nosystem_rc"}, "build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
EXPECT_THAT(parsed_rcs,
ElementsAre(Pointee(CanonicalSourcePathsAre(workspace_rc)),
Pointee(CanonicalSourcePathsAre(home_rc))));
}
TEST_F(GetRcFileTest, GetRcFilesRespectsNoWorkspaceRc) {
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("", &system_rc));
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("", &workspace_rc));
std::string home_rc;
ASSERT_TRUE(SetUpHomeRcFile("", &home_rc));
const CommandLine cmd_line =
CommandLine(binary_path_, {"--noworkspace_rc"}, "build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
EXPECT_THAT(parsed_rcs,
ElementsAre(Pointee(CanonicalSourcePathsAre(system_rc)),
Pointee(CanonicalSourcePathsAre(home_rc))));
}
TEST_F(GetRcFileTest,
GetRcFilesRespectsNoWorkspaceRcAndNoSystemAndNoHomeRcCombined) {
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("", &system_rc));
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("", &workspace_rc));
std::string home_rc;
ASSERT_TRUE(SetUpHomeRcFile("", &home_rc));
const CommandLine cmd_line = CommandLine(
binary_path_, {"--noworkspace_rc", "--nosystem_rc", "--nohome_rc"},
"build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
EXPECT_THAT(parsed_rcs, IsEmpty());
}
TEST_F(GetRcFileTest, GetRcFilesWarnsAboutIgnoredMasterRcFiles) {
std::string workspace_rc;
ASSERT_TRUE(SetUpLegacyMasterRcFileInWorkspace("", &workspace_rc));
std::string binary_rc;
ASSERT_TRUE(SetUpLegacyMasterRcFileAlongsideBinary("", &binary_rc));
const CommandLine cmd_line = CommandLine(binary_path_, {}, "build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
testing::internal::CaptureStderr();
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
// Expect that GetRcFiles outputs a warning about these files that are not
// read as expected.
EXPECT_THAT(output,
HasSubstr("The following rc files are no longer being read"));
EXPECT_THAT(output, HasSubstr(workspace_rc));
EXPECT_THAT(output, HasSubstr(binary_rc));
}
TEST_F(GetRcFileTest, GetRcFilesReadsCommandLineRc) {
const std::string cmdline_rc_path =
blaze_util::JoinPath(workspace_, "mybazelrc");
ASSERT_TRUE(
blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
ASSERT_TRUE(blaze_util::WriteFile("", cmdline_rc_path, 0755));
const CommandLine cmd_line = CommandLine(
binary_path_, {"--bazelrc=" + cmdline_rc_path},
"build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
// Because of the variety of path representations in windows, this
// equality test does not attempt to check the entire path.
ASSERT_EQ(1, parsed_rcs.size());
ASSERT_EQ(1, parsed_rcs[0]->canonical_source_paths().size());
EXPECT_THAT(parsed_rcs[0]->canonical_source_paths()[0],
HasSubstr("mybazelrc"));
}
TEST_F(GetRcFileTest, GetRcFilesAcceptsNullCommandLineRc) {
const CommandLine cmd_line =
CommandLine(binary_path_,
{"--nosystem_rc", "--noworkspace_rc", "--nohome_rc",
"--bazelrc=/dev/null"},
"build", {});
std::string error = "check that this string is not modified";
std::vector<std::unique_ptr<RcFile>> parsed_rcs;
const blaze_exit_code::ExitCode exit_code =
option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
&cmd_line, &parsed_rcs, &error);
// /dev/null is not an error
EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
EXPECT_EQ("check that this string is not modified", error);
// but it does technically count as a file
EXPECT_THAT(parsed_rcs,
ElementsAre(Pointee(CanonicalSourcePathsAre(kNullDevice))));
}
class ParseOptionsTest : public RcFileTest {
protected:
void ParseOptionsAndCheckOutput(
const std::vector<std::string>& args,
const blaze_exit_code::ExitCode expected_exit_code,
const std::string& expected_error_regex,
const std::string& expected_output_regex) {
std::string error;
testing::internal::CaptureStderr();
const blaze_exit_code::ExitCode exit_code =
option_processor_->ParseOptions(args, workspace_, cwd_, &error);
const std::string output = testing::internal::GetCapturedStderr();
ASSERT_EQ(expected_exit_code, exit_code) << error;
ASSERT_THAT(error, ContainsRegex(expected_error_regex));
ASSERT_THAT(output, ContainsRegex(expected_output_regex));
}
};
TEST_F(ParseOptionsTest, IgnoreAllRcFilesIgnoresAllMasterAndUserRcFiles) {
// Put fake options in different expected rc files, to check that none of them
// are read.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("startup --workspacefoo", &workspace_rc));
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("startup --systemfoo", &system_rc));
const std::string cmdline_rc_path =
blaze_util::JoinPath(workspace_, "mybazelrc");
ASSERT_TRUE(
blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
ASSERT_TRUE(blaze_util::WriteFile("startup --myfoo", cmdline_rc_path, 0755));
const std::vector<std::string> args = {binary_path_, "--ignore_all_rc_files",
"build"};
// Expect no error due to the incorrect options, as non of them should have
// been loaded.
std::string error;
EXPECT_EQ(blaze_exit_code::SUCCESS,
option_processor_->ParseOptions(args, workspace_, cwd_, &error));
ASSERT_EQ("", error);
// Check that the startup options' provenance message contains nothing
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_EQ(output, "");
}
TEST_F(ParseOptionsTest, LaterIgnoreAllRcFilesValueWins) {
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("startup --workspacefoo", &workspace_rc));
const std::vector<std::string> args = {binary_path_, "--ignore_all_rc_files",
"--noignore_all_rc_files", "build"};
std::string error;
EXPECT_EQ(blaze_exit_code::BAD_ARGV,
option_processor_->ParseOptions(args, workspace_, cwd_, &error));
ASSERT_EQ(
"Unknown startup option: '--workspacefoo'.\n For more info, run "
"'bazel help startup_options'.",
error);
// Check that the startup options' provenance message contains the provenance
// of the incorrect option.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(
output,
MatchesRegex("INFO: Reading 'startup' options from .*workspace.*bazelrc: "
"--workspacefoo\n"));
}
TEST_F(ParseOptionsTest, IgnoreAllRcFilesIgnoresCommandLineRcFileToo) {
// Put fake options in different expected rc files, to check that none of them
// are read.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("startup --workspacefoo", &workspace_rc));
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("startup --systemfoo", &system_rc));
const std::string cmdline_rc_path =
blaze_util::JoinPath(workspace_, "mybazelrc");
ASSERT_TRUE(
blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
ASSERT_TRUE(
blaze_util::WriteFile("startup --cmdlinefoo", cmdline_rc_path, 0755));
const std::vector<std::string> args = {binary_path_, "--ignore_all_rc_files",
"--bazelrc=" + cmdline_rc_path,
"build"};
// Expect no error due to the incorrect options, as non of them should have
// been loaded.
std::string error;
EXPECT_EQ(blaze_exit_code::SUCCESS,
option_processor_->ParseOptions(args, workspace_, cwd_, &error));
ASSERT_EQ("", error);
// Check that the startup options' provenance message contains nothing
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_EQ(output, "");
}
TEST_F(ParseOptionsTest, CommandLineBazelrcHasUnknownOption) {
const std::string cmdline_rc_path =
blaze_util::JoinPath(workspace_, "mybazelrc");
ASSERT_TRUE(
blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
ASSERT_TRUE(blaze_util::WriteFile("startup --foo", cmdline_rc_path, 0755));
const std::vector<std::string> args = {binary_path_,
"--bazelrc=" + cmdline_rc_path,
"build"};
const std::string expected_error =
"Unknown startup option: '--foo'.\n"
" For more info, run 'bazel help startup_options'.";
std::string error;
ASSERT_NE(blaze_exit_code::SUCCESS,
option_processor_->ParseOptions(args, workspace_, cwd_, &error))
<< error;
ASSERT_EQ(expected_error, error);
// Check that the startup options' provenance message contains the correct
// information for the incorrect flag, and does not print the command-line
// provided startup flags.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(output,
MatchesRegex(
"INFO: Reading 'startup' options from .*mybazelrc: --foo\n"));
}
TEST_F(ParseOptionsTest, BazelrcHasUnknownOption) {
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("startup --foo", &workspace_rc));
const std::vector<std::string> args = {binary_path_, "build"};
// Expect no error due to the incorrect --foo.
std::string error;
EXPECT_EQ(blaze_exit_code::BAD_ARGV,
option_processor_->ParseOptions(args, workspace_, cwd_, &error));
ASSERT_EQ(
"Unknown startup option: '--foo'.\n"
" For more info, run 'bazel help startup_options'.",
error);
// Check that the startup options' provenance message contains nothing for the
// master bazelrc.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(output, MatchesRegex("INFO: Reading 'startup' options from "
".*workspace.*bazelrc: --foo\n"));
}
TEST_F(ParseOptionsTest,
IncorrectWorkspaceBazelrcIgnoredWhenNoWorkspaceRcIsPresent) {
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("startup --foo", &workspace_rc));
const std::vector<std::string> args = {binary_path_, "--noworkspace_rc",
"build"};
// Expect no error due to the incorrect --foo.
std::string error;
EXPECT_EQ(blaze_exit_code::SUCCESS,
option_processor_->ParseOptions(args, workspace_, cwd_, &error));
ASSERT_EQ("", error);
// Check that the startup options' provenance message contains nothing for the
// master bazelrc.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_EQ(output, "");
}
TEST_F(ParseOptionsTest, PositiveOptionOverridesNegativeOption) {
std::string workspace_rc;
ASSERT_TRUE(
SetUpWorkspaceRcFile("startup --max_idle_secs=123", &workspace_rc));
const std::vector<std::string> args = {"bazel", "--noworkspace_rc",
"--workspace_rc", "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);
// Check that the startup options' provenance message contains the correct
// information for the master bazelrc.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(output,
MatchesRegex("INFO: Reading 'startup' options from "
".*workspace.*bazelrc: --max_idle_secs=123\n"));
}
TEST_F(ParseOptionsTest, MultipleStartupArgsInMasterBazelrcWorksCorrectly) {
// Add startup flags to the master bazelrc.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile(
"startup --max_idle_secs=42\nstartup --io_nice_level=6", &workspace_rc));
const std::vector<std::string> args = {binary_path_, "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
EXPECT_EQ(42, option_processor_->GetParsedStartupOptions()->max_idle_secs);
EXPECT_EQ(6, option_processor_->GetParsedStartupOptions()->io_nice_level);
// Check that the startup options get grouped together properly in the output
// message.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(
output,
MatchesRegex("INFO: Reading 'startup' options from .*workspace.*bazelrc: "
"--max_idle_secs=42 --io_nice_level=6\n"));
}
TEST_F(ParseOptionsTest, CommandLineBazelrcHasPriorityOverDefaultBazelrc) {
// Add startup flags to the workspace bazelrc.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile(
"startup --max_idle_secs=42\nstartup --io_nice_level=6", &workspace_rc));
// Override one of the master bazelrc's flags in the commandline rc.
const std::string cmdline_rc_path =
blaze_util::JoinPath(workspace_, "mybazelrc");
ASSERT_TRUE(
blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
ASSERT_TRUE(blaze_util::WriteFile("startup --max_idle_secs=123",
cmdline_rc_path, 0755));
const std::vector<std::string> args = {
"bazel", "--bazelrc=" + cmdline_rc_path, "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);
EXPECT_EQ(6, option_processor_->GetParsedStartupOptions()->io_nice_level);
// Check that the options are reported in the correct order in the provenance
// message.
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(
output,
MatchesRegex("INFO: Reading 'startup' options from .*workspace.*bazelrc: "
"--max_idle_secs=42 --io_nice_level=6\n"
"INFO: Reading 'startup' options from .*mybazelrc: "
"--max_idle_secs=123\n"));
}
class BlazercImportTest : public ParseOptionsTest {
protected:
void TestBazelRcImportsMaintainsFlagOrdering(const std::string& import_type) {
// Override one of the master bazelrc's flags in the custom bazelrc.
const std::string imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
ASSERT_TRUE(blaze_util::MakeDirectories(
blaze_util::Dirname(imported_rc_path), 0755));
ASSERT_TRUE(blaze_util::WriteFile(
"startup --max_idle_secs=123\n"
"startup --io_nice_level=4",
imported_rc_path, 0755));
// Add startup flags the imported bazelrc.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile(
"startup --max_idle_secs=42\n" +
import_type + " " + imported_rc_path + "\n"
"startup --io_nice_level=6",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);
EXPECT_EQ(6, option_processor_->GetParsedStartupOptions()->io_nice_level);
// Check that the options are reported in the correct order in the
// provenance message, the imported file between the two master flags
testing::internal::CaptureStderr();
option_processor_->PrintStartupOptionsProvenanceMessage();
const std::string output = testing::internal::GetCapturedStderr();
EXPECT_THAT(
output,
MatchesRegex(
"INFO: Reading 'startup' options from .*workspace.*bazelrc: "
"--max_idle_secs=42\n"
"INFO: Reading 'startup' options from .*myimportedbazelrc: "
"--max_idle_secs=123 --io_nice_level=4\n"
"INFO: Reading 'startup' options from .*workspace.*bazelrc: "
"--io_nice_level=6\n"));
}
void TestThatDoubleImportsCauseAWarning(const std::string& import_type) {
const std::string imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
ASSERT_TRUE(blaze_util::WriteFile("", imported_rc_path, 0755));
// Import the custom location twice.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile(
import_type + " " + imported_rc_path + "\n" +
import_type + " " + imported_rc_path + "\n",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*myimportedbazelrc is imported multiple "
"times from .*workspace.*bazelrc\n");
}
void TestThatDoubleImportWithWorkspaceRelativeSyntaxCauseAWarning(
const std::string& import_type) {
const std::string imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
ASSERT_TRUE(blaze_util::WriteFile("", imported_rc_path, 0755));
// Import the custom location twice.
std::string workspace_rc;
ASSERT_TRUE(
SetUpWorkspaceRcFile(
import_type + " " + imported_rc_path + "\n" +
import_type + " %workspace%/myimportedbazelrc\n",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*myimportedbazelrc is imported multiple "
"times from .*workspace.*bazelrc\n");
}
void TestThatDoubleImportWithExcessPathSyntaxCauseAWarning(
const std::string& import_type) {
const std::string imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
ASSERT_TRUE(blaze_util::WriteFile("", imported_rc_path, 0755));
// Import the custom location twice.
std::string workspace_rc;
ASSERT_TRUE(
SetUpWorkspaceRcFile(
import_type + " " + imported_rc_path + "\n" +
import_type + " %workspace%///.//myimportedbazelrc\n",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*myimportedbazelrc is imported multiple "
"times from .*workspace.*bazelrc\n");
}
void TestThatDeepDoubleImportCausesAWarning(const std::string& import_type) {
const std::string dual_imported_rc_path =
blaze_util::JoinPath(workspace_, "dual_imported.bazelrc");
ASSERT_TRUE(blaze_util::WriteFile("", dual_imported_rc_path, 0755));
const std::string intermediate_import_1 =
blaze_util::JoinPath(workspace_, "intermediate_import_1");
ASSERT_TRUE(blaze_util::WriteFile(
import_type + " " + dual_imported_rc_path,
intermediate_import_1, 0755));
const std::string intermediate_import_2 =
blaze_util::JoinPath(workspace_, "intermediate_import_2");
ASSERT_TRUE(blaze_util::WriteFile(
import_type + " " + dual_imported_rc_path,
intermediate_import_2, 0755));
// Import the custom location twice.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile(
import_type + " " + intermediate_import_1 + "\n" +
import_type + " " + intermediate_import_2 + "\n",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*dual_imported.bazelrc is imported "
"multiple times from .*workspace.*bazelrc\n");
}
void TestThatImportingAFileAndPassingItInCausesAWarning(
const std::string& import_type) {
const std::string imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
ASSERT_TRUE(blaze_util::WriteFile("", imported_rc_path, 0755));
// Import the custom location, and pass it in by flag.
std::string workspace_rc;
ASSERT_TRUE(
SetUpWorkspaceRcFile(
import_type + " " + imported_rc_path,
&workspace_rc));
const std::vector<std::string> args = {
"bazel", "--bazelrc=" + imported_rc_path, "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*myimportedbazelrc is read multiple "
"times, "
"it is a standard rc file location but must have been unnecessarily "
"imported earlier.\n");
}
};
TEST_F(BlazercImportTest, BazelRcImportFailsForMissingFile) {
const std::string missing_imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("import " + missing_imported_rc_path,
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::INTERNAL_ERROR,
"Unexpected error reading .blazerc file '.*myimportedbazelrc'", "");
}
TEST_F(BlazercImportTest, BazelRcTryImportDoesNotFailForMissingFile) {
const std::string missing_imported_rc_path =
blaze_util::JoinPath(workspace_, "tryimported.bazelrc");
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("try-import " + missing_imported_rc_path,
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
}
// rc_file does not differentiate between non-existent and unreadable files. We
// don't necessarily want try-import to ignore unreadable files, but this test
// exists to make sure we don't change the behavior by accident. Any change that
// makes existent but unreadable files a failure with try-import should inform
// users.
TEST_F(BlazercImportTest, BazelRcTryImportDoesNotFailForUnreadableFile) {
const std::string unreadable_rc_path =
blaze_util::JoinPath(workspace_, "tryimported.bazelrc");
ASSERT_TRUE(blaze_util::WriteFile("startup --max_idle_secs=123",
unreadable_rc_path, 222));
std::string workspace_rc;
ASSERT_TRUE(
SetUpWorkspaceRcFile("try-import " + unreadable_rc_path, &workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
}
#if defined(_WIN32)
TEST_F(BlazercImportTest,
BazelRcTryImportDoesNotFailForInvalidPosixPathOnWindows) {
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("try-import /mnt/shared/defaults.bazelrc",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(args, blaze_exit_code::SUCCESS, "", "");
}
#endif
TEST_F(BlazercImportTest, BazelRcImportsMaintainsFlagOrdering) {
TestBazelRcImportsMaintainsFlagOrdering("import");
}
TEST_F(BlazercImportTest, BazelRcTryImportsMaintainsFlagOrdering) {
TestBazelRcImportsMaintainsFlagOrdering("try-import");
}
TEST_F(BlazercImportTest, DoubleImportsCauseAWarning) {
TestThatDoubleImportsCauseAWarning("import");
}
TEST_F(BlazercImportTest, DoubleTryImportsCauseAWarning) {
TestThatDoubleImportsCauseAWarning("try-import");
}
TEST_F(BlazercImportTest,
DoubleImportWithWorkspaceRelativeSyntaxCauseAWarning) {
TestThatDoubleImportWithWorkspaceRelativeSyntaxCauseAWarning("import");
}
TEST_F(BlazercImportTest,
DoubleTryImportWithWorkspaceRelativeSyntaxCauseAWarning) {
TestThatDoubleImportWithWorkspaceRelativeSyntaxCauseAWarning("try-import");
}
TEST_F(BlazercImportTest, DoubleImportWithExcessPathSyntaxCauseAWarning) {
TestThatDoubleImportWithExcessPathSyntaxCauseAWarning("import");
}
TEST_F(BlazercImportTest, DoubleTryImportWithExcessPathSyntaxCauseAWarning) {
TestThatDoubleImportWithExcessPathSyntaxCauseAWarning("try-import");
}
// The following tests unix-path semantics.
#if !defined(_WIN32) && !defined(__CYGWIN__)
TEST_F(BlazercImportTest,
DoubleImportWithEnclosingDirectorySyntaxCauseAWarning) {
const std::string imported_rc_path =
blaze_util::JoinPath(workspace_, "myimportedbazelrc");
ASSERT_TRUE(blaze_util::WriteFile("", imported_rc_path, 0755));
ASSERT_TRUE(blaze_util::MakeDirectories(
blaze_util::JoinPath(workspace_, "extra"), 0755));
// Import the custom location twice.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile(
"import " + imported_rc_path + "\n"
"import %workspace%/extra/../myimportedbazelrc\n",
&workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*myimportedbazelrc is imported multiple "
"times from .*workspace.*bazelrc\n");
}
#endif // !defined(_WIN32) && !defined(__CYGWIN__)
TEST_F(BlazercImportTest, DeepDoubleImportCausesAWarning) {
TestThatDeepDoubleImportCausesAWarning("import");
}
TEST_F(BlazercImportTest, DeepDoubleTryImportCausesAWarning) {
TestThatDeepDoubleImportCausesAWarning("try-import");
}
TEST_F(BlazercImportTest, ImportingAFileAndPassingItInCausesAWarning) {
TestThatImportingAFileAndPassingItInCausesAWarning("import");
}
TEST_F(BlazercImportTest, TryImportingAFileAndPassingItInCausesAWarning) {
TestThatImportingAFileAndPassingItInCausesAWarning("try-import");
}
// TODO(b/112908763): Somehow, in the following tests, we end with a relative
// path written in the import line on Windows. Figure out what's going on and
// reinstate these tests
#if !defined(_WIN32) && !defined(__CYGWIN__)
TEST_F(ParseOptionsTest, ImportingAPreviouslyLoadedStandardRcCausesAWarning) {
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("", &system_rc));
// Import the system_rc extraneously.
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("import " + system_rc, &workspace_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*bazel.bazelrc is read multiple "
"times, most recently imported from .*workspace.*bazelrc\n");
}
TEST_F(ParseOptionsTest, ImportingStandardRcBeforeItIsLoadedCausesAWarning) {
std::string workspace_rc;
ASSERT_TRUE(SetUpWorkspaceRcFile("", &workspace_rc));
// Import the workspace_rc extraneously.
std::string system_rc;
ASSERT_TRUE(SetUpSystemRcFile("import " + workspace_rc, &system_rc));
const std::vector<std::string> args = {"bazel", "build"};
ParseOptionsAndCheckOutput(
args, blaze_exit_code::SUCCESS, "",
"WARNING: Duplicate rc file: .*workspace.*bazelrc is read multiple "
"times, it is a standard rc file location but must have been "
"unnecessarily imported earlier.\n");
}
#endif // !defined(_WIN32) && !defined(__CYGWIN__)
} // namespace blaze