1 //
2 // Copyright (C) 2014 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 #ifndef TRUNKS_TRUNKS_FACTORY_FOR_TEST_H_
18 #define TRUNKS_TRUNKS_FACTORY_FOR_TEST_H_
19 
20 #include "trunks/trunks_factory.h"
21 
22 #include <memory>
23 #include <string>
24 
25 #include <base/macros.h>
26 
27 #include "trunks/password_authorization_delegate.h"
28 #include "trunks/trunks_export.h"
29 
30 namespace trunks {
31 
32 class AuthorizationDelegate;
33 class MockBlobParser;
34 class MockHmacSession;
35 class MockPolicySession;
36 class MockSessionManager;
37 class MockTpm;
38 class MockTpmState;
39 class MockTpmUtility;
40 class HmacSession;
41 class PasswordAuthorizationDelegate;
42 class PolicySession;
43 class SessionManager;
44 class Tpm;
45 class TpmState;
46 class TpmUtility;
47 
48 // A factory implementation for testing. Custom instances can be injected. If no
49 // instance has been injected, a default mock instance will be used. Objects for
50 // which ownership is passed to the caller are instantiated as forwarders which
51 // simply forward calls to the current instance set for the class.
52 //
53 // Example usage:
54 //   TrunksFactoryForTest factory;
55 //   MockTpmState mock_tpm_state;
56 //   factory.set_tpm_state(mock_tpm_state);
57 //   // Set expectations on mock_tpm_state...
58 class TRUNKS_EXPORT TrunksFactoryForTest : public TrunksFactory {
59  public:
60   TrunksFactoryForTest();
61   ~TrunksFactoryForTest() override;
62 
63   // TrunksFactory methods.
64   Tpm* GetTpm() const override;
65   std::unique_ptr<TpmState> GetTpmState() const override;
66   std::unique_ptr<TpmUtility> GetTpmUtility() const override;
67   std::unique_ptr<AuthorizationDelegate> GetPasswordAuthorization(
68       const std::string& password) const override;
69   std::unique_ptr<SessionManager> GetSessionManager() const override;
70   std::unique_ptr<HmacSession> GetHmacSession() const override;
71   std::unique_ptr<PolicySession> GetPolicySession() const override;
72   std::unique_ptr<PolicySession> GetTrialSession() const override;
73   std::unique_ptr<BlobParser> GetBlobParser() const override;
74 
75   // Mutators to inject custom mocks.
set_tpm(Tpm * tpm)76   void set_tpm(Tpm* tpm) { tpm_ = tpm; }
77 
set_tpm_state(TpmState * tpm_state)78   void set_tpm_state(TpmState* tpm_state) { tpm_state_ = tpm_state; }
79 
set_tpm_utility(TpmUtility * tpm_utility)80   void set_tpm_utility(TpmUtility* tpm_utility) { tpm_utility_ = tpm_utility; }
81 
set_password_authorization_delegate(AuthorizationDelegate * delegate)82   void set_password_authorization_delegate(AuthorizationDelegate* delegate) {
83     password_authorization_delegate_ = delegate;
84   }
85 
set_session_manager(SessionManager * session_manager)86   void set_session_manager(SessionManager* session_manager) {
87     session_manager_ = session_manager;
88   }
89 
set_hmac_session(HmacSession * hmac_session)90   void set_hmac_session(HmacSession* hmac_session) {
91     hmac_session_ = hmac_session;
92   }
93 
set_policy_session(PolicySession * policy_session)94   void set_policy_session(PolicySession* policy_session) {
95     policy_session_ = policy_session;
96   }
97 
set_trial_session(PolicySession * trial_session)98   void set_trial_session(PolicySession* trial_session) {
99     trial_session_ = trial_session;
100   }
101 
set_blob_parser(BlobParser * blob_parser)102   void set_blob_parser(BlobParser* blob_parser) { blob_parser_ = blob_parser; }
103 
104  private:
105   std::unique_ptr<MockTpm> default_tpm_;
106   Tpm* tpm_;
107   std::unique_ptr<MockTpmState> default_tpm_state_;
108   TpmState* tpm_state_;
109   std::unique_ptr<MockTpmUtility> default_tpm_utility_;
110   TpmUtility* tpm_utility_;
111   std::unique_ptr<PasswordAuthorizationDelegate>
112       default_authorization_delegate_;
113   AuthorizationDelegate* password_authorization_delegate_;
114   std::unique_ptr<MockSessionManager> default_session_manager_;
115   SessionManager* session_manager_;
116   std::unique_ptr<MockHmacSession> default_hmac_session_;
117   HmacSession* hmac_session_;
118   std::unique_ptr<MockPolicySession> default_policy_session_;
119   PolicySession* policy_session_;
120   std::unique_ptr<MockPolicySession> default_trial_session_;
121   PolicySession* trial_session_;
122   std::unique_ptr<MockBlobParser> default_blob_parser_;
123   BlobParser* blob_parser_;
124 
125   DISALLOW_COPY_AND_ASSIGN(TrunksFactoryForTest);
126 };
127 
128 }  // namespace trunks
129 
130 #endif  // TRUNKS_TRUNKS_FACTORY_FOR_TEST_H_
131