1 //
2 // Copyright (C) 2015 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include <string>
18
19 #include <brillo/bind_lambda.h>
20 #include <dbus/mock_object_proxy.h>
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23
24 #include "tpm_manager/client/tpm_ownership_dbus_proxy.h"
25
26 using testing::_;
27 using testing::Invoke;
28 using testing::StrictMock;
29 using testing::WithArgs;
30
31 namespace tpm_manager {
32
33 class TpmOwnershipDBusProxyTest : public testing::Test {
34 public:
35 ~TpmOwnershipDBusProxyTest() override = default;
SetUp()36 void SetUp() override {
37 mock_object_proxy_ = new StrictMock<dbus::MockObjectProxy>(
38 nullptr, "", dbus::ObjectPath(""));
39 proxy_.set_object_proxy(mock_object_proxy_.get());
40 }
41
42 protected:
43 scoped_refptr<StrictMock<dbus::MockObjectProxy>> mock_object_proxy_;
44 TpmOwnershipDBusProxy proxy_;
45 };
46
TEST_F(TpmOwnershipDBusProxyTest,GetTpmStatus)47 TEST_F(TpmOwnershipDBusProxyTest, GetTpmStatus) {
48 auto fake_dbus_call = [](
49 dbus::MethodCall* method_call,
50 const dbus::MockObjectProxy::ResponseCallback& response_callback) {
51 // Verify request protobuf.
52 dbus::MessageReader reader(method_call);
53 GetTpmStatusRequest request;
54 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
55 // Create reply protobuf.
56 auto response = dbus::Response::CreateEmpty();
57 dbus::MessageWriter writer(response.get());
58 GetTpmStatusReply reply;
59 reply.set_status(STATUS_SUCCESS);
60 reply.set_enabled(true);
61 reply.set_owned(true);
62 reply.set_dictionary_attack_counter(3);
63 reply.set_dictionary_attack_threshold(4);
64 reply.set_dictionary_attack_lockout_in_effect(true);
65 reply.set_dictionary_attack_lockout_seconds_remaining(5);
66 writer.AppendProtoAsArrayOfBytes(reply);
67 response_callback.Run(response.release());
68 };
69 EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
70 .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
71
72 // Set expectations on the outputs.
73 int callback_count = 0;
74 auto callback = [&callback_count](const GetTpmStatusReply& reply) {
75 callback_count++;
76 EXPECT_EQ(STATUS_SUCCESS, reply.status());
77 EXPECT_TRUE(reply.enabled());
78 EXPECT_TRUE(reply.owned());
79 EXPECT_EQ(3, reply.dictionary_attack_counter());
80 EXPECT_EQ(4, reply.dictionary_attack_threshold());
81 EXPECT_TRUE(reply.dictionary_attack_lockout_in_effect());
82 EXPECT_EQ(5, reply.dictionary_attack_lockout_seconds_remaining());
83 };
84 GetTpmStatusRequest request;
85 proxy_.GetTpmStatus(request, base::Bind(callback));
86 EXPECT_EQ(1, callback_count);
87 }
88
TEST_F(TpmOwnershipDBusProxyTest,TakeOwnership)89 TEST_F(TpmOwnershipDBusProxyTest, TakeOwnership) {
90 auto fake_dbus_call = [](
91 dbus::MethodCall* method_call,
92 const dbus::MockObjectProxy::ResponseCallback& response_callback) {
93 // Verify request protobuf.
94 dbus::MessageReader reader(method_call);
95 TakeOwnershipRequest request;
96 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
97 // Create reply protobuf.
98 auto response = dbus::Response::CreateEmpty();
99 dbus::MessageWriter writer(response.get());
100 TakeOwnershipReply reply;
101 reply.set_status(STATUS_SUCCESS);
102 writer.AppendProtoAsArrayOfBytes(reply);
103 response_callback.Run(response.release());
104 };
105 EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
106 .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
107
108 // Set expectations on the outputs.
109 int callback_count = 0;
110 auto callback = [&callback_count](const TakeOwnershipReply& reply) {
111 callback_count++;
112 EXPECT_EQ(STATUS_SUCCESS, reply.status());
113 };
114 TakeOwnershipRequest request;
115 proxy_.TakeOwnership(request, base::Bind(callback));
116 EXPECT_EQ(1, callback_count);
117 }
118
TEST_F(TpmOwnershipDBusProxyTest,RemoveOwnerDependency)119 TEST_F(TpmOwnershipDBusProxyTest, RemoveOwnerDependency) {
120 const std::string owner_dependency("owner");
121 auto fake_dbus_call = [&owner_dependency](
122 dbus::MethodCall* method_call,
123 const dbus::MockObjectProxy::ResponseCallback& response_callback) {
124 // Verify request protobuf.
125 dbus::MessageReader reader(method_call);
126 RemoveOwnerDependencyRequest request;
127 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
128 EXPECT_TRUE(request.has_owner_dependency());
129 EXPECT_EQ(owner_dependency, request.owner_dependency());
130 // Create reply protobuf.
131 auto response = dbus::Response::CreateEmpty();
132 dbus::MessageWriter writer(response.get());
133 RemoveOwnerDependencyReply reply;
134 reply.set_status(STATUS_SUCCESS);
135 writer.AppendProtoAsArrayOfBytes(reply);
136 response_callback.Run(response.release());
137 };
138 EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
139 .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
140
141 // Set expectations on the outputs.
142 int callback_count = 0;
143 auto callback = [&callback_count](const RemoveOwnerDependencyReply& reply) {
144 callback_count++;
145 EXPECT_EQ(STATUS_SUCCESS, reply.status());
146 };
147 RemoveOwnerDependencyRequest request;
148 request.set_owner_dependency(owner_dependency);
149 proxy_.RemoveOwnerDependency(request, base::Bind(callback));
150 EXPECT_EQ(1, callback_count);
151 }
152
153 } // namespace tpm_manager
154