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; 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 47 TEST_F(TpmNvramDBusProxyTest, DefineSpace) { 48 uint32_t nvram_index = 5; 49 size_t nvram_size = 32; 50 auto fake_dbus_call = [nvram_index, nvram_size]( 51 dbus::MethodCall* method_call, 52 const dbus::MockObjectProxy::ResponseCallback& response_callback) { 53 // Verify request protobuf. 54 dbus::MessageReader reader(method_call); 55 DefineSpaceRequest 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_size()); 60 EXPECT_EQ(nvram_size, request.size()); 61 // Create reply protobuf. 62 auto response = dbus::Response::CreateEmpty(); 63 dbus::MessageWriter writer(response.get()); 64 DefineSpaceReply reply; 65 reply.set_result(NVRAM_RESULT_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 DefineSpaceReply& reply) { 74 callback_count++; 75 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 76 }; 77 DefineSpaceRequest request; 78 request.set_index(nvram_index); 79 request.set_size(nvram_size); 80 proxy_.DefineSpace(request, base::Bind(callback)); 81 EXPECT_EQ(1, callback_count); 82 } 83 84 TEST_F(TpmNvramDBusProxyTest, DestroySpaceRequest) { 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 DestroySpaceRequest 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 DestroySpaceReply reply; 99 reply.set_result(NVRAM_RESULT_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 DestroySpaceReply& reply) { 108 callback_count++; 109 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 110 }; 111 DestroySpaceRequest request; 112 request.set_index(nvram_index); 113 proxy_.DestroySpace(request, base::Bind(callback)); 114 EXPECT_EQ(1, callback_count); 115 } 116 TEST_F(TpmNvramDBusProxyTest, WriteSpace) { 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 WriteSpaceRequest 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 WriteSpaceReply reply; 134 reply.set_result(NVRAM_RESULT_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 WriteSpaceReply& reply) { 143 callback_count++; 144 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 145 }; 146 WriteSpaceRequest request; 147 request.set_index(nvram_index); 148 request.set_data(nvram_data); 149 proxy_.WriteSpace(request, base::Bind(callback)); 150 EXPECT_EQ(1, callback_count); 151 } 152 153 TEST_F(TpmNvramDBusProxyTest, ReadSpace) { 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 ReadSpaceRequest 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 ReadSpaceReply reply; 169 reply.set_result(NVRAM_RESULT_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 ReadSpaceReply& reply) { 179 callback_count++; 180 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 181 EXPECT_TRUE(reply.has_data()); 182 EXPECT_EQ(nvram_data, reply.data()); 183 }; 184 ReadSpaceRequest request; 185 request.set_index(nvram_index); 186 proxy_.ReadSpace(request, base::Bind(callback)); 187 EXPECT_EQ(1, callback_count); 188 } 189 190 TEST_F(TpmNvramDBusProxyTest, LockSpace) { 191 uint32_t nvram_index = 5; 192 auto fake_dbus_call = [nvram_index]( 193 dbus::MethodCall* method_call, 194 const dbus::MockObjectProxy::ResponseCallback& response_callback) { 195 // Verify request protobuf. 196 dbus::MessageReader reader(method_call); 197 LockSpaceRequest request; 198 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request)); 199 EXPECT_TRUE(request.has_index()); 200 EXPECT_EQ(nvram_index, request.index()); 201 // Create reply protobuf. 202 auto response = dbus::Response::CreateEmpty(); 203 dbus::MessageWriter writer(response.get()); 204 LockSpaceReply reply; 205 reply.set_result(NVRAM_RESULT_SUCCESS); 206 writer.AppendProtoAsArrayOfBytes(reply); 207 response_callback.Run(response.release()); 208 }; 209 EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _)) 210 .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call))); 211 // Set expectations on the outputs. 212 int callback_count = 0; 213 auto callback = [&callback_count](const LockSpaceReply& reply) { 214 callback_count++; 215 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 216 }; 217 LockSpaceRequest request; 218 request.set_index(nvram_index); 219 proxy_.LockSpace(request, base::Bind(callback)); 220 EXPECT_EQ(1, callback_count); 221 } 222 223 TEST_F(TpmNvramDBusProxyTest, ListSpaces) { 224 constexpr uint32_t nvram_index_list[] = {3, 4, 5}; 225 auto fake_dbus_call = [nvram_index_list]( 226 dbus::MethodCall* method_call, 227 const dbus::MockObjectProxy::ResponseCallback& response_callback) { 228 // Verify request protobuf. 229 dbus::MessageReader reader(method_call); 230 ListSpacesRequest request; 231 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request)); 232 // Create reply protobuf. 233 auto response = dbus::Response::CreateEmpty(); 234 dbus::MessageWriter writer(response.get()); 235 ListSpacesReply reply; 236 reply.set_result(NVRAM_RESULT_SUCCESS); 237 for (auto index : nvram_index_list) { 238 reply.add_index_list(index); 239 } 240 writer.AppendProtoAsArrayOfBytes(reply); 241 response_callback.Run(response.release()); 242 }; 243 EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _)) 244 .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call))); 245 // Set expectations on the outputs. 246 int callback_count = 0; 247 auto callback = [&callback_count, 248 nvram_index_list](const ListSpacesReply& reply) { 249 callback_count++; 250 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 251 EXPECT_EQ(arraysize(nvram_index_list), reply.index_list_size()); 252 for (size_t i = 0; i < 3; i++) { 253 EXPECT_EQ(nvram_index_list[i], reply.index_list(i)); 254 } 255 }; 256 ListSpacesRequest request; 257 proxy_.ListSpaces(request, base::Bind(callback)); 258 EXPECT_EQ(1, callback_count); 259 } 260 261 TEST_F(TpmNvramDBusProxyTest, GetSpaceInfo) { 262 uint32_t nvram_index = 5; 263 size_t nvram_size = 32; 264 auto fake_dbus_call = [nvram_index, nvram_size]( 265 dbus::MethodCall* method_call, 266 const dbus::MockObjectProxy::ResponseCallback& response_callback) { 267 // Verify request protobuf. 268 dbus::MessageReader reader(method_call); 269 GetSpaceInfoRequest request; 270 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request)); 271 EXPECT_TRUE(request.has_index()); 272 EXPECT_EQ(nvram_index, request.index()); 273 // Create reply protobuf. 274 auto response = dbus::Response::CreateEmpty(); 275 dbus::MessageWriter writer(response.get()); 276 GetSpaceInfoReply reply; 277 reply.set_result(NVRAM_RESULT_SUCCESS); 278 reply.set_size(nvram_size); 279 writer.AppendProtoAsArrayOfBytes(reply); 280 response_callback.Run(response.release()); 281 }; 282 EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _)) 283 .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call))); 284 // Set expectations on the outputs. 285 int callback_count = 0; 286 auto callback = [&callback_count, 287 nvram_size](const GetSpaceInfoReply& reply) { 288 callback_count++; 289 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 290 EXPECT_TRUE(reply.has_size()); 291 EXPECT_EQ(nvram_size, reply.size()); 292 }; 293 GetSpaceInfoRequest request; 294 request.set_index(nvram_index); 295 proxy_.GetSpaceInfo(request, base::Bind(callback)); 296 EXPECT_EQ(1, callback_count); 297 } 298 299 } // namespace tpm_manager 300
