1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81


headless / test / headless_browser_test_utils.h [blame]

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

#ifndef HEADLESS_TEST_HEADLESS_BROWSER_TEST_UTILS_H_
#define HEADLESS_TEST_HEADLESS_BROWSER_TEST_UTILS_H_

#include <string>
#include <string_view>

#include "base/values.h"
#include "net/base/net_errors.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"

namespace simple_devtools_protocol_client {
class SimpleDevToolsProtocolClient;
}

namespace headless {

class HeadlessWebContents;

// Send DevTools command and wait for response by running local
// message loop. This is typically used as a quick and dirty way
// to enable a domain.
base::Value::Dict SendCommandSync(
    simple_devtools_protocol_client::SimpleDevToolsProtocolClient&
        devtools_client,
    const std::string& command);
base::Value::Dict SendCommandSync(
    simple_devtools_protocol_client::SimpleDevToolsProtocolClient&
        devtools_client,
    const std::string& command,
    base::Value::Dict params);

// Synchronously evaluates a script and returns the result.
base::Value::Dict EvaluateScript(HeadlessWebContents* web_contents,
                                 const std::string& script);

// Synchronously waits for a tab to finish loading and optionally retrieves
// an error.
bool WaitForLoad(HeadlessWebContents* web_contents,
                 net::Error* error = nullptr);

// Synchronously waits for a tab to finish loading and to gain focus.
void WaitForLoadAndGainFocus(HeadlessWebContents* web_contents);

// Convenience function to create a single key/value Dict.
template <typename T>
base::Value::Dict Param(std::string_view key, T&& value) {
  base::Value::Dict param;
  param.Set(key, std::move(value));
  return param;
}

// Convenience functions to retrieve values from a base::Value::Dict and
// CHECK fail if the specified path is not found.
std::string DictString(const base::Value::Dict& dict, std::string_view path);
int DictInt(const base::Value::Dict& dict, std::string_view path);
bool DictBool(const base::Value::Dict& dict, std::string_view path);
bool DictHas(const base::Value::Dict& dict, std::string_view path);

// A custom GMock matcher which matches if a base::Value::Dict has
// a path |path| that is equal to |value|.
testing::Matcher<const base::Value::Dict&> DictHasPathValue(
    const std::string& path,
    base::Value expected_value);

template <typename T>
testing::Matcher<const base::Value::Dict&> DictHasValue(const std::string& path,
                                                        T expected_value) {
  return DictHasPathValue(path, base::Value(expected_value));
}

// A custom GMock matcher which matches if a base::Value::Dict has
// the key |key|.
testing::Matcher<const base::Value::Dict&> DictHasKey(const std::string& key);

}  // namespace headless

#endif  // HEADLESS_TEST_HEADLESS_BROWSER_TEST_UTILS_H_