mock_report_queue_provider.cc 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/reporting/client/mock_report_queue_provider.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/task/sequenced_task_runner.h"
  10. #include "base/task/thread_pool.h"
  11. #include "base/test/gmock_callback_support.h"
  12. #include "base/threading/thread_task_runner_handle.h"
  13. #include "components/reporting/client/mock_report_queue.h"
  14. #include "components/reporting/client/report_queue.h"
  15. #include "components/reporting/client/report_queue_configuration.h"
  16. #include "components/reporting/client/report_queue_provider.h"
  17. #include "components/reporting/storage/test_storage_module.h"
  18. #include "testing/gmock/include/gmock/gmock.h"
  19. using ::base::test::RunOnceCallback;
  20. using ::testing::_;
  21. using ::testing::NiceMock;
  22. using ::testing::Return;
  23. namespace reporting {
  24. MockReportQueueProvider::MockReportQueueProvider()
  25. : ReportQueueProvider(base::BindRepeating(
  26. [](OnStorageModuleCreatedCallback storage_created_cb) {
  27. std::move(storage_created_cb)
  28. .Run(base::MakeRefCounted<test::TestStorageModule>());
  29. })),
  30. test_sequenced_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
  31. MockReportQueueProvider::~MockReportQueueProvider() = default;
  32. void MockReportQueueProvider::ExpectCreateNewQueueAndReturnNewMockQueue(
  33. size_t times) {
  34. CheckOnThread();
  35. EXPECT_CALL(*this, CreateNewQueueMock(_, _))
  36. .Times(times)
  37. .WillRepeatedly([](std::unique_ptr<ReportQueueConfiguration> config,
  38. CreateReportQueueCallback cb) {
  39. std::move(cb).Run(std::make_unique<MockReportQueue>());
  40. });
  41. }
  42. void MockReportQueueProvider::
  43. ExpectCreateNewSpeculativeQueueAndReturnNewMockQueue(size_t times) {
  44. CheckOnThread();
  45. // Mock internals so we do not unnecessarily create a new report queue.
  46. EXPECT_CALL(*this, CreateNewQueueMock(_, _))
  47. .Times(times)
  48. .WillRepeatedly(
  49. RunOnceCallback<1>(std::unique_ptr<ReportQueue>(nullptr)));
  50. EXPECT_CALL(*this, CreateNewSpeculativeQueueMock())
  51. .Times(times)
  52. .WillRepeatedly([]() {
  53. auto report_queue =
  54. std::unique_ptr<MockReportQueue, base::OnTaskRunnerDeleter>(
  55. new MockReportQueue(),
  56. base::OnTaskRunnerDeleter(
  57. base::ThreadPool::CreateSequencedTaskRunner({})));
  58. // Mock PrepareToAttachActualQueue so we do not attempt to replace
  59. // the mocked report queue
  60. EXPECT_CALL(*report_queue, PrepareToAttachActualQueue()).WillOnce([]() {
  61. return base::DoNothing();
  62. });
  63. return report_queue;
  64. });
  65. }
  66. void MockReportQueueProvider::OnInitCompleted() {
  67. // OnInitCompleted is called on a thread pool, so in order to make potential
  68. // EXPECT_CALLs happen sequentially, we assign Mock to the test's main thread
  69. // task runner.
  70. test_sequenced_task_runner_->PostTask(
  71. FROM_HERE, base::BindOnce(&MockReportQueueProvider::OnInitCompletedMock,
  72. base::Unretained(this)));
  73. }
  74. void MockReportQueueProvider::CreateNewQueue(
  75. std::unique_ptr<ReportQueueConfiguration> config,
  76. CreateReportQueueCallback cb) {
  77. // CreateNewQueue is called on a thread pool, so in order to make potential
  78. // EXPECT_CALLs happen sequentially, we assign Mock to the test's main thread
  79. // task runner.
  80. test_sequenced_task_runner_->PostTask(
  81. FROM_HERE,
  82. base::BindOnce(&MockReportQueueProvider::CreateNewQueueMock,
  83. base::Unretained(this), std::move(config), std::move(cb)));
  84. }
  85. StatusOr<std::unique_ptr<ReportQueue, base::OnTaskRunnerDeleter>>
  86. MockReportQueueProvider::CreateNewSpeculativeQueue() {
  87. CheckOnThread();
  88. return CreateNewSpeculativeQueueMock();
  89. }
  90. void MockReportQueueProvider::ConfigureReportQueue(
  91. std::unique_ptr<ReportQueueConfiguration> report_queue_config,
  92. ReportQueueConfiguredCallback completion_cb) {
  93. // ConfigureReportQueue is called on a thread pool, so in order to make
  94. // potential EXPECT_CALLs happen sequentially, we assign Mock to the test's
  95. // main thread task runner.
  96. test_sequenced_task_runner_->PostTask(
  97. FROM_HERE,
  98. base::BindOnce(&MockReportQueueProvider::ConfigureReportQueueMock,
  99. base::Unretained(this), std::move(report_queue_config),
  100. std::move(completion_cb)));
  101. }
  102. void MockReportQueueProvider::CheckOnThread() const {
  103. DCHECK_CALLED_ON_VALID_SEQUENCE(test_sequence_checker_);
  104. }
  105. } // namespace reporting