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
82
83
84
85
86
87
88
89
90
91
92
93
|
// Copyright 2020 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/ash/cert_provisioning/mock_cert_provisioning_worker.h"
#include "base/test/values_test_util.h"
using base::test::IsJson;
using testing::_;
using testing::Return;
using testing::ReturnRef;
namespace ash {
namespace cert_provisioning {
// ================ MockCertProvisioningWorkerFactory ==========================
MockCertProvisioningWorkerFactory::MockCertProvisioningWorkerFactory() =
default;
MockCertProvisioningWorkerFactory::~MockCertProvisioningWorkerFactory() =
default;
MockCertProvisioningWorker*
MockCertProvisioningWorkerFactory::ExpectCreateReturnMock(
CertScope cert_scope,
const CertProfile& cert_profile) {
auto mock_worker = std::make_unique<MockCertProvisioningWorker>();
MockCertProvisioningWorker* pointer = mock_worker.get();
EXPECT_CALL(*this, Create(_, cert_scope, _, _, cert_profile, _, _, _, _))
.Times(1)
.WillOnce(Return(testing::ByMove(std::move(mock_worker))));
return pointer;
}
MockCertProvisioningWorker*
MockCertProvisioningWorkerFactory::ExpectDeserializeReturnMock(
CertScope cert_scope,
const base::Value& saved_worker) {
auto mock_worker = std::make_unique<MockCertProvisioningWorker>();
MockCertProvisioningWorker* pointer = mock_worker.get();
EXPECT_CALL(*this,
Deserialize(cert_scope, _, _, IsJson(saved_worker), _, _, _, _))
.Times(1)
.WillOnce(Return(testing::ByMove(std::move(mock_worker))));
return pointer;
}
// ================ MockCertProvisioningWorker =================================
MockCertProvisioningWorker::MockCertProvisioningWorker() {
// Makes MockCertProvisioningWorker return empty key by default. Because the
// return type is a reference, the object must exist to be able to return a
// default value.
static const std::vector<uint8_t> default_public_key;
ON_CALL(*this, GetPublicKey).WillByDefault(ReturnRef(default_public_key));
}
MockCertProvisioningWorker::~MockCertProvisioningWorker() = default;
void MockCertProvisioningWorker::SetExpectations(
testing::Cardinality do_step_times,
bool is_waiting,
const std::string& process_id,
const CertProfile& cert_profile,
std::string failure_message) {
testing::Mock::VerifyAndClearExpectations(this);
process_id_ = process_id;
cert_profile_ = cert_profile;
failure_message_ = std::move(failure_message);
EXPECT_CALL(*this, DoStep).Times(do_step_times);
EXPECT_CALL(*this, IsWaiting).WillRepeatedly(Return(is_waiting));
EXPECT_CALL(*this, GetProcessId).WillRepeatedly(ReturnRef(process_id_));
EXPECT_CALL(*this, GetCertProfile).WillRepeatedly(ReturnRef(cert_profile_));
EXPECT_CALL(*this, GetFailureMessageWithPii)
.WillRepeatedly(Return(failure_message_));
}
void MockCertProvisioningWorker::ResetExpected() {
testing::InSequence seq;
EXPECT_CALL(*this, IsWorkerMarkedForReset).WillOnce(Return(false));
EXPECT_CALL(*this, MarkWorkerForReset);
EXPECT_CALL(*this, IsWorkerMarkedForReset).WillRepeatedly(Return(true));
}
} // namespace cert_provisioning
} // namespace ash
|
