chrome/browser/policy/messaging_layer/util/test_request_payload.h - chromium/src - Git at Google

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

 // Test support library for request payloads.

 #ifndef CHROME_BROWSER_POLICY_MESSAGING_LAYER_UTIL_TEST_REQUEST_PAYLOAD_H_
 #define CHROME_BROWSER_POLICY_MESSAGING_LAYER_UTIL_TEST_REQUEST_PAYLOAD_H_

 #include <list>
 #include <ostream>
 #include <sstream>
 #include <string>
 #include <string_view>
 #include <type_traits>

 #include "base/containers/flat_map.h"
 #include "base/values.h"

 #include "testing/gmock/include/gmock/gmock.h"

 namespace reporting {

 using ::testing::AllOfArray;
 using ::testing::Matcher;
 using ::testing::MatchResultListener;

 // Matcher interface for each request validity matcher. A request validity
 // matcher is a matcher that verifies one aspect of the general validity of a
 // request JSON object.
 class RequestValidityMatcherInterface {
  public:
   using is_gtest_matcher = void;
   virtual ~RequestValidityMatcherInterface() = default;
   virtual bool MatchAndExplain(const base::Value::Dict& arg,
                                MatchResultListener* listener) const = 0;
   virtual void DescribeTo(std::ostream* os) const = 0;
   virtual void DescribeNegationTo(std::ostream* os) const = 0;
   // Name of this matcher.
   virtual std::string Name() const = 0;
 };

 // attachEncryptionSettings must be of bool type and true.
 class AttachEncryptionSettingsMatcher : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // attachEncryptionSettings must be absent.
 class NoAttachEncryptionSettingsMatcher
     : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // ConfigurationFileVersion must be of bool type and true.
 class ConfigurationFileVersionMatcher : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // ConfigurationFileVersion must be absent.
 class NoConfigurationFileVersionMatcher
     : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // source must be of string type.
 class SourceMatcher : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // source must be absent.
 class NoSourceMatcher : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // encryptedRecord must be a list. This matcher is recommended to be applies
 // before verifying the details of any record (e.g., via |RecordMatcher|) to
 // generate more readable error messages.
 class EncryptedRecordMatcher : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // requestId must be a hexadecimal number represented as a string.
 class RequestIdMatcher : public RequestValidityMatcherInterface {
  public:
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // Base class of all matchers that verify one aspect of a record.
 class RecordMatcher : public RequestValidityMatcherInterface {
  public:
   enum class Mode : char {
     // The default. Match the content of each record in a full request payload
     // in "encryptedRecord". The argument is a dict that represents a full
     // request payload. This is typically switched on if the test case is
     // verifying a full request payload.
     FullRequest = 'f',
     // Directly match the content of a single record assuming no
     // "encryptedRecord" key wrapping it. The argument is a dict that contains
     // the record. This is typically switched on if the test case is verifying a
     // single record.
     RecordOnly = 'r'
   };
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* listener) const final;
   // Match and explain the given record.
   virtual bool MatchAndExplainRecord(const base::Value::Dict& arg,
                                      MatchResultListener* listener) const = 0;
   // Change mode. See the doc of |Mode| above.
   RecordMatcher& SetMode(Mode mode);

   // A helper function that calls |SetMode| above and casts the type back to the
   // derived class.
   template <class DerivedRecordMatcher>
   static DerivedRecordMatcher& SetMode(DerivedRecordMatcher&& record_matcher,
                                        Mode mode) {
     static_assert(std::is_base_of<RecordMatcher, DerivedRecordMatcher>::value,
                   "record_matcher must be of type RecordMatcher.");
     return static_cast<DerivedRecordMatcher&>(record_matcher.SetMode(mode));
   }

  private:
   Mode mode_ = Mode::FullRequest;
 };

 // Verify the encryptedWrappedRecord field of each record.
 class EncryptedWrappedRecordRecordMatcher : public RecordMatcher {
  public:
   bool MatchAndExplainRecord(const base::Value::Dict& arg,
                              MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // Verify the absence of the encryptedWrappedRecord field of each record.
 class NoEncryptedWrappedRecordRecordMatcher : public RecordMatcher {
  public:
   bool MatchAndExplainRecord(const base::Value::Dict& arg,
                              MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // Verify the sequenceInformation field of each record.
 class SequenceInformationRecordMatcher : public RecordMatcher {
  public:
   bool MatchAndExplainRecord(const base::Value::Dict& arg,
                              MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // Verify the compressionInformation field of each record.
 class CompressionInformationMatcher : public RecordMatcher {
  public:
   bool MatchAndExplainRecord(const base::Value::Dict& arg,
                              MatchResultListener* listener) const override;
   void DescribeTo(std::ostream* os) const override;
   void DescribeNegationTo(std::ostream* os) const override;
   std::string Name() const override;
 };

 // Build a matcher that can be used to verify the general validity of a
 // request matcher while accommodating the variety of requirements (e.g.,
 // some verification must be loosen because the request is intentionally
 // malformed for a particular test case). To use this class, call
 // CreateDataUpload() or CreateEmpty() to create an instance. Adapt matchers by
 // calling AppendMatcher() or RemoveMatcher().
 //
 // For the document of what response payload should look like, search for
 // "{{{Note}}} ERP Request Payload Overview" in the codebase.
 template <class T = base::Value::Dict>
 class RequestValidityMatcherBuilder {
  public:
   // We can't support copy because after copying, matcher_list_t's iterators in
   // matcher_index_ would point to the elements in the wrong
   // RequestValidityMatcherBuilder instance.
   RequestValidityMatcherBuilder(const RequestValidityMatcherBuilder<T>&) =
       delete;
   RequestValidityMatcherBuilder<T>& operator=(
       const RequestValidityMatcherBuilder<T>&) = delete;
   RequestValidityMatcherBuilder(RequestValidityMatcherBuilder<T>&&) = default;
   RequestValidityMatcherBuilder<T>& operator=(
       RequestValidityMatcherBuilder<T>&&) = default;

   // These creator functions are helpful because they are common starting point
   // of a combination of matchers and are friendly to be adapted slightly for
   // some test cases.

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains no matchers.
   static RequestValidityMatcherBuilder<T> CreateEmpty() {
     return RequestValidityMatcherBuilder<T>();
   }

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains a matcher that is suited for verifying a data upload request.
   static RequestValidityMatcherBuilder<T> CreateDataUpload() {
     // We need to call std::move here because AppendMatcher returns an lvalue
     // reference. It's important to move the object here because the iterators
     // in matcher_index_ would lose validity otherwise. (If a std::list object
     // is moved, its existing iterators remain valid and point to the elements
     // in this new object. But if it is copied and the old object is destroyed,
     // the existing iterators become invalid.)
     return std::move(RequestValidityMatcherBuilder<T>::CreateEmpty()
                          .AppendMatcher(RequestIdMatcher())
                          .AppendMatcher(EncryptedRecordMatcher())
                          .AppendMatcher(EncryptedWrappedRecordRecordMatcher())
                          .AppendMatcher(SequenceInformationRecordMatcher()));
   }

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains a matcher that is suited for verifying an encryption key-request
   // upload request. If need_key is false, the matcher will ensure the request
   // does not request an encryption key.
   static RequestValidityMatcherBuilder<T> CreateEncryptionKeyRequestUpload(
       bool need_key) {
     auto builder = RequestValidityMatcherBuilder<T>::CreateEmpty();
     builder.AppendMatcher(RequestIdMatcher());
     if (need_key) {
       builder.AppendMatcher(AttachEncryptionSettingsMatcher());
     } else {
       builder.AppendMatcher(NoAttachEncryptionSettingsMatcher());
     }
     return builder;
   }

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains a matcher that is suited for verifying a configuration file
   // request. If request_config_file is false the matcher will ensure the
   // request does not request the configuration file.
   static RequestValidityMatcherBuilder<T> CreateConfigurationFileRequestUpload(
       bool request_config_file) {
     auto builder = RequestValidityMatcherBuilder<T>::CreateEmpty();
     builder.AppendMatcher(RequestIdMatcher());
     if (request_config_file) {
       builder.AppendMatcher(ConfigurationFileVersionMatcher());
     } else {
       builder.AppendMatcher(NoConfigurationFileVersionMatcher());
     }
     return builder;
   }

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains a matcher that is suited for verifying a client automated test
   // request. If client_automated_test is false the matcher will ensure the
   // request does not include the field source.
   static RequestValidityMatcherBuilder<T> CreateSourceRequestUpload(
       bool client_automated_test) {
     auto builder = RequestValidityMatcherBuilder<T>::CreateEmpty();
     builder.AppendMatcher(RequestIdMatcher());
     if (client_automated_test) {
       builder.AppendMatcher(SourceMatcher());
     } else {
       builder.AppendMatcher(NoSourceMatcher());
     }
     return builder;
   }

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains a matcher that is suited for verifying a single record.
   static RequestValidityMatcherBuilder<T> CreateRecord() {
     return std::move(RequestValidityMatcherBuilder<T>::CreateEmpty()
                          .AppendMatcher(RecordMatcher::SetMode(
                              EncryptedWrappedRecordRecordMatcher(),
                              RecordMatcher::Mode::RecordOnly))
                          .AppendMatcher(RecordMatcher::SetMode(
                              SequenceInformationRecordMatcher(),
                              RecordMatcher::Mode::RecordOnly)));
   }

   // Creates and returns a |RequestValidityMatcherBuilder| instance that
   // contains a matcher that is suited for verifying a gap upload request.
   static RequestValidityMatcherBuilder<T> CreateGapUpload() {
     // A gap upload is a data upload with no encryptedWrappedRecord.
     return std::move(
         RequestValidityMatcherBuilder<T>::CreateDataUpload()
             .RemoveMatcher("encrypted-wrapped-record-record-matcher")
             .AppendMatcher(NoEncryptedWrappedRecordRecordMatcher()));
   }

   // Builds and returns the |Matcher<T>| object.
   [[nodiscard]] Matcher<T> Build() const { return AllOfArray(matchers_); }

   // Append a matcher.
   template <class RequestValidityMatcher>
   RequestValidityMatcherBuilder<T>& AppendMatcher(
       const RequestValidityMatcher& matcher) {
     static_assert(std::is_base_of<RequestValidityMatcherInterface,
                                   RequestValidityMatcher>::value,
                   "matcher must be of type RequestValidityMatcherInterface.");
     matchers_.emplace_back(matcher);
     matcher_index_.emplace(matcher.Name(), std::prev(matchers_.cend()));
     return *this;
   }

   // Remove a matcher.
   RequestValidityMatcherBuilder<T>& RemoveMatcher(std::string_view name) {
     auto matcher_it = matcher_index_.find(name);
     EXPECT_NE(matcher_it, matcher_index_.end())
         << "Matcher \"" << name << "\" not found.";
     matchers_.erase(matcher_it->second);
     matcher_index_.erase(matcher_it);
     return *this;
   }

  private:
   // List of matchers.
   using matcher_list_t = std::list<Matcher<T>>;
   matcher_list_t matchers_{};
   // A name to matcher mapping.
   base::flat_map<std::string, typename matcher_list_t::const_iterator>
       matcher_index_{};

   RequestValidityMatcherBuilder() = default;
 };

 class RequestContainingRecordMatcher {
  public:
   using is_gtest_matcher = void;

   explicit RequestContainingRecordMatcher(std::string_view matched_record_json);
   bool MatchAndExplain(const base::Value::Dict& arg,
                        MatchResultListener* os) const;
   void DescribeTo(std::ostream* os) const;
   void DescribeNegationTo(std::ostream* os) const;

  private:
   const std::string matched_record_json_;

   // Determine if |sub| is a sub-dictionary of |super|. That means, whether
   // |super| contains all keys of |sub| and the values corresponding to each of
   // |sub|'s keys equal. This method does not call itself recursively on values
   // that are dictionaries.
   static bool IsSubDict(const base::Value::Dict& sub,
                         const base::Value::Dict& super);
 };

 // The following matcher functions templated because we expect the tested
 // request comes in different forms, including their referenceness (gtest need
 // the matcher type to also match references to some extent). As long as the
 // type can be cast to a |base::Value::Dict| object, this matcher should work.

 // Match a data upload request that is valid. This matcher is intended to be
 // called for most tested data upload requests to verify whether the request is
 // valid on some basic fronts, such as containing an "encryptedRecord" key, etc.
 //
 // To enable or skip some part of the validity checks (e.g., because your test
 // case intentionally creates a malformed request), instead of using this
 // wrapper, you must call
 //
 //     RequestValidityMatcherBuilder<>::CreateDataUpload()
 //            .AppendMatcher(...)
 //            .RemoveMatcher(...)
 //            ...
 //            .Build()
 template <class T = base::Value::Dict>
 Matcher<T> IsDataUploadRequestValid() {
   return RequestValidityMatcherBuilder<T>::CreateDataUpload().Build();
 }

 // Match an encryption key-request upload request that is valid. If need_key is
 // false, this matcher will ensure the request does not request an encryption
 // key.
 template <class T = base::Value::Dict>
 Matcher<T> IsEncryptionKeyRequestUploadRequestValid(bool need_key = true) {
   return RequestValidityMatcherBuilder<T>::CreateEncryptionKeyRequestUpload(
              need_key)
       .Build();
 }

 // Match a configuration file request upload request that is valid. If
 // request_config_file is false, this matcher will ensure the request does not
 // request a configuration file.
 template <class T = base::Value::Dict>
 Matcher<T> IsConfigurationFileRequestUploadRequestValid(
     bool request_config_file = false) {
   return RequestValidityMatcherBuilder<T>::CreateConfigurationFileRequestUpload(
              request_config_file)
       .Build();
 }

 // Match a source upload request that is valid.
 template <class T = base::Value::Dict>
 Matcher<T> IsSourceRequestUploadRequestValid(
     bool client_automated_test = false) {
   return RequestValidityMatcherBuilder<T>::CreateSourceRequestUpload(
              client_automated_test)
       .Build();
 }

 // Match a gap upload request that is valid.
 template <class T = base::Value::Dict>
 Matcher<T> IsGapUploadRequestValid() {
   return RequestValidityMatcherBuilder<T>::CreateGapUpload().Build();
 }

 // Match a single record within a payload that is valid.
 template <class T = base::Value::Dict>
 Matcher<T> IsRecordValid() {
   return RequestValidityMatcherBuilder<T>::CreateRecord().Build();
 }

 // Match a request that contains the given record |matched_record_json|. The
 // match will be successful as long as any record in the request contains
 // |matched_record_json| as a sub-dictionary -- they are not required to equal.
 // In this way, you can specify only part of the record of interest (e.g., omit
 // "encryptedWrappedRecord").
 template <class T = base::Value::Dict>
 Matcher<T> DoesRequestContainRecord(std::string_view matched_record_json) {
   return RequestContainingRecordMatcher(matched_record_json);
 }

 }  // namespace reporting

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

	// Test support library for request payloads.

	#ifndef CHROME_BROWSER_POLICY_MESSAGING_LAYER_UTIL_TEST_REQUEST_PAYLOAD_H_
	#define CHROME_BROWSER_POLICY_MESSAGING_LAYER_UTIL_TEST_REQUEST_PAYLOAD_H_

	#include <list>
	#include <ostream>
	#include <sstream>
	#include <string>
	#include <string_view>
	#include <type_traits>

	#include "base/containers/flat_map.h"
	#include "base/values.h"

	#include "testing/gmock/include/gmock/gmock.h"

	namespace reporting {

	using ::testing::AllOfArray;
	using ::testing::Matcher;
	using ::testing::MatchResultListener;

	// Matcher interface for each request validity matcher. A request validity
	// matcher is a matcher that verifies one aspect of the general validity of a
	// request JSON object.
	class RequestValidityMatcherInterface {
	public:
	using is_gtest_matcher = void;
	virtual ~RequestValidityMatcherInterface() = default;
	virtual bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const = 0;
	virtual void DescribeTo(std::ostream* os) const = 0;
	virtual void DescribeNegationTo(std::ostream* os) const = 0;
	// Name of this matcher.
	virtual std::string Name() const = 0;
	};

	// attachEncryptionSettings must be of bool type and true.
	class AttachEncryptionSettingsMatcher : public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// attachEncryptionSettings must be absent.
	class NoAttachEncryptionSettingsMatcher
	: public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// ConfigurationFileVersion must be of bool type and true.
	class ConfigurationFileVersionMatcher : public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// ConfigurationFileVersion must be absent.
	class NoConfigurationFileVersionMatcher
	: public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// source must be of string type.
	class SourceMatcher : public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// source must be absent.
	class NoSourceMatcher : public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// encryptedRecord must be a list. This matcher is recommended to be applies
	// before verifying the details of any record (e.g., via \|RecordMatcher\|) to
	// generate more readable error messages.
	class EncryptedRecordMatcher : public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// requestId must be a hexadecimal number represented as a string.
	class RequestIdMatcher : public RequestValidityMatcherInterface {
	public:
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// Base class of all matchers that verify one aspect of a record.
	class RecordMatcher : public RequestValidityMatcherInterface {
	public:
	enum class Mode : char {
	// The default. Match the content of each record in a full request payload
	// in "encryptedRecord". The argument is a dict that represents a full
	// request payload. This is typically switched on if the test case is
	// verifying a full request payload.
	FullRequest = 'f',
	// Directly match the content of a single record assuming no
	// "encryptedRecord" key wrapping it. The argument is a dict that contains
	// the record. This is typically switched on if the test case is verifying a
	// single record.
	RecordOnly = 'r'
	};
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* listener) const final;
	// Match and explain the given record.
	virtual bool MatchAndExplainRecord(const base::Value::Dict& arg,
	MatchResultListener* listener) const = 0;
	// Change mode. See the doc of \|Mode\| above.
	RecordMatcher& SetMode(Mode mode);

	// A helper function that calls \|SetMode\| above and casts the type back to the
	// derived class.
	template <class DerivedRecordMatcher>
	static DerivedRecordMatcher& SetMode(DerivedRecordMatcher&& record_matcher,
	Mode mode) {
	static_assert(std::is_base_of<RecordMatcher, DerivedRecordMatcher>::value,
	"record_matcher must be of type RecordMatcher.");
	return static_cast<DerivedRecordMatcher&>(record_matcher.SetMode(mode));
	}

	private:
	Mode mode_ = Mode::FullRequest;
	};

	// Verify the encryptedWrappedRecord field of each record.
	class EncryptedWrappedRecordRecordMatcher : public RecordMatcher {
	public:
	bool MatchAndExplainRecord(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// Verify the absence of the encryptedWrappedRecord field of each record.
	class NoEncryptedWrappedRecordRecordMatcher : public RecordMatcher {
	public:
	bool MatchAndExplainRecord(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// Verify the sequenceInformation field of each record.
	class SequenceInformationRecordMatcher : public RecordMatcher {
	public:
	bool MatchAndExplainRecord(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// Verify the compressionInformation field of each record.
	class CompressionInformationMatcher : public RecordMatcher {
	public:
	bool MatchAndExplainRecord(const base::Value::Dict& arg,
	MatchResultListener* listener) const override;
	void DescribeTo(std::ostream* os) const override;
	void DescribeNegationTo(std::ostream* os) const override;
	std::string Name() const override;
	};

	// Build a matcher that can be used to verify the general validity of a
	// request matcher while accommodating the variety of requirements (e.g.,
	// some verification must be loosen because the request is intentionally
	// malformed for a particular test case). To use this class, call
	// CreateDataUpload() or CreateEmpty() to create an instance. Adapt matchers by
	// calling AppendMatcher() or RemoveMatcher().
	//
	// For the document of what response payload should look like, search for
	// "{{{Note}}} ERP Request Payload Overview" in the codebase.
	template <class T = base::Value::Dict>
	class RequestValidityMatcherBuilder {
	public:
	// We can't support copy because after copying, matcher_list_t's iterators in
	// matcher_index_ would point to the elements in the wrong
	// RequestValidityMatcherBuilder instance.
	RequestValidityMatcherBuilder(const RequestValidityMatcherBuilder<T>&) =
	delete;
	RequestValidityMatcherBuilder<T>& operator=(
	const RequestValidityMatcherBuilder<T>&) = delete;
	RequestValidityMatcherBuilder(RequestValidityMatcherBuilder<T>&&) = default;
	RequestValidityMatcherBuilder<T>& operator=(
	RequestValidityMatcherBuilder<T>&&) = default;

	// These creator functions are helpful because they are common starting point
	// of a combination of matchers and are friendly to be adapted slightly for
	// some test cases.

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains no matchers.
	static RequestValidityMatcherBuilder<T> CreateEmpty() {
	return RequestValidityMatcherBuilder<T>();
	}

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains a matcher that is suited for verifying a data upload request.
	static RequestValidityMatcherBuilder<T> CreateDataUpload() {
	// We need to call std::move here because AppendMatcher returns an lvalue
	// reference. It's important to move the object here because the iterators
	// in matcher_index_ would lose validity otherwise. (If a std::list object
	// is moved, its existing iterators remain valid and point to the elements
	// in this new object. But if it is copied and the old object is destroyed,
	// the existing iterators become invalid.)
	return std::move(RequestValidityMatcherBuilder<T>::CreateEmpty()
	.AppendMatcher(RequestIdMatcher())
	.AppendMatcher(EncryptedRecordMatcher())
	.AppendMatcher(EncryptedWrappedRecordRecordMatcher())
	.AppendMatcher(SequenceInformationRecordMatcher()));
	}

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains a matcher that is suited for verifying an encryption key-request
	// upload request. If need_key is false, the matcher will ensure the request
	// does not request an encryption key.
	static RequestValidityMatcherBuilder<T> CreateEncryptionKeyRequestUpload(
	bool need_key) {
	auto builder = RequestValidityMatcherBuilder<T>::CreateEmpty();
	builder.AppendMatcher(RequestIdMatcher());
	if (need_key) {
	builder.AppendMatcher(AttachEncryptionSettingsMatcher());
	} else {
	builder.AppendMatcher(NoAttachEncryptionSettingsMatcher());
	}
	return builder;
	}

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains a matcher that is suited for verifying a configuration file
	// request. If request_config_file is false the matcher will ensure the
	// request does not request the configuration file.
	static RequestValidityMatcherBuilder<T> CreateConfigurationFileRequestUpload(
	bool request_config_file) {
	auto builder = RequestValidityMatcherBuilder<T>::CreateEmpty();
	builder.AppendMatcher(RequestIdMatcher());
	if (request_config_file) {
	builder.AppendMatcher(ConfigurationFileVersionMatcher());
	} else {
	builder.AppendMatcher(NoConfigurationFileVersionMatcher());
	}
	return builder;
	}

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains a matcher that is suited for verifying a client automated test
	// request. If client_automated_test is false the matcher will ensure the
	// request does not include the field source.
	static RequestValidityMatcherBuilder<T> CreateSourceRequestUpload(
	bool client_automated_test) {
	auto builder = RequestValidityMatcherBuilder<T>::CreateEmpty();
	builder.AppendMatcher(RequestIdMatcher());
	if (client_automated_test) {
	builder.AppendMatcher(SourceMatcher());
	} else {
	builder.AppendMatcher(NoSourceMatcher());
	}
	return builder;
	}

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains a matcher that is suited for verifying a single record.
	static RequestValidityMatcherBuilder<T> CreateRecord() {
	return std::move(RequestValidityMatcherBuilder<T>::CreateEmpty()
	.AppendMatcher(RecordMatcher::SetMode(
	EncryptedWrappedRecordRecordMatcher(),
	RecordMatcher::Mode::RecordOnly))
	.AppendMatcher(RecordMatcher::SetMode(
	SequenceInformationRecordMatcher(),
	RecordMatcher::Mode::RecordOnly)));
	}

	// Creates and returns a \|RequestValidityMatcherBuilder\| instance that
	// contains a matcher that is suited for verifying a gap upload request.
	static RequestValidityMatcherBuilder<T> CreateGapUpload() {
	// A gap upload is a data upload with no encryptedWrappedRecord.
	return std::move(
	RequestValidityMatcherBuilder<T>::CreateDataUpload()
	.RemoveMatcher("encrypted-wrapped-record-record-matcher")
	.AppendMatcher(NoEncryptedWrappedRecordRecordMatcher()));
	}

	// Builds and returns the \|Matcher<T>\| object.
	[[nodiscard]] Matcher<T> Build() const { return AllOfArray(matchers_); }

	// Append a matcher.
	template <class RequestValidityMatcher>
	RequestValidityMatcherBuilder<T>& AppendMatcher(
	const RequestValidityMatcher& matcher) {
	static_assert(std::is_base_of<RequestValidityMatcherInterface,
	RequestValidityMatcher>::value,
	"matcher must be of type RequestValidityMatcherInterface.");
	matchers_.emplace_back(matcher);
	matcher_index_.emplace(matcher.Name(), std::prev(matchers_.cend()));
	return *this;
	}

	// Remove a matcher.
	RequestValidityMatcherBuilder<T>& RemoveMatcher(std::string_view name) {
	auto matcher_it = matcher_index_.find(name);
	EXPECT_NE(matcher_it, matcher_index_.end())
	<< "Matcher \"" << name << "\" not found.";
	matchers_.erase(matcher_it->second);
	matcher_index_.erase(matcher_it);
	return *this;
	}

	private:
	// List of matchers.
	using matcher_list_t = std::list<Matcher<T>>;
	matcher_list_t matchers_{};
	// A name to matcher mapping.
	base::flat_map<std::string, typename matcher_list_t::const_iterator>
	matcher_index_{};

	RequestValidityMatcherBuilder() = default;
	};

	class RequestContainingRecordMatcher {
	public:
	using is_gtest_matcher = void;

	explicit RequestContainingRecordMatcher(std::string_view matched_record_json);
	bool MatchAndExplain(const base::Value::Dict& arg,
	MatchResultListener* os) const;
	void DescribeTo(std::ostream* os) const;
	void DescribeNegationTo(std::ostream* os) const;

	private:
	const std::string matched_record_json_;

	// Determine if \|sub\| is a sub-dictionary of \|super\|. That means, whether
	// \|super\| contains all keys of \|sub\| and the values corresponding to each of
	// \|sub\|'s keys equal. This method does not call itself recursively on values
	// that are dictionaries.
	static bool IsSubDict(const base::Value::Dict& sub,
	const base::Value::Dict& super);
	};

	// The following matcher functions templated because we expect the tested
	// request comes in different forms, including their referenceness (gtest need
	// the matcher type to also match references to some extent). As long as the
	// type can be cast to a \|base::Value::Dict\| object, this matcher should work.

	// Match a data upload request that is valid. This matcher is intended to be
	// called for most tested data upload requests to verify whether the request is
	// valid on some basic fronts, such as containing an "encryptedRecord" key, etc.
	//
	// To enable or skip some part of the validity checks (e.g., because your test
	// case intentionally creates a malformed request), instead of using this
	// wrapper, you must call
	//
	// RequestValidityMatcherBuilder<>::CreateDataUpload()
	// .AppendMatcher(...)
	// .RemoveMatcher(...)
	// ...
	// .Build()
	template <class T = base::Value::Dict>
	Matcher<T> IsDataUploadRequestValid() {
	return RequestValidityMatcherBuilder<T>::CreateDataUpload().Build();
	}

	// Match an encryption key-request upload request that is valid. If need_key is
	// false, this matcher will ensure the request does not request an encryption
	// key.
	template <class T = base::Value::Dict>
	Matcher<T> IsEncryptionKeyRequestUploadRequestValid(bool need_key = true) {
	return RequestValidityMatcherBuilder<T>::CreateEncryptionKeyRequestUpload(
	need_key)
	.Build();
	}

	// Match a configuration file request upload request that is valid. If
	// request_config_file is false, this matcher will ensure the request does not
	// request a configuration file.
	template <class T = base::Value::Dict>
	Matcher<T> IsConfigurationFileRequestUploadRequestValid(
	bool request_config_file = false) {
	return RequestValidityMatcherBuilder<T>::CreateConfigurationFileRequestUpload(
	request_config_file)
	.Build();
	}

	// Match a source upload request that is valid.
	template <class T = base::Value::Dict>
	Matcher<T> IsSourceRequestUploadRequestValid(
	bool client_automated_test = false) {
	return RequestValidityMatcherBuilder<T>::CreateSourceRequestUpload(
	client_automated_test)
	.Build();
	}

	// Match a gap upload request that is valid.
	template <class T = base::Value::Dict>
	Matcher<T> IsGapUploadRequestValid() {
	return RequestValidityMatcherBuilder<T>::CreateGapUpload().Build();
	}

	// Match a single record within a payload that is valid.
	template <class T = base::Value::Dict>
	Matcher<T> IsRecordValid() {
	return RequestValidityMatcherBuilder<T>::CreateRecord().Build();
	}

	// Match a request that contains the given record \|matched_record_json\|. The
	// match will be successful as long as any record in the request contains
	// \|matched_record_json\| as a sub-dictionary -- they are not required to equal.
	// In this way, you can specify only part of the record of interest (e.g., omit
	// "encryptedWrappedRecord").
	template <class T = base::Value::Dict>
	Matcher<T> DoesRequestContainRecord(std::string_view matched_record_json) {
	return RequestContainingRecordMatcher(matched_record_json);
	}

	} // namespace reporting

	#endif // CHROME_BROWSER_POLICY_MESSAGING_LAYER_UTIL_TEST_REQUEST_PAYLOAD_H_