src/chrome_frame/test/automation_client_mock.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_FRAME_TEST_AUTOMATION_CLIENT_MOCK_H_
   6 #define CHROME_FRAME_TEST_AUTOMATION_CLIENT_MOCK_H_
   7
   8 #include <windows.h>
   9 #include <string>
  10
  11 #include "base/strings/string_util.h"
  12 #include "chrome_frame/chrome_frame_automation.h"
  13 #include "chrome_frame/test/chrome_frame_test_utils.h"
  14 #include "chrome_frame/test/proxy_factory_mock.h"
  15 #include "chrome_frame/utils.h"
  16 #include "gmock/gmock.h"
  17
  18 using testing::StrictMock;
  19
  20 // ChromeFrameAutomationClient [CFAC] tests.
  21 struct MockCFDelegate : public ChromeFrameDelegateImpl {
  22   MOCK_CONST_METHOD0(GetWindow, WindowType());
  23   MOCK_METHOD1(GetBounds, void(RECT* bounds));
  24   MOCK_METHOD0(GetDocumentUrl, std::string());
  25   MOCK_METHOD2(ExecuteScript, bool(const std::string& script,
  26                                    std::string* result));
  27   MOCK_METHOD0(OnAutomationServerReady, void());
  28   MOCK_METHOD2(OnAutomationServerLaunchFailed, void(
  29       AutomationLaunchResult reason, const std::string& server_version));
  30   // This remains in interface since we call it if Navigate()
  31   // returns immediate error.
  32   MOCK_METHOD2(OnLoadFailed, void(int error_code, const std::string& url));
  33
  34   // Do not mock this method. :) Use it as message demuxer and dispatcher
  35   // to the following methods (which we mock)
  36   // MOCK_METHOD1(OnMessageReceived, void(const IPC::Message&));
  37
  38   MOCK_METHOD0(OnChannelError, void(void));
  39   MOCK_METHOD1(OnNavigationStateChanged, void(int flags));
  40   MOCK_METHOD1(OnUpdateTargetUrl, void(
  41       const std::wstring& new_target_url));
  42   MOCK_METHOD1(OnAcceleratorPressed, void(const MSG& accel_message));
  43   MOCK_METHOD1(OnTabbedOut, void(bool reverse));
  44   MOCK_METHOD2(OnOpenURL, void(const GURL& url, int open_disposition));
  45   MOCK_METHOD1(OnDidNavigate, void(
  46       const NavigationInfo& navigation_info));
  47   MOCK_METHOD2(OnNavigationFailed, void(int error_code, const GURL& gurl));
  48   MOCK_METHOD1(OnLoad, void(const GURL& url));
  49   MOCK_METHOD3(OnMessageFromChromeFrame, void(
  50       const std::string& message,
  51       const std::string& origin,
  52       const std::string& target));
  53   MOCK_METHOD3(OnHandleContextMenu, void(HANDLE menu_handle,
  54       int align_flags, const MiniContextMenuParams& params));
  55   MOCK_METHOD2(OnRequestStart, void(int request_id,
  56       const AutomationURLRequest& request));
  57   MOCK_METHOD2(OnRequestRead, void(int request_id, int bytes_to_read));
  58   MOCK_METHOD2(OnRequestEnd, void(int request_id,
  59       const net::URLRequestStatus& status));
  60   MOCK_METHOD2(OnSetCookieAsync, void(const GURL& url,
  61       const std::string& cookie));
  62
  63   // Use for sending network responses
  64   void SetRequestDelegate(PluginUrlRequestDelegate* request_delegate) {
  65     request_delegate_ = request_delegate;
  66   }
  67
  68   void ReplyStarted(int request_id, const char* headers) {
  69     request_delegate_->OnResponseStarted(request_id, "text/html", headers,
  70       0, base::Time::Now(), EmptyString(), 0, net::HostPortPair(), 0);
  71   }
  72
  73   void ReplyData(int request_id, const std::string* data) {
  74     request_delegate_->OnReadComplete(request_id, *data);
  75   }
  76
  77   void Reply(const net::URLRequestStatus& status, int request_id) {
  78     request_delegate_->OnResponseEnd(request_id, status);
  79   }
  80
  81   void Reply404(int request_id) {
  82     ReplyStarted(request_id, "HTTP/1.1 404\r\n\r\n");
  83     Reply(net::URLRequestStatus(), request_id);
  84   }
  85
  86   PluginUrlRequestDelegate* request_delegate_;
  87 };
  88
  89 class MockAutomationProxy : public ChromeFrameAutomationProxy {
  90  public:
  91   MOCK_METHOD1(Send, bool(IPC::Message*));
  92   MOCK_METHOD3(SendAsAsync,
  93                void(IPC::SyncMessage* msg,
  94                     SyncMessageReplyDispatcher::SyncMessageCallContext* context,
  95                     void* key));
  96   MOCK_METHOD1(CancelAsync, void(void* key));
  97   MOCK_METHOD1(CreateTabProxy, scoped_refptr<TabProxy>(int handle));
  98   MOCK_METHOD1(ReleaseTabProxy, void(AutomationHandle handle));
  99   MOCK_METHOD0(server_version, std::string(void));
 100   MOCK_METHOD1(SendProxyConfig, void(const std::string&));
 101
 102   ~MockAutomationProxy() {}
 103 };
 104
 105 struct MockAutomationMessageSender : public AutomationMessageSender {
 106   virtual bool Send(IPC::Message* msg) {
 107     return proxy_->Send(msg);
 108   }
 109
 110   virtual bool Send(IPC::Message* msg, int timeout_ms) {
 111     return proxy_->Send(msg);
 112   }
 113
 114   void ForwardTo(StrictMock<MockAutomationProxy> *p) {
 115     proxy_ = p;
 116   }
 117
 118   StrictMock<MockAutomationProxy>* proxy_;
 119 };
 120
 121 // [CFAC] -- uses a ProxyFactory for creation of ChromeFrameAutomationProxy
 122 // -- uses ChromeFrameAutomationProxy
 123 // -- uses TabProxy obtained from ChromeFrameAutomationProxy
 124 // -- uses ChromeFrameDelegate as outgoing interface
 125 //
 126 // We mock ProxyFactory to return mock object (MockAutomationProxy) implementing
 127 // ChromeFrameAutomationProxy interface.
 128 // Since CFAC uses TabProxy for few calls and TabProxy is not easy mockable,
 129 // we create 'real' TabProxy but with fake AutomationSender (the one responsible
 130 // for sending messages over channel).
 131 // Additionally we have mock implementation ChromeFrameDelagate interface -
 132 // MockCFDelegate.
 133
 134 // Test fixture, saves typing all of it's members.
 135 class CFACMockTest : public testing::Test {
 136  public:
 137   MockProxyFactory factory_;
 138   MockCFDelegate   cfd_;
 139   chrome_frame_test::TimedMsgLoop loop_;
 140   // Most of the test uses the mocked proxy, but some tests need
 141   // to validate the functionality of the real proxy object.
 142   // So we have a mock that is used as the default for the returned_proxy_
 143   // pointer, but tests can set their own pointer in there as needed.
 144   StrictMock<MockAutomationProxy> mock_proxy_;
 145   ChromeFrameAutomationProxy* returned_proxy_;
 146   scoped_ptr<AutomationHandleTracker> tracker_;
 147   MockAutomationMessageSender dummy_sender_;
 148   scoped_refptr<TabProxy> tab_;
 149   // the victim of all tests
 150   scoped_refptr<ChromeFrameAutomationClient> client_;
 151
 152   base::FilePath profile_path_;
 153   int timeout_;
 154   void* id_;  // Automation server id we are going to return
 155   int tab_handle_;   // Tab handle. Any non-zero value is Ok.
 156
 157   inline ChromeFrameAutomationProxy* get_proxy() {
 158     return returned_proxy_;
 159   }
 160
 161   inline void CreateTab() {
 162     ASSERT_EQ(NULL, tab_.get());
 163     tab_ = new TabProxy(&dummy_sender_, tracker_.get(), tab_handle_);
 164   }
 165
 166   // Easy methods to set expectations.
 167   void SetAutomationServerOk(int times);
 168   void Set_CFD_LaunchFailed(AutomationLaunchResult result);
 169
 170  protected:
 171   CFACMockTest()
 172     : timeout_(500),
 173       returned_proxy_(static_cast<ChromeFrameAutomationProxy*>(&mock_proxy_)) {
 174     GetChromeFrameProfilePath(L"Adam.N.Epilinter", &profile_path_);
 175     id_ = reinterpret_cast<void*>(5);
 176     tab_handle_ = 3;
 177   }
 178
 179   virtual void SetUp() {
 180     dummy_sender_.ForwardTo(&mock_proxy_);
 181     tracker_.reset(new AutomationHandleTracker());
 182
 183     client_ = new ChromeFrameAutomationClient;
 184     client_->set_proxy_factory(&factory_);
 185   }
 186 };
 187
 188 #endif  // CHROME_FRAME_TEST_AUTOMATION_CLIENT_MOCK_H_