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