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