// 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
