blob: 04349ded17738714e810a2fc55f1c33314d28dc4 [file] [log] [blame]
// Copyright 2013 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 "base/bind.h"
#include "base/files/file_path.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/path_service.h"
#include "base/strings/string_number_conversions.h"
#include "chrome/browser/chromeos/first_run/drive_first_run_controller.h"
#include "chrome/browser/extensions/crx_installer.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/extensions/extension_test_notification_observer.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "content/public/test/test_utils.h"
#include "extensions/browser/extension_system.h"
#include "net/dns/mock_host_resolver.h"
#include "net/http/http_status_code.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "net/test/embedded_test_server/http_request.h"
#include "net/test/embedded_test_server/http_response.h"
namespace chromeos {
namespace {
// Directory containing data files for the tests.
const char kTestDirectory[] = "drive_first_run";
// Directory containing correct hosted app page served by the test server.
const char kGoodServerDirectory[] = "good";
// Directory containing incorrect hosted app page served by the test server.
const char kBadServerDirectory[] = "bad";
// Name of the test hosted app .crx file.
const char kTestAppCrxName[] = "app.crx";
// App id of the test hosted app.
const char kTestAppId[] = "kipccbklifbfblhpplnmklieangbjnhb";
// The endpoint belonging to the test hosted app.
const char kTestEndpointUrl[] = "http://example.com/endpoint.html";
} // namespace
class DriveFirstRunTest : public InProcessBrowserTest,
public DriveFirstRunController::Observer {
protected:
DriveFirstRunTest();
// InProcessBrowserTest overrides:
void SetUpOnMainThread() override;
void TearDownOnMainThread() override;
// DriveFirstRunController::Observer overrides:
void OnCompletion(bool success) override;
void OnTimedOut() override;
void InstallApp();
void InitTestServer(const std::string& directory);
bool WaitForFirstRunResult();
void EnableOfflineMode();
void SetDelays(int initial_delay_secs, int timeout_secs);
bool timed_out() const { return timed_out_; }
private:
// |controller_| is responsible for its own lifetime.
DriveFirstRunController* controller_;
scoped_refptr<content::MessageLoopRunner> runner_;
bool timed_out_;
bool waiting_for_result_;
bool success_;
base::FilePath test_data_dir_;
std::string endpoint_url_;
};
DriveFirstRunTest::DriveFirstRunTest() :
timed_out_(false),
waiting_for_result_(false),
success_(false) {}
void DriveFirstRunTest::SetUpOnMainThread() {
InProcessBrowserTest::SetUpOnMainThread();
PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
test_data_dir_ = test_data_dir_.AppendASCII(kTestDirectory);
host_resolver()->AddRule("example.com", "127.0.0.1");
// |controller_| will delete itself when it completes.
controller_ = new DriveFirstRunController(browser()->profile());
controller_->AddObserver(this);
controller_->SetDelaysForTest(0, 10);
controller_->SetAppInfoForTest(kTestAppId, kTestEndpointUrl);
}
void DriveFirstRunTest::TearDownOnMainThread() {
content::RunAllPendingInMessageLoop();
}
void DriveFirstRunTest::InitTestServer(const std::string& directory) {
embedded_test_server()->ServeFilesFromDirectory(
test_data_dir_.AppendASCII(directory));
ASSERT_TRUE(embedded_test_server()->Start());
// Configure the endpoint to use the test server's port.
const GURL url(kTestEndpointUrl);
GURL::Replacements replacements;
std::string port(base::IntToString(embedded_test_server()->port()));
replacements.SetPortStr(port);
endpoint_url_ = url.ReplaceComponents(replacements).spec();
controller_->SetAppInfoForTest(kTestAppId, endpoint_url_);
}
void DriveFirstRunTest::InstallApp() {
ExtensionService* extension_service = extensions::ExtensionSystem::Get(
browser()->profile())->extension_service();
scoped_refptr<extensions::CrxInstaller> installer =
extensions::CrxInstaller::CreateSilent(extension_service);
installer->InstallCrx(test_data_dir_.AppendASCII(kTestAppCrxName));
ExtensionTestNotificationObserver observer(browser());
observer.WaitForExtensionLoad();
ASSERT_TRUE(extension_service->GetExtensionById(kTestAppId, false));
}
void DriveFirstRunTest::EnableOfflineMode() {
controller_->EnableOfflineMode();
}
void DriveFirstRunTest::SetDelays(int initial_delay_secs, int timeout_secs) {
controller_->SetDelaysForTest(initial_delay_secs, timeout_secs);
}
bool DriveFirstRunTest::WaitForFirstRunResult() {
waiting_for_result_ = true;
runner_ = new content::MessageLoopRunner;
runner_->Run();
EXPECT_FALSE(waiting_for_result_);
return success_;
}
void DriveFirstRunTest::OnCompletion(bool success) {
EXPECT_TRUE(waiting_for_result_);
waiting_for_result_ = false;
success_ = success;
runner_->Quit();
// |controller_| will eventually delete itself upon completion, so invalidate
// the pointer.
controller_ = NULL;
}
void DriveFirstRunTest::OnTimedOut() {
timed_out_ = true;
}
IN_PROC_BROWSER_TEST_F(DriveFirstRunTest, OfflineEnabled) {
InstallApp();
InitTestServer(kGoodServerDirectory);
EnableOfflineMode();
EXPECT_TRUE(WaitForFirstRunResult());
}
IN_PROC_BROWSER_TEST_F(DriveFirstRunTest, AppNotInstalled) {
InitTestServer(kGoodServerDirectory);
EnableOfflineMode();
EXPECT_FALSE(WaitForFirstRunResult());
EXPECT_FALSE(timed_out());
}
IN_PROC_BROWSER_TEST_F(DriveFirstRunTest, TimedOut) {
// Test that the controller times out instead of hanging forever.
InstallApp();
InitTestServer(kBadServerDirectory);
SetDelays(0, 0);
EnableOfflineMode();
EXPECT_FALSE(WaitForFirstRunResult());
EXPECT_TRUE(timed_out());
}
} // namespace chromeos