blob: c0cb53fefb7a3bb1f2394f6d0a5b9afc76b50bef [file] [log] [blame]
// Copyright (c) 2011 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 <stddef.h>
#include <string.h>
#include "base/files/file_util.h"
#include "base/macros.h"
#include "base/path_service.h"
#include "chrome/browser/after_startup_task_utils.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_contents_observer.h"
#include "net/base/filename_util.h"
#include "net/base/net_errors.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
class InProcessBrowserTestP
: public InProcessBrowserTest,
public ::testing::WithParamInterface<const char*> {
};
IN_PROC_BROWSER_TEST_P(InProcessBrowserTestP, TestP) {
EXPECT_EQ(0, strcmp("foo", GetParam()));
}
INSTANTIATE_TEST_CASE_P(IPBTP,
InProcessBrowserTestP,
::testing::Values("foo"));
// WebContents observer that can detect provisional load failures.
class LoadFailObserver : public content::WebContentsObserver {
public:
explicit LoadFailObserver(content::WebContents* contents)
: content::WebContentsObserver(contents),
failed_load_(false),
error_code_(net::OK) { }
void DidFailProvisionalLoad(
content::RenderFrameHost* render_frame_host,
const GURL& validated_url,
int error_code,
const base::string16& error_description,
bool was_ignored_by_handler) override {
failed_load_ = true;
error_code_ = static_cast<net::Error>(error_code);
validated_url_ = validated_url;
}
bool failed_load() const { return failed_load_; }
net::Error error_code() const { return error_code_; }
const GURL& validated_url() const { return validated_url_; }
private:
bool failed_load_;
net::Error error_code_;
GURL validated_url_;
DISALLOW_COPY_AND_ASSIGN(LoadFailObserver);
};
// Tests that InProcessBrowserTest cannot resolve external host, in this case
// "google.com" and "cnn.com". Using external resources is disabled by default
// in InProcessBrowserTest because it causes flakiness.
IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, ExternalConnectionFail) {
content::WebContents* contents =
browser()->tab_strip_model()->GetActiveWebContents();
const char* const kURLs[] = {
"http://www.google.com/",
"http://www.cnn.com/"
};
for (size_t i = 0; i < arraysize(kURLs); ++i) {
GURL url(kURLs[i]);
LoadFailObserver observer(contents);
ui_test_utils::NavigateToURL(browser(), url);
EXPECT_TRUE(observer.failed_load());
EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, observer.error_code());
EXPECT_EQ(url, observer.validated_url());
}
}
// Verify that AfterStartupTaskUtils considers startup to be complete
// prior to test execution so tasks posted by tests are never deferred.
IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, AfterStartupTaskUtils) {
EXPECT_TRUE(AfterStartupTaskUtils::IsBrowserStartupComplete());
}
// Paths are to very simple HTML files. One is accessible, the other is not.
const base::FilePath::CharType kPassHTML[] =
FILE_PATH_LITERAL("chrome/test/data/accessibility_pass.html");
const base::FilePath::CharType kFailHTML[] =
FILE_PATH_LITERAL("chrome/test/data/accessibility_fail.html");
/*
* This class is meant as a test for the accessibility audit in the
* InProcessBrowserTest. These tests do NOT validate the accessibility audit,
* just the ability to run it.
*/
class InProcessAccessibilityBrowserTest : public InProcessBrowserTest {
protected:
// Construct a URL from a file path that can be used to get to a web page.
base::FilePath BuildURLToFile(const base::FilePath::CharType* file_path) {
base::FilePath source_root;
if (!PathService::Get(base::DIR_SOURCE_ROOT, &source_root))
return base::FilePath();
return source_root.Append(file_path);
}
bool NavigateToURL(const base::FilePath::CharType* address) {
GURL url = net::FilePathToFileURL(BuildURLToFile(address));
if (!url.is_valid() || url.is_empty() || !browser())
return false;
ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
browser(), url, 1);
return true;
}
};
// Test that an accessible page doesn't fail the accessibility audit.
IN_PROC_BROWSER_TEST_F(
InProcessAccessibilityBrowserTest, DISABLED_VerifyAccessibilityPass) {
ASSERT_TRUE(NavigateToURL(kPassHTML));
std::string test_result;
EXPECT_TRUE(RunAccessibilityChecks(&test_result));
// No error message on success.
EXPECT_EQ("", test_result);
}
// Test that a page that is not accessible will fail the accessibility audit.
IN_PROC_BROWSER_TEST_F(
InProcessAccessibilityBrowserTest, VerifyAccessibilityFail) {
ASSERT_TRUE(NavigateToURL(kFailHTML));
std::string test_result;
EXPECT_FALSE(RunAccessibilityChecks(&test_result));
// Error should NOT be empty on failure.
EXPECT_NE("", test_result);
}
} // namespace