chrome/browser/net/log_net_log_browsertest.cc - chromium/src.git - Git at Google

 // Copyright 2018 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <string>
 #include <string_view>

 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/test/browser_test.h"
 #include "services/network/public/cpp/network_switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace chrome_browser_net {
 namespace {

 // Test fixture for running tests with --log-net-log with no explicit file
 // specified.
 class LogNetLogTest : public InProcessBrowserTest {
  public:
   LogNetLogTest() = default;

   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(network::switches::kLogNetLog);
   }

   void TearDownInProcessBrowserTestFixture() override { VerifyNetLog(); }

  private:
   // Verify that the netlog file was written to the user data dir.
   void VerifyNetLog() {
     base::FilePath user_data_dir;
     ASSERT_TRUE(base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
     auto net_log_path = user_data_dir.AppendASCII("netlog.json");

     // Read the netlog from disk.
     std::string file_contents;
     ASSERT_TRUE(base::ReadFileToString(net_log_path, &file_contents))
         << "Could not read: " << net_log_path;

     // Parse it as JSON.
     auto parsed = base::JSONReader::Read(file_contents);
     EXPECT_TRUE(parsed);

     // Detailed checking is done by LogNetLogExplicitFileTest, so this test just
     // accepts any valid JSON.
   }
 };

 IN_PROC_BROWSER_TEST_F(LogNetLogTest, Exists) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL url(embedded_test_server()->GetURL("/simple.html"));
   EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url));
 }

 // Test fixture for running tests with --log-net-log, and a parameterized value
 // for --net-log-capture-mode.
 //
 // Asserts that a netlog file was created, appears valid, and stripped cookies
 // in accordance to the --net-log-capture-mode flag.
 class LogNetLogExplicitFileTest
     : public InProcessBrowserTest,
       public testing::WithParamInterface<const char*> {
  public:
   LogNetLogExplicitFileTest() = default;

   void SetUpCommandLine(base::CommandLine* command_line) override {
     ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
     net_log_path_ = tmp_dir_.GetPath().AppendASCII("netlog.json");

     command_line->AppendSwitchPath(network::switches::kLogNetLog,
                                    net_log_path_);

     if (GetParam()) {
       command_line->AppendSwitchASCII(network::switches::kNetLogCaptureMode,
                                       GetParam());
     }
   }

   void TearDownInProcessBrowserTestFixture() override { VerifyNetLog(); }

  private:
   // Verify that the netlog file was written, appears to be well formed, and
   // includes the requested level of data.
   void VerifyNetLog() {
     // Read the netlog from disk.
     std::string file_contents;
     ASSERT_TRUE(base::ReadFileToString(net_log_path_, &file_contents))
         << "Could not read: " << net_log_path_;

     // Parse it as JSON.
     auto parsed = base::JSONReader::Read(file_contents);
     ASSERT_TRUE(parsed);

     // Ensure the root value is a dictionary.
     ASSERT_TRUE(parsed->is_dict());
     const base::Value::Dict& main = parsed->GetDict();

     // Ensure it has a "constants" property.
     const base::Value::Dict* constants = main.FindDict("constants");
     ASSERT_TRUE(constants);
     ASSERT_FALSE(constants->empty());

     // Ensure it has an "events" property.
     const base::Value::List* events = main.FindList("events");
     ASSERT_TRUE(events);
     ASSERT_FALSE(events->empty());

     // Verify that cookies were stripped when the --net-log-capture-mode flag
     // was omitted, and not stripped when it was given a value of
     // IncludeSensitive
     bool include_cookies =
         GetParam() && std::string_view(GetParam()) == "IncludeSensitive";

     if (include_cookies) {
       EXPECT_TRUE(file_contents.find("Set-Cookie: name=Good;Max-Age=3600") !=
                   std::string::npos);
     } else {
       EXPECT_TRUE(file_contents.find("Set-Cookie: [22 bytes were stripped]") !=
                   std::string::npos);
     }
   }

   base::FilePath net_log_path_;
   base::ScopedTempDir tmp_dir_;
 };

 INSTANTIATE_TEST_SUITE_P(All,
                          LogNetLogExplicitFileTest,
                          ::testing::Values(nullptr, "IncludeSensitive"));

 IN_PROC_BROWSER_TEST_P(LogNetLogExplicitFileTest, Basic) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL url(embedded_test_server()->GetURL("/set_cookie_header.html"));
   ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url));
 }

 // Test fixture for NetLog with invalid duration values.
 //
 // Tests handling of invalid values for the --net-log-duration flag.
 // This ensures that when invalid duration values are provided,browser continues
 // to function properly by:
 // 1. Successfully creating a NetLog file
 // 2. Continuing to log network activity throughout the browser session
 // 3. Generating a properly formatted JSON log file
 //
 // The test operates by setting various invalid duration values, performing
 // network operations, and verifying the NetLog continues to function rather
 // than failing or stopping prematurely.
 class LogNetLogInvalidDurationTest
     : public InProcessBrowserTest,
       public testing::WithParamInterface<const char*> {
  public:
   LogNetLogInvalidDurationTest() = default;

   void SetUpCommandLine(base::CommandLine* command_line) override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     net_log_path_ =
         temp_dir_.GetPath().Append(FILE_PATH_LITERAL("netlog.json"));

     // Add the NetLog path
     command_line->AppendSwitchPath(network::switches::kLogNetLog,
                                    net_log_path_);
     command_line->AppendSwitchASCII(network::switches::kLogNetLogDuration,
                                     GetParam());
     command_line->AppendSwitchASCII(network::switches::kNetLogCaptureMode,
                                     "Default");
   }

   void TearDownInProcessBrowserTestFixture() override {
     // Verify the log file exists and is valid
     std::string file_contents;
     ASSERT_TRUE(base::ReadFileToString(net_log_path_, &file_contents))
         << "Could not read: " << net_log_path_;

     // Parse it as JSON
     std::optional<base::Value> log_value =
         base::JSONReader::Read(file_contents);
     ASSERT_TRUE(log_value.has_value());
     EXPECT_TRUE(log_value->is_dict());
   }

  private:
   base::ScopedTempDir temp_dir_;
   base::FilePath net_log_path_;
 };

 // Test cases: empty string, non-integer value, zero value, negative value
 INSTANTIATE_TEST_SUITE_P(InvalidDurations,
                          LogNetLogInvalidDurationTest,
                          ::testing::Values("", "abc", "0", "-5"));

 IN_PROC_BROWSER_TEST_P(LogNetLogInvalidDurationTest, InvalidDurationHandling) {
   ASSERT_TRUE(embedded_test_server()->Start());

   // Generate some network activity
   GURL url(embedded_test_server()->GetURL("/simple.html"));
   EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url));

   // Generate more traffic to verify NetLog is still active
   url = embedded_test_server()->GetURL("/title1.html");
   EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url));

   // NetLog should continue until browser shutdown
   // Verification of log file happens in TearDownInProcessBrowserTestFixture
 }

 // Test fixture for NetLog with a valid duration value.
 //
 // Tests the --net-log-duration flag with a valid positive integer value.
 // This ensures that when a valid duration is provided, the NetLog system:
 // 1. Properly starts capturing network events
 // 2. Automatically stops capturing after the specified duration (1 second)
 // 3. Generates a valid JSON file containing the captured events
 //
 // The test operates by:
 // - Setting up a 1-second NetLog duration
 // - Performing network operations to generate capturable events
 // - Waiting for the duration to complete
 // - Polling to verify a valid JSON file appears
 class LogNetLogValidDurationTest : public InProcessBrowserTest {
  public:
   LogNetLogValidDurationTest() = default;
   // Polling interval when waiting for the NetLog file to be written
   static constexpr base::TimeDelta kPollInterval = base::Milliseconds(10);
   // Maximum number of polling attempts (total wait time = kPollInterval *
   // kMaxPollAttempts)
   static constexpr int kMaxPollAttempts = 200;  // 2 seconds total

   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Create a temp directory for storing our netlog file.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     net_log_path_ =
         temp_dir_.GetPath().Append(FILE_PATH_LITERAL("netlog_valid.json"));

     // Specify a 1-second NetLog duration.
     command_line->AppendSwitchPath(network::switches::kLogNetLog,
                                    net_log_path_);
     command_line->AppendSwitchASCII(network::switches::kLogNetLogDuration, "1");
     command_line->AppendSwitchASCII(network::switches::kNetLogCaptureMode,
                                     "Default");
   }

   bool LogFileExistsAndIsValidJson() {
     // Allow blocking file I/O in this test method:
     base::ScopedAllowBlockingForTesting allow_blocking;

     if (!base::PathExists(net_log_path_)) {
       return false;
     }

     std::string file_contents;
     if (!base::ReadFileToString(net_log_path_, &file_contents)) {
       return false;
     }

     std::optional<base::Value> parsed_json =
         base::JSONReader::Read(file_contents);
     if (!parsed_json.has_value() || !parsed_json->is_dict()) {
       return false;
     }
     return true;
   }
   void RunLoopFor(base::TimeDelta duration) {
     base::RunLoop run_loop;
     base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), duration);
     run_loop.Run();
   }

  private:
   base::ScopedTempDir temp_dir_;
   base::FilePath net_log_path_;
 };

 // This test confirms that the NetLog stops after 1 second and a valid JSON file
 // eventually appears on disk.
 IN_PROC_BROWSER_TEST_F(LogNetLogValidDurationTest, SucceedsWithOneSecond) {
   ASSERT_TRUE(embedded_test_server()->Start());

   // Wait ~1 second (the NetLog's duration).
   RunLoopFor(base::Seconds(1));

   // Now poll until the file is written and valid JSON, or we time out.
   bool success = false;
   for (int i = 0; i < kMaxPollAttempts; ++i) {
     if (LogFileExistsAndIsValidJson()) {
       success = true;
       break;
     }
     RunLoopFor(kPollInterval);
   }

   EXPECT_TRUE(success);
 }
 }  // namespace

 }  // namespace chrome_browser_net
	// Copyright 2018 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <string>
	#include <string_view>

	#include "base/files/file_util.h"
	#include "base/files/scoped_temp_dir.h"
	#include "base/json/json_reader.h"
	#include "base/path_service.h"
	#include "base/threading/scoped_blocking_call.h"
	#include "chrome/common/chrome_paths.h"
	#include "chrome/test/base/in_process_browser_test.h"
	#include "chrome/test/base/ui_test_utils.h"
	#include "content/public/test/browser_test.h"
	#include "services/network/public/cpp/network_switches.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace chrome_browser_net {
	namespace {

	// Test fixture for running tests with --log-net-log with no explicit file
	// specified.
	class LogNetLogTest : public InProcessBrowserTest {
	public:
	LogNetLogTest() = default;

	void SetUpCommandLine(base::CommandLine* command_line) override {
	command_line->AppendSwitch(network::switches::kLogNetLog);
	}

	void TearDownInProcessBrowserTestFixture() override { VerifyNetLog(); }

	private:
	// Verify that the netlog file was written to the user data dir.
	void VerifyNetLog() {
	base::FilePath user_data_dir;
	ASSERT_TRUE(base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
	auto net_log_path = user_data_dir.AppendASCII("netlog.json");

	// Read the netlog from disk.
	std::string file_contents;
	ASSERT_TRUE(base::ReadFileToString(net_log_path, &file_contents))
	<< "Could not read: " << net_log_path;

	// Parse it as JSON.
	auto parsed = base::JSONReader::Read(file_contents);
	EXPECT_TRUE(parsed);

	// Detailed checking is done by LogNetLogExplicitFileTest, so this test just
	// accepts any valid JSON.
	}
	};

	IN_PROC_BROWSER_TEST_F(LogNetLogTest, Exists) {
	ASSERT_TRUE(embedded_test_server()->Start());
	GURL url(embedded_test_server()->GetURL("/simple.html"));
	EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url));
	}

	// Test fixture for running tests with --log-net-log, and a parameterized value
	// for --net-log-capture-mode.
	//
	// Asserts that a netlog file was created, appears valid, and stripped cookies
	// in accordance to the --net-log-capture-mode flag.
	class LogNetLogExplicitFileTest
	: public InProcessBrowserTest,
	public testing::WithParamInterface<const char*> {
	public:
	LogNetLogExplicitFileTest() = default;

	void SetUpCommandLine(base::CommandLine* command_line) override {
	ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
	net_log_path_ = tmp_dir_.GetPath().AppendASCII("netlog.json");

	command_line->AppendSwitchPath(network::switches::kLogNetLog,
	net_log_path_);

	if (GetParam()) {
	command_line->AppendSwitchASCII(network::switches::kNetLogCaptureMode,
	GetParam());
	}
	}

	void TearDownInProcessBrowserTestFixture() override { VerifyNetLog(); }

	private:
	// Verify that the netlog file was written, appears to be well formed, and
	// includes the requested level of data.
	void VerifyNetLog() {
	// Read the netlog from disk.
	std::string file_contents;
	ASSERT_TRUE(base::ReadFileToString(net_log_path_, &file_contents))
	<< "Could not read: " << net_log_path_;

	// Parse it as JSON.
	auto parsed = base::JSONReader::Read(file_contents);
	ASSERT_TRUE(parsed);

	// Ensure the root value is a dictionary.
	ASSERT_TRUE(parsed->is_dict());
	const base::Value::Dict& main = parsed->GetDict();

	// Ensure it has a "constants" property.
	const base::Value::Dict* constants = main.FindDict("constants");
	ASSERT_TRUE(constants);
	ASSERT_FALSE(constants->empty());

	// Ensure it has an "events" property.
	const base::Value::List* events = main.FindList("events");
	ASSERT_TRUE(events);
	ASSERT_FALSE(events->empty());

	// Verify that cookies were stripped when the --net-log-capture-mode flag
	// was omitted, and not stripped when it was given a value of
	// IncludeSensitive
	bool include_cookies =
	GetParam() && std::string_view(GetParam()) == "IncludeSensitive";

	if (include_cookies) {
	EXPECT_TRUE(file_contents.find("Set-Cookie: name=Good;Max-Age=3600") !=
	std::string::npos);
	} else {
	EXPECT_TRUE(file_contents.find("Set-Cookie: [22 bytes were stripped]") !=
	std::string::npos);
	}
	}

	base::FilePath net_log_path_;
	base::ScopedTempDir tmp_dir_;
	};

	INSTANTIATE_TEST_SUITE_P(All,
	LogNetLogExplicitFileTest,
	::testing::Values(nullptr, "IncludeSensitive"));

	IN_PROC_BROWSER_TEST_P(LogNetLogExplicitFileTest, Basic) {
	ASSERT_TRUE(embedded_test_server()->Start());
	GURL url(embedded_test_server()->GetURL("/set_cookie_header.html"));
	ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url));
	}

	// Test fixture for NetLog with invalid duration values.
	//
	// Tests handling of invalid values for the --net-log-duration flag.
	// This ensures that when invalid duration values are provided,browser continues
	// to function properly by:
	// 1. Successfully creating a NetLog file
	// 2. Continuing to log network activity throughout the browser session
	// 3. Generating a properly formatted JSON log file
	//
	// The test operates by setting various invalid duration values, performing
	// network operations, and verifying the NetLog continues to function rather
	// than failing or stopping prematurely.
	class LogNetLogInvalidDurationTest
	: public InProcessBrowserTest,
	public testing::WithParamInterface<const char*> {
	public:
	LogNetLogInvalidDurationTest() = default;

	void SetUpCommandLine(base::CommandLine* command_line) override {
	ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
	net_log_path_ =
	temp_dir_.GetPath().Append(FILE_PATH_LITERAL("netlog.json"));

	// Add the NetLog path
	command_line->AppendSwitchPath(network::switches::kLogNetLog,
	net_log_path_);
	command_line->AppendSwitchASCII(network::switches::kLogNetLogDuration,
	GetParam());
	command_line->AppendSwitchASCII(network::switches::kNetLogCaptureMode,
	"Default");
	}

	void TearDownInProcessBrowserTestFixture() override {
	// Verify the log file exists and is valid
	std::string file_contents;
	ASSERT_TRUE(base::ReadFileToString(net_log_path_, &file_contents))
	<< "Could not read: " << net_log_path_;

	// Parse it as JSON
	std::optional<base::Value> log_value =
	base::JSONReader::Read(file_contents);
	ASSERT_TRUE(log_value.has_value());
	EXPECT_TRUE(log_value->is_dict());
	}

	private:
	base::ScopedTempDir temp_dir_;
	base::FilePath net_log_path_;
	};

	// Test cases: empty string, non-integer value, zero value, negative value
	INSTANTIATE_TEST_SUITE_P(InvalidDurations,
	LogNetLogInvalidDurationTest,
	::testing::Values("", "abc", "0", "-5"));

	IN_PROC_BROWSER_TEST_P(LogNetLogInvalidDurationTest, InvalidDurationHandling) {
	ASSERT_TRUE(embedded_test_server()->Start());

	// Generate some network activity
	GURL url(embedded_test_server()->GetURL("/simple.html"));
	EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url));

	// Generate more traffic to verify NetLog is still active
	url = embedded_test_server()->GetURL("/title1.html");
	EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url));

	// NetLog should continue until browser shutdown
	// Verification of log file happens in TearDownInProcessBrowserTestFixture
	}

	// Test fixture for NetLog with a valid duration value.
	//
	// Tests the --net-log-duration flag with a valid positive integer value.
	// This ensures that when a valid duration is provided, the NetLog system:
	// 1. Properly starts capturing network events
	// 2. Automatically stops capturing after the specified duration (1 second)
	// 3. Generates a valid JSON file containing the captured events
	//
	// The test operates by:
	// - Setting up a 1-second NetLog duration
	// - Performing network operations to generate capturable events
	// - Waiting for the duration to complete
	// - Polling to verify a valid JSON file appears
	class LogNetLogValidDurationTest : public InProcessBrowserTest {
	public:
	LogNetLogValidDurationTest() = default;
	// Polling interval when waiting for the NetLog file to be written
	static constexpr base::TimeDelta kPollInterval = base::Milliseconds(10);
	// Maximum number of polling attempts (total wait time = kPollInterval *
	// kMaxPollAttempts)
	static constexpr int kMaxPollAttempts = 200; // 2 seconds total

	void SetUpCommandLine(base::CommandLine* command_line) override {
	// Create a temp directory for storing our netlog file.
	ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
	net_log_path_ =
	temp_dir_.GetPath().Append(FILE_PATH_LITERAL("netlog_valid.json"));

	// Specify a 1-second NetLog duration.
	command_line->AppendSwitchPath(network::switches::kLogNetLog,
	net_log_path_);
	command_line->AppendSwitchASCII(network::switches::kLogNetLogDuration, "1");
	command_line->AppendSwitchASCII(network::switches::kNetLogCaptureMode,
	"Default");
	}

	bool LogFileExistsAndIsValidJson() {
	// Allow blocking file I/O in this test method:
	base::ScopedAllowBlockingForTesting allow_blocking;

	if (!base::PathExists(net_log_path_)) {
	return false;
	}

	std::string file_contents;
	if (!base::ReadFileToString(net_log_path_, &file_contents)) {
	return false;
	}

	std::optional<base::Value> parsed_json =
	base::JSONReader::Read(file_contents);
	if (!parsed_json.has_value() \|\| !parsed_json->is_dict()) {
	return false;
	}
	return true;
	}
	void RunLoopFor(base::TimeDelta duration) {
	base::RunLoop run_loop;
	base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
	FROM_HERE, run_loop.QuitClosure(), duration);
	run_loop.Run();
	}

	private:
	base::ScopedTempDir temp_dir_;
	base::FilePath net_log_path_;
	};

	// This test confirms that the NetLog stops after 1 second and a valid JSON file
	// eventually appears on disk.
	IN_PROC_BROWSER_TEST_F(LogNetLogValidDurationTest, SucceedsWithOneSecond) {
	ASSERT_TRUE(embedded_test_server()->Start());

	// Wait ~1 second (the NetLog's duration).
	RunLoopFor(base::Seconds(1));

	// Now poll until the file is written and valid JSON, or we time out.
	bool success = false;
	for (int i = 0; i < kMaxPollAttempts; ++i) {
	if (LogFileExistsAndIsValidJson()) {
	success = true;
	break;
	}
	RunLoopFor(kPollInterval);
	}

	EXPECT_TRUE(success);
	}
	} // namespace

	} // namespace chrome_browser_net