cache_replayer_unittest.cc | Explore in Territory

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

#include "chrome/browser/autofill/automated_tests/cache_replayer.h"

#include <memory>
#include <optional>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>

#include "base/base64.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/json/json_writer.h"
#include "base/strings/strcat.h"
#include "base/strings/string_util.h"
#include "base/values.h"
#include "build/build_config.h"
#include "components/autofill/core/browser/proto/api_v1.pb.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/zlib/google/compression_utils.h"

namespace autofill {
namespace test {
namespace {

// Only run these tests on Linux because there are issues with other platforms.
// Testing on one platform gives enough confidence.
#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)

JSONWriter;
Value;

// Request Response Pair for the API server
RequestResponsePair;

constexpr char kTestHTTPResponseHeader[] = …;
constexpr char kHTTPBodySep[] = …;
// The host name of the autofill server.
constexpr char kHostname[] = …;

struct LightField { … };

struct LightForm { … };

std::string CreateQueryUrl(const std::string& base64_encoded_query) { … }

bool GetServerResponseForQuery(const ServerCacheReplayer& cache_replayer,
                               const AutofillPageQueryRequest& query,
                               std::string* http_text) { … }

RequestResponsePair MakeQueryRequestResponsePair(
    const std::vector<LightForm>& forms) { … }

// Returns a query request URL. If |query| is not empty, the corresponding
// query is encoded into the URL.
bool MakeQueryRequestURL(std::optional<AutofillPageQueryRequest> query,
                         std::string* request_url) { … }

// Make HTTP request header given |url|.
inline std::string MakeRequestHeader(std::string_view url) { … }

// Makes string value for "SerializedRequest" json node that contains HTTP
// request content.
bool MakeSerializedRequest(const AutofillPageQueryRequest& query,
                           RequestType type,
                           std::string* serialized_request,
                           std::string* request_url) { … }

std::string MakeSerializedResponse(
    const AutofillQueryResponse& query_response) { … }

// Write json node to file in text format.
bool WriteJSONNode(const base::FilePath& file_path, const base::Value& node) { … }

// Write cache to file in json text format.
bool WriteJSON(const base::FilePath& file_path,
               const std::vector<RequestResponsePair>& request_response_pairs,
               RequestType request_type = RequestType::kQueryProtoPOST) { … }

// TODO(crbug.com/40768066): The test flakily times out.
TEST(AutofillCacheReplayerDeathTest,
     DISABLED_ServerCacheReplayerConstructor_CrashesWhenNoDomainNode) { … }

TEST(AutofillCacheReplayerDeathTest,
     ServerCacheReplayerConstructor_CrashesWhenNoQueryNodesAndFailOnEmpty) { … }

// Test suite for GET Query death test.
class AutofillCacheReplayerGETQueryDeathTest
    : public testing::TestWithParam<std::string> { … };

TEST_P(
    AutofillCacheReplayerGETQueryDeathTest,
    ApiServerCacheReplayerConstructor_CrashesWhenInvalidRequestURLForGETQuery) { … }

INSTANTIATE_TEST_SUITE_P(…);

TEST(AutofillCacheReplayerTest,
     CanUseReplayerWhenNoCacheContentWithNotFailOnEmpty) { … }

template <typename U, typename V>
bool ProtobufsEqual(const U& u, const V& v) { … }

// Test suite for Query response retrieval test.
class AutofillCacheReplayerGetResponseForQueryTest
    : public testing::TestWithParam<RequestType> { … };

TEST_P(AutofillCacheReplayerGetResponseForQueryTest,
       FillsResponseWhenNoErrors) { … }

INSTANTIATE_TEST_SUITE_P(…);
TEST(AutofillCacheReplayerTest, GetResponseForQueryGivesFalseWhenNullptr) { … }

TEST(AutofillCacheReplayerTest, GetResponseForQueryGivesFalseWhenNoKeyMatch) { … }

TEST(AutofillCacheReplayerTest,
     GetResponseForQueryGivesFalseWhenDecompressFailsBecauseInvalidHTTP) { … }

TEST(AutofillCacheReplayerTest,
     GetResponseForQueryGivesTrueWhenDecompressSucceededBecauseEmptyBody) { … }

// Returns whether the forms in |response| and |forms| match. If both contain
// the same number of forms, a boolean is appended to the output for each form
// indicating whether the expectation and actual form matched. In case of
// gross mismatch, the function may return an empty vector.
std::vector<bool> DoFormsMatch(const AutofillQueryResponse& response,
                               const std::vector<LightForm>& forms) { … }

std::vector<bool> CheckFormsInCache(const ServerCacheReplayer& cache_replayer,
                                    const std::vector<LightForm>& forms) { … }

TEST(AutofillCacheReplayerTest, CrossEnvironmentIntegrationTest) { … }
#endif  // if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
}  // namespace
}  // namespace test
}  // namespace autofill
chromium/chrome/browser/autofill/automated_tests/cache_replayer_unittest.cc
