blob: 06a57453f3256f3cbe992486a3367a3484fa5766 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome_frame/test/automation_client_mock.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "chrome/common/automation_messages.h"
#include "chrome_frame/custom_sync_call_context.h"
#include "chrome_frame/navigation_constraints.h"
#include "chrome_frame/test/chrome_frame_test_utils.h"
#include "chrome_frame/test/test_scrubber.h"
#include "net/base/net_errors.h"
#define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
#include "testing/gmock_mutant.h"
using testing::_;
using testing::CreateFunctor;
using testing::Return;
namespace {
#ifndef NDEBUG
const base::TimeDelta kChromeLaunchTimeout = base::TimeDelta::FromSeconds(15);
#else
const base::TimeDelta kChromeLaunchTimeout = base::TimeDelta::FromSeconds(10);
#endif
const int kSaneAutomationTimeoutMs = 10 * 1000;
} // namespace
MATCHER_P(LaunchParamProfileEq, profile_name, "Check for profile name") {
return arg->profile_name().compare(profile_name) == 0;
}
void MockProxyFactory::GetServerImpl(ChromeFrameAutomationProxy* pxy,
void* proxy_id,
AutomationLaunchResult result,
LaunchDelegate* d,
ChromeFrameLaunchParams* params,
void** automation_server_id) {
*automation_server_id = proxy_id;
loop_->PostDelayedTask(FROM_HERE,
base::Bind(&LaunchDelegate::LaunchComplete,
base::Unretained(d), pxy, result),
base::TimeDelta::FromMilliseconds(params->launch_timeout()) / 2);
}
void CFACMockTest::SetAutomationServerOk(int times) {
EXPECT_CALL(factory_, GetAutomationServer(testing::NotNull(),
LaunchParamProfileEq(profile_path_.BaseName().value()),
testing::NotNull()))
.Times(times)
.WillRepeatedly(testing::Invoke(CreateFunctor(&factory_,
&MockProxyFactory::GetServerImpl, get_proxy(), id_,
AUTOMATION_SUCCESS)));
EXPECT_CALL(factory_,
ReleaseAutomationServer(testing::Eq(id_), testing::NotNull()))
.Times(times);
}
void CFACMockTest::Set_CFD_LaunchFailed(AutomationLaunchResult result) {
EXPECT_CALL(cfd_, OnAutomationServerLaunchFailed(testing::Eq(result),
testing::_))
.Times(1)
.WillOnce(QUIT_LOOP(loop_));
}
MATCHER_P(MsgType, msg_type, "IPC::Message::type()") {
const IPC::Message& m = arg;
return (m.type() == msg_type);
}
MATCHER_P(EqNavigationInfoUrl, url, "IPC::NavigationInfo matcher") {
if (url.is_valid() && url != arg.url)
return false;
// TODO(stevet): other members
return true;
}
// Could be implemented as MockAutomationProxy member (we have WithArgs<>!)
ACTION_P4(HandleCreateTab, tab_handle, external_tab_container, tab_wnd,
session_id) {
// arg0 - message
// arg1 - callback
// arg2 - key
CreateExternalTabContext::output_type input_args(tab_wnd,
external_tab_container,
tab_handle,
session_id);
CreateExternalTabContext* context =
reinterpret_cast<CreateExternalTabContext*>(arg1);
DispatchToMethod(context, &CreateExternalTabContext::Completed, input_args);
delete context;
}
ACTION_P4(InitiateNavigation, client, url, referrer, constraints) {
client->InitiateNavigation(url, referrer, constraints);
}
// ChromeFrameAutomationClient tests that launch Chrome.
class CFACWithChrome : public testing::Test {
protected:
static void SetUpTestCase();
static void TearDownTestCase();
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
static FilePath profile_path_;
MockCFDelegate cfd_;
scoped_refptr<ChromeFrameAutomationClient> client_;
scoped_refptr<ChromeFrameLaunchParams> launch_params_;
chrome_frame_test::TimedMsgLoop loop_;
};
// static
FilePath CFACWithChrome::profile_path_;
// static
void CFACWithChrome::SetUpTestCase() {
GetChromeFrameProfilePath(L"Adam.N.Epilinter", &profile_path_);
}
// static
void CFACWithChrome::TearDownTestCase() {
profile_path_.clear();
}
void CFACWithChrome::SetUp() {
chrome_frame_test::OverrideDataDirectoryForThisTest(profile_path_.value());
client_ = new ChromeFrameAutomationClient();
GURL empty;
launch_params_ = new ChromeFrameLaunchParams(
empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
false, false, false, false);
launch_params_->set_version_check(false);
launch_params_->set_launch_timeout(kSaneAutomationTimeoutMs);
}
void CFACWithChrome::TearDown() {
client_->Uninitialize();
}
// We mock ChromeFrameDelegate only. The rest is with real AutomationProxy
TEST_F(CFACWithChrome, CreateTooFast) {
int timeout = 0; // Chrome cannot send Hello message so fast.
EXPECT_CALL(cfd_, OnAutomationServerLaunchFailed(AUTOMATION_TIMEOUT, _))
.WillOnce(QUIT_LOOP(loop_));
launch_params_->set_launch_timeout(timeout);
EXPECT_TRUE(client_->Initialize(&cfd_, launch_params_));
loop_.RunFor(kChromeLaunchTimeout);
}
// This test may fail if Chrome take more that 10 seconds (timeout var) to
// launch. In this case GMock shall print something like "unexpected call to
// OnAutomationServerLaunchFailed". I'm yet to find out how to specify
// that this is an unexpected call, and still to execute an action.
TEST_F(CFACWithChrome, CreateNotSoFast) {
EXPECT_CALL(cfd_, OnAutomationServerReady())
.WillOnce(QUIT_LOOP(loop_));
EXPECT_CALL(cfd_, OnAutomationServerLaunchFailed(_, _))
.Times(0);
EXPECT_TRUE(client_->Initialize(&cfd_, launch_params_));
loop_.RunFor(kChromeLaunchTimeout);
}
TEST_F(CFACWithChrome, NavigateOk) {
NavigationConstraintsImpl navigation_constraints;
const std::string url = "about:version";
EXPECT_CALL(cfd_, OnAutomationServerReady())
.WillOnce(InitiateNavigation(client_.get(), url, std::string(),
&navigation_constraints));
EXPECT_CALL(cfd_, GetBounds(_)).Times(testing::AnyNumber());
EXPECT_CALL(cfd_, OnNavigationStateChanged(_))
.Times(testing::AnyNumber());
{
testing::InSequence s;
EXPECT_CALL(cfd_, OnDidNavigate(EqNavigationInfoUrl(GURL())))
.Times(1);
EXPECT_CALL(cfd_, OnUpdateTargetUrl(_)).Times(testing::AtMost(1));
EXPECT_CALL(cfd_, OnLoad(_))
.WillOnce(QUIT_LOOP(loop_));
}
EXPECT_TRUE(client_->Initialize(&cfd_, launch_params_));
loop_.RunFor(kChromeLaunchTimeout);
}
TEST_F(CFACWithChrome, NavigateFailed) {
NavigationConstraintsImpl navigation_constraints;
const std::string url = "http://127.0.0.3:65412/";
const net::URLRequestStatus connection_failed(net::URLRequestStatus::FAILED,
net::ERR_INVALID_URL);
cfd_.SetRequestDelegate(client_);
EXPECT_CALL(cfd_, OnAutomationServerReady())
.WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(CreateFunctor(
client_.get(), &ChromeFrameAutomationClient::InitiateNavigation,
url, std::string(), &navigation_constraints))));
EXPECT_CALL(cfd_, GetBounds(_)).Times(testing::AnyNumber());
EXPECT_CALL(cfd_, OnNavigationStateChanged(_)).Times(testing::AnyNumber());
EXPECT_CALL(cfd_, OnRequestStart(_, _))
// Often there's another request for the error page
.Times(testing::Between(1, 2))
.WillRepeatedly(testing::WithArgs<0>(testing::Invoke(CreateFunctor(&cfd_,
&MockCFDelegate::Reply, connection_failed))));
EXPECT_CALL(cfd_, OnUpdateTargetUrl(_)).Times(testing::AnyNumber());
EXPECT_CALL(cfd_, OnLoad(_)).Times(testing::AtMost(1));
EXPECT_CALL(cfd_, OnNavigationFailed(_, GURL(url)))
.Times(1)
.WillOnce(QUIT_LOOP_SOON(loop_, base::TimeDelta::FromSeconds(2)));
EXPECT_TRUE(client_->Initialize(&cfd_, launch_params_));
loop_.RunFor(kChromeLaunchTimeout);
}
TEST_F(CFACMockTest, MockedCreateTabOk) {
int timeout = 500;
CreateTab();
SetAutomationServerOk(1);
EXPECT_CALL(mock_proxy_, server_version()).Times(testing::AnyNumber())
.WillRepeatedly(Return(""));
// We need some valid HWNDs, when responding to CreateExternalTab
HWND h1 = ::GetDesktopWindow();
HWND h2 = ::GetDesktopWindow();
EXPECT_CALL(mock_proxy_, SendAsAsync(testing::Property(
&IPC::SyncMessage::type, AutomationMsg_CreateExternalTab::ID),
testing::NotNull(), _))
.Times(1).WillOnce(HandleCreateTab(tab_handle_, h1, h2, 99));
EXPECT_CALL(mock_proxy_, CreateTabProxy(testing::Eq(tab_handle_)))
.WillOnce(Return(tab_));
EXPECT_CALL(cfd_, OnAutomationServerReady())
.WillOnce(QUIT_LOOP(loop_));
EXPECT_CALL(mock_proxy_, CancelAsync(_)).Times(testing::AnyNumber());
// Here we go!
GURL empty;
scoped_refptr<ChromeFrameLaunchParams> clp(new ChromeFrameLaunchParams(
empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
false, false, false, false));
clp->set_launch_timeout(timeout);
clp->set_version_check(false);
EXPECT_TRUE(client_->Initialize(&cfd_, clp));
loop_.RunFor(base::TimeDelta::FromSeconds(10));
EXPECT_CALL(mock_proxy_, ReleaseTabProxy(testing::Eq(tab_handle_))).Times(1);
client_->Uninitialize();
}
TEST_F(CFACMockTest, MockedCreateTabFailed) {
HWND null_wnd = NULL;
SetAutomationServerOk(1);
EXPECT_CALL(mock_proxy_, server_version()).Times(testing::AnyNumber())
.WillRepeatedly(Return(""));
EXPECT_CALL(mock_proxy_, SendAsAsync(testing::Property(
&IPC::SyncMessage::type, AutomationMsg_CreateExternalTab::ID),
testing::NotNull(), _))
.Times(1).WillOnce(HandleCreateTab(tab_handle_, null_wnd, null_wnd,
99));
EXPECT_CALL(mock_proxy_, CreateTabProxy(_)).Times(0);
EXPECT_CALL(mock_proxy_, CancelAsync(_)).Times(testing::AnyNumber());
Set_CFD_LaunchFailed(AUTOMATION_CREATE_TAB_FAILED);
// Here we go!
GURL empty;
scoped_refptr<ChromeFrameLaunchParams> clp(new ChromeFrameLaunchParams(
empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
false, false, false, false));
clp->set_launch_timeout(timeout_);
clp->set_version_check(false);
EXPECT_TRUE(client_->Initialize(&cfd_, clp));
loop_.RunFor(base::TimeDelta::FromSeconds(4));
client_->Uninitialize();
}
class TestChromeFrameAutomationProxyImpl
: public ChromeFrameAutomationProxyImpl {
public:
TestChromeFrameAutomationProxyImpl()
// 1 is an unneeded timeout.
: ChromeFrameAutomationProxyImpl(
NULL,
AutomationProxy::GenerateChannelID(),
base::TimeDelta::FromMilliseconds(1)) {
}
MOCK_METHOD3(
SendAsAsync,
void(IPC::SyncMessage* msg,
SyncMessageReplyDispatcher::SyncMessageCallContext* context,
void* key));
void FakeChannelError() {
reinterpret_cast<IPC::ChannelProxy::MessageFilter*>(message_filter_.get())->
OnChannelError();
}
};
TEST_F(CFACMockTest, OnChannelErrorEmpty) {
TestChromeFrameAutomationProxyImpl proxy;
// No tabs should do nothing yet still not fail either.
proxy.FakeChannelError();
}
TEST_F(CFACMockTest, OnChannelError) {
const base::TimeDelta loop_duration = base::TimeDelta::FromSeconds(11);
TestChromeFrameAutomationProxyImpl proxy;
returned_proxy_ = &proxy;
GURL empty;
scoped_refptr<ChromeFrameLaunchParams> clp(new ChromeFrameLaunchParams(
empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
false, false, false, false));
clp->set_launch_timeout(1); // Unneeded timeout, but can't be 0.
clp->set_version_check(false);
HWND h1 = ::GetDesktopWindow();
HWND h2 = ::GetDesktopWindow();
EXPECT_CALL(proxy, SendAsAsync(testing::Property(
&IPC::SyncMessage::type, AutomationMsg_CreateExternalTab::ID),
testing::NotNull(), _)).Times(3)
.WillOnce(HandleCreateTab(tab_handle_, h1, h2, 99))
.WillOnce(HandleCreateTab(tab_handle_ * 2, h1, h2, 100))
.WillOnce(HandleCreateTab(tab_handle_ * 3, h1, h2, 101));
SetAutomationServerOk(3);
// First, try a single tab and make sure the notification find its way to the
// Chrome Frame Delegate.
StrictMock<MockCFDelegate> cfd1;
scoped_refptr<ChromeFrameAutomationClient> client1;
client1 = new ChromeFrameAutomationClient;
client1->set_proxy_factory(&factory_);
EXPECT_CALL(cfd1, OnAutomationServerReady()).WillOnce(QUIT_LOOP(loop_));
EXPECT_TRUE(client1->Initialize(&cfd1, clp));
// Wait for OnAutomationServerReady to be called in the UI thread.
loop_.RunFor(loop_duration);
proxy.FakeChannelError();
EXPECT_CALL(cfd1, OnChannelError()).WillOnce(QUIT_LOOP(loop_));
// Wait for OnChannelError to be propagated to delegate from the UI thread.
loop_.RunFor(loop_duration);
// Add a second tab using a different delegate.
StrictMock<MockCFDelegate> cfd2;
scoped_refptr<ChromeFrameAutomationClient> client2;
client2 = new ChromeFrameAutomationClient;
client2->set_proxy_factory(&factory_);
EXPECT_CALL(cfd2, OnAutomationServerReady()).WillOnce(QUIT_LOOP(loop_));
EXPECT_TRUE(client2->Initialize(&cfd2, clp));
// Wait for OnAutomationServerReady to be called in the UI thread.
loop_.RunFor(loop_duration);
EXPECT_CALL(cfd1, OnChannelError()).Times(1);
EXPECT_CALL(cfd2, OnChannelError()).WillOnce(QUIT_LOOP(loop_));
proxy.FakeChannelError();
// Wait for OnChannelError to be propagated to delegate from the UI thread.
loop_.RunFor(loop_duration);
// And now a 3rd tab using the first delegate.
scoped_refptr<ChromeFrameAutomationClient> client3;
client3 = new ChromeFrameAutomationClient;
client3->set_proxy_factory(&factory_);
EXPECT_CALL(cfd1, OnAutomationServerReady()).WillOnce(QUIT_LOOP(loop_));
EXPECT_TRUE(client3->Initialize(&cfd1, clp));
// Wait for OnAutomationServerReady to be called in the UI thread.
loop_.RunFor(loop_duration);
EXPECT_CALL(cfd2, OnChannelError()).Times(1);
EXPECT_CALL(cfd1, OnChannelError()).Times(2).WillOnce(Return())
.WillOnce(QUIT_LOOP(loop_));
proxy.FakeChannelError();
// Wait for OnChannelError to be propagated to delegate from the UI thread.
loop_.RunFor(loop_duration);
// Cleanup.
client1->Uninitialize();
client2->Uninitialize();
client3->Uninitialize();
client1 = NULL;
client2 = NULL;
client3 = NULL;
}
TEST_F(CFACMockTest, NavigateTwiceAfterInitToSameUrl) {
int timeout = 500;
NavigationConstraintsImpl navigation_constraints;
CreateTab();
SetAutomationServerOk(1);
EXPECT_CALL(mock_proxy_, server_version()).Times(testing::AnyNumber())
.WillRepeatedly(Return(""));
// We need some valid HWNDs, when responding to CreateExternalTab
HWND h1 = ::GetDesktopWindow();
HWND h2 = ::GetDesktopWindow();
EXPECT_CALL(mock_proxy_, SendAsAsync(testing::Property(
&IPC::SyncMessage::type, AutomationMsg_CreateExternalTab::ID),
testing::NotNull(), _))
.Times(1).WillOnce(HandleCreateTab(tab_handle_, h1, h2, 99));
EXPECT_CALL(mock_proxy_, CreateTabProxy(testing::Eq(tab_handle_)))
.WillOnce(Return(tab_));
EXPECT_CALL(cfd_, OnAutomationServerReady())
.WillOnce(InitiateNavigation(client_.get(),
std::string("http://www.nonexistent.com"),
std::string(), &navigation_constraints));
EXPECT_CALL(mock_proxy_, SendAsAsync(testing::Property(
&IPC::SyncMessage::type, AutomationMsg_NavigateInExternalTab::ID),
testing::NotNull(), _))
.Times(1).WillOnce(QUIT_LOOP(loop_));
EXPECT_CALL(mock_proxy_, CancelAsync(_)).Times(testing::AnyNumber());
EXPECT_CALL(mock_proxy_, Send(
testing::Property(&IPC::Message::type, AutomationMsg_TabReposition::ID)))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(cfd_, GetBounds(_)).Times(1);
// Here we go!
GURL empty;
scoped_refptr<ChromeFrameLaunchParams> launch_params(
new ChromeFrameLaunchParams(
GURL("http://www.nonexistent.com"), empty, profile_path_,
profile_path_.BaseName().value(), L"", false, false, false, false));
launch_params->set_launch_timeout(timeout);
launch_params->set_version_check(false);
EXPECT_TRUE(client_->Initialize(&cfd_, launch_params));
loop_.RunFor(base::TimeDelta::FromSeconds(10));
EXPECT_CALL(mock_proxy_, ReleaseTabProxy(testing::Eq(tab_handle_))).Times(1);
client_->Uninitialize();
}