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_nvram_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 TpmNvramDBusProxyTest : public testing::Test {
34  public:
35   ~TpmNvramDBusProxyTest() 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   TpmNvramDBusProxy proxy_;
45 };
46 
TEST_F(TpmNvramDBusProxyTest,DefineNvram)47 TEST_F(TpmNvramDBusProxyTest, DefineNvram) {
48   uint32_t nvram_index = 5;
49   size_t nvram_length = 32;
50   auto fake_dbus_call = [nvram_index, nvram_length](
51       dbus::MethodCall* method_call,
52       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
53     // Verify request protobuf.
54     dbus::MessageReader reader(method_call);
55     DefineNvramRequest request;
56     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
57     EXPECT_TRUE(request.has_index());
58     EXPECT_EQ(nvram_index, request.index());
59     EXPECT_TRUE(request.has_length());
60     EXPECT_EQ(nvram_length, request.length());
61     // Create reply protobuf.
62     auto response = dbus::Response::CreateEmpty();
63     dbus::MessageWriter writer(response.get());
64     DefineNvramReply reply;
65     reply.set_status(STATUS_SUCCESS);
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   // Set expectations on the outputs.
72   int callback_count = 0;
73   auto callback = [&callback_count](const DefineNvramReply& reply) {
74     callback_count++;
75     EXPECT_EQ(STATUS_SUCCESS, reply.status());
76   };
77   DefineNvramRequest request;
78   request.set_index(nvram_index);
79   request.set_length(nvram_length);
80   proxy_.DefineNvram(request, base::Bind(callback));
81   EXPECT_EQ(1, callback_count);
82 }
83 
TEST_F(TpmNvramDBusProxyTest,DestroyNvram)84 TEST_F(TpmNvramDBusProxyTest, DestroyNvram) {
85   uint32_t nvram_index = 5;
86   auto fake_dbus_call = [nvram_index](
87       dbus::MethodCall* method_call,
88       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
89     // Verify request protobuf.
90     dbus::MessageReader reader(method_call);
91     DestroyNvramRequest request;
92     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
93     EXPECT_TRUE(request.has_index());
94     EXPECT_EQ(nvram_index, request.index());
95     // Create reply protobuf.
96     auto response = dbus::Response::CreateEmpty();
97     dbus::MessageWriter writer(response.get());
98     DestroyNvramReply reply;
99     reply.set_status(STATUS_SUCCESS);
100     writer.AppendProtoAsArrayOfBytes(reply);
101     response_callback.Run(response.release());
102   };
103   EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
104       .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
105   // Set expectations on the outputs.
106   int callback_count = 0;
107   auto callback = [&callback_count](const DestroyNvramReply& reply) {
108     callback_count++;
109     EXPECT_EQ(STATUS_SUCCESS, reply.status());
110   };
111   DestroyNvramRequest request;
112   request.set_index(nvram_index);
113   proxy_.DestroyNvram(request, base::Bind(callback));
114   EXPECT_EQ(1, callback_count);
115 }
TEST_F(TpmNvramDBusProxyTest,WriteNvram)116 TEST_F(TpmNvramDBusProxyTest, WriteNvram) {
117   uint32_t nvram_index = 5;
118   std::string nvram_data("nvram_data");
119   auto fake_dbus_call = [nvram_index, nvram_data](
120       dbus::MethodCall* method_call,
121       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
122     // Verify request protobuf.
123     dbus::MessageReader reader(method_call);
124     WriteNvramRequest request;
125     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
126     EXPECT_TRUE(request.has_index());
127     EXPECT_EQ(nvram_index, request.index());
128     EXPECT_TRUE(request.has_data());
129     EXPECT_EQ(nvram_data, request.data());
130     // Create reply protobuf.
131     auto response = dbus::Response::CreateEmpty();
132     dbus::MessageWriter writer(response.get());
133     WriteNvramReply 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   // Set expectations on the outputs.
141   int callback_count = 0;
142   auto callback = [&callback_count](const WriteNvramReply& reply) {
143     callback_count++;
144     EXPECT_EQ(STATUS_SUCCESS, reply.status());
145   };
146   WriteNvramRequest request;
147   request.set_index(nvram_index);
148   request.set_data(nvram_data);
149   proxy_.WriteNvram(request, base::Bind(callback));
150   EXPECT_EQ(1, callback_count);
151 }
152 
TEST_F(TpmNvramDBusProxyTest,ReadNvram)153 TEST_F(TpmNvramDBusProxyTest, ReadNvram) {
154   uint32_t nvram_index = 5;
155   std::string nvram_data("nvram_data");
156   auto fake_dbus_call = [nvram_index, nvram_data](
157       dbus::MethodCall* method_call,
158       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
159     // Verify request protobuf.
160     dbus::MessageReader reader(method_call);
161     ReadNvramRequest request;
162     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
163     EXPECT_TRUE(request.has_index());
164     EXPECT_EQ(nvram_index, request.index());
165     // Create reply protobuf.
166     auto response = dbus::Response::CreateEmpty();
167     dbus::MessageWriter writer(response.get());
168     ReadNvramReply reply;
169     reply.set_status(STATUS_SUCCESS);
170     reply.set_data(nvram_data);
171     writer.AppendProtoAsArrayOfBytes(reply);
172     response_callback.Run(response.release());
173   };
174   EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
175       .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
176   // Set expectations on the outputs.
177   int callback_count = 0;
178   auto callback = [&callback_count, nvram_data](const ReadNvramReply& reply) {
179     callback_count++;
180     EXPECT_EQ(STATUS_SUCCESS, reply.status());
181     EXPECT_TRUE(reply.has_data());
182     EXPECT_EQ(nvram_data, reply.data());
183   };
184   ReadNvramRequest request;
185   request.set_index(nvram_index);
186   proxy_.ReadNvram(request, base::Bind(callback));
187   EXPECT_EQ(1, callback_count);
188 }
189 
TEST_F(TpmNvramDBusProxyTest,IsNvramDefined)190 TEST_F(TpmNvramDBusProxyTest, IsNvramDefined) {
191   uint32_t nvram_index = 5;
192   bool nvram_defined = true;
193   auto fake_dbus_call = [nvram_index, nvram_defined](
194       dbus::MethodCall* method_call,
195       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
196     // Verify request protobuf.
197     dbus::MessageReader reader(method_call);
198     IsNvramDefinedRequest request;
199     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
200     EXPECT_TRUE(request.has_index());
201     EXPECT_EQ(nvram_index, request.index());
202     // Create reply protobuf.
203     auto response = dbus::Response::CreateEmpty();
204     dbus::MessageWriter writer(response.get());
205     IsNvramDefinedReply reply;
206     reply.set_status(STATUS_SUCCESS);
207     reply.set_is_defined(nvram_defined);
208     writer.AppendProtoAsArrayOfBytes(reply);
209     response_callback.Run(response.release());
210   };
211   EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
212       .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
213   // Set expectations on the outputs.
214   int callback_count = 0;
215   auto callback = [&callback_count, nvram_defined](
216       const IsNvramDefinedReply& reply) {
217     callback_count++;
218     EXPECT_EQ(STATUS_SUCCESS, reply.status());
219     EXPECT_TRUE(reply.has_is_defined());
220     EXPECT_EQ(nvram_defined, reply.is_defined());
221   };
222   IsNvramDefinedRequest request;
223   request.set_index(nvram_index);
224   proxy_.IsNvramDefined(request, base::Bind(callback));
225   EXPECT_EQ(1, callback_count);
226 }
227 
TEST_F(TpmNvramDBusProxyTest,IsNvramLocked)228 TEST_F(TpmNvramDBusProxyTest, IsNvramLocked) {
229   uint32_t nvram_index = 5;
230   bool nvram_locked = true;
231   auto fake_dbus_call = [nvram_index, nvram_locked](
232       dbus::MethodCall* method_call,
233       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
234     // Verify request protobuf.
235     dbus::MessageReader reader(method_call);
236     IsNvramLockedRequest request;
237     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
238     EXPECT_TRUE(request.has_index());
239     EXPECT_EQ(nvram_index, request.index());
240     // Create reply protobuf.
241     auto response = dbus::Response::CreateEmpty();
242     dbus::MessageWriter writer(response.get());
243     IsNvramLockedReply reply;
244     reply.set_status(STATUS_SUCCESS);
245     reply.set_is_locked(nvram_locked);
246     writer.AppendProtoAsArrayOfBytes(reply);
247     response_callback.Run(response.release());
248   };
249   EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
250       .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
251   // Set expectations on the outputs.
252   int callback_count = 0;
253   auto callback = [&callback_count, nvram_locked](
254       const IsNvramLockedReply& reply) {
255     callback_count++;
256     EXPECT_EQ(STATUS_SUCCESS, reply.status());
257     EXPECT_TRUE(reply.has_is_locked());
258     EXPECT_EQ(nvram_locked, reply.is_locked());
259   };
260   IsNvramLockedRequest request;
261   request.set_index(nvram_index);
262   proxy_.IsNvramLocked(request, base::Bind(callback));
263   EXPECT_EQ(1, callback_count);
264 }
265 
TEST_F(TpmNvramDBusProxyTest,GetNvramSize)266 TEST_F(TpmNvramDBusProxyTest, GetNvramSize) {
267   uint32_t nvram_index = 5;
268   size_t nvram_size = 32;
269   auto fake_dbus_call = [nvram_index, nvram_size](
270       dbus::MethodCall* method_call,
271       const dbus::MockObjectProxy::ResponseCallback& response_callback) {
272     // Verify request protobuf.
273     dbus::MessageReader reader(method_call);
274     GetNvramSizeRequest request;
275     EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
276     EXPECT_TRUE(request.has_index());
277     EXPECT_EQ(nvram_index, request.index());
278     // Create reply protobuf.
279     auto response = dbus::Response::CreateEmpty();
280     dbus::MessageWriter writer(response.get());
281     GetNvramSizeReply reply;
282     reply.set_status(STATUS_SUCCESS);
283     reply.set_size(nvram_size);
284     writer.AppendProtoAsArrayOfBytes(reply);
285     response_callback.Run(response.release());
286   };
287   EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
288       .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
289   // Set expectations on the outputs.
290   int callback_count = 0;
291   auto callback = [&callback_count, nvram_size](
292       const GetNvramSizeReply& reply) {
293     callback_count++;
294     EXPECT_EQ(STATUS_SUCCESS, reply.status());
295     EXPECT_TRUE(reply.has_size());
296     EXPECT_EQ(nvram_size, reply.size());
297   };
298   GetNvramSizeRequest request;
299   request.set_index(nvram_index);
300   proxy_.GetNvramSize(request, base::Bind(callback));
301   EXPECT_EQ(1, callback_count);
302 }
303 
304 }  // namespace tpm_manager
305