Adding the "Authenticate" step to the "MANUAL_Auth" test case. Also added the username and password…

remoting/test/remote_desktop_browsertest.cc

 // Copyright (c) 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/command_line.h"
 #include "base/path_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
@@ skipping 17 matching lines @@
 #include "net/dns/mock_host_resolver.h"
 
 using extensions::Extension;
 
 namespace {
 // Command line arguments specific to the chromoting browser tests.
 const char kOverrideUserDataDir[] = "override-user-data-dir";
 const char kNoCleanup[] = "no-cleanup";
 const char kNoInstall[] = "no-install";
 const char kWebAppCrx[] = "webapp-crx";
+const char kUsername[] = "username";
+const char kPassword[] = "password";
+
+// ASSERT_TRUE can only be used in void returning functions.
+void _ASSERT_TRUE(bool condition) {
+  ASSERT_TRUE(condition);
+  return;
+}
+
 }
 
 namespace remoting {
 
 class RemoteDesktopBrowserTest : public ExtensionBrowserTest {
  public:
   virtual void SetUp() OVERRIDE {
     ParseCommandLine();
     ExtensionBrowserTest::SetUp();
   }
@@ skipping 22 matching lines @@
   void VerifyChromotingLoaded(bool expected);
 
   // Launch the chromoting app.
   void LaunchChromotingApp();
 
   // Verify the test has access to the internet (specifically google.com)
   void VerifyInternetAccess();
 
   void Authorize();
 
+  void Authenticate();
+
   // Whether to perform the cleanup tasks (uninstalling chromoting, etc).
   // This is useful for diagnostic purposes.
   bool NoCleanup() { return no_cleanup_; }
 
   // Whether to install the chromoting extension before running the test cases.
   // This is useful for diagnostic purposes.
   bool NoInstall() { return no_install_; }
 
  private:
   void ParseCommandLine();
@@ skipping 10 matching lines @@
   base::FilePath WebAppCrxPath() { return webapp_crx_; }
 
   // Helper to get the extension ID of the installed chromoting webapp.
   std::string ChromotingID() { return chromoting_id_; }
 
   // Helper to retrieve the current URL of the active tab in the browser.
   GURL GetCurrentURL() {
     return browser()->tab_strip_model()->GetActiveWebContents()->GetURL();
   }
 
+  // Helper to execute a javascript code snippet on the current page.
+  void ExecuteScript(const std::string& script) {
+    ASSERT_TRUE(content::ExecuteScript(
+        browser()->tab_strip_model()->GetActiveWebContents(), script));
+  }
+
+  // Helper to execute a javascript code snippet on the current page and
+  // wait for page load to complete.
+  void ExecuteScriptAndWait(const std::string& script) {
+    content::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        content::Source<content::NavigationController>(
+            &browser()->tab_strip_model()->GetActiveWebContents()->
+                GetController()));
+
+    ExecuteScript(script);
+
+    observer.Wait();
+  }
+
+  // Helper to execute a javascript code snippet on the current page and
+  // extract the boolean result.
+  bool ExecuteScriptAndExtractBool(const std::string& script) {
+    bool result;
+    // Using a private assert function because ASSERT_TRUE can only be used in
+    // void returning functions.
+    _ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+        browser()->tab_strip_model()->GetActiveWebContents(),
+        "window.domAutomationController.send(" + script + ");",
+        &result));
+
+    return result;
+  }
+
+  // Helper to check whether a html element with the given name exists on
+  // the current page.
+  bool HtmlElementExists(const std::string& name) {
+    return ExecuteScriptAndExtractBool(
+        "document.getElementById(\"" + name + "\") != null");
+  }
+
+  // Helper to navigate to a given url.
+  void NavigateToURLAndWait(const GURL& url) {
+    content::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        content::Source<content::NavigationController>(
+            &browser()->tab_strip_model()->GetActiveWebContents()->
+                GetController()));
+
+    ui_test_utils::NavigateToURL(browser(), url);
+    observer.Wait();
+  }
+
   // This test needs to make live DNS requests for access to
   // GAIA and sync server URLs under google.com. We use a scoped version
   // to override the default resolver while the test is active.
   scoped_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_override_;
 
   bool no_cleanup_;
   bool no_install_;
   std::string chromoting_id_;
   base::FilePath webapp_crx_;
+  std::string username_;
+  std::string password_;
 };
 
 void RemoteDesktopBrowserTest::ParseCommandLine() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   // The test framework overrides any command line user-data-dir
   // argument with a /tmp/.org.chromium.Chromium.XXXXXX directory.
   // That happens in the ChromeTestLauncherDelegate, and affects
   // all unit tests (no opt out available). It intentionally erases
   // any --user-data-dir switch if present and appends a new one.
   // Re-override the default data dir if override-user-data-dir
   // is specified.
   if (command_line->HasSwitch(kOverrideUserDataDir)) {
     const base::FilePath& override_user_data_dir =
         command_line->GetSwitchValuePath(kOverrideUserDataDir);
 
     ASSERT_FALSE(override_user_data_dir.empty());
 
     command_line->AppendSwitchPath(switches::kUserDataDir,
                                    override_user_data_dir);
   }
 
+  username_ = command_line->GetSwitchValueNative(kUsername);
+  password_ = command_line->GetSwitchValueNative(kPassword);
+
   no_cleanup_ = command_line->HasSwitch(kNoCleanup);
   no_install_ = command_line->HasSwitch(kNoInstall);
 
   if (!no_install_) {
     webapp_crx_ = command_line->GetSwitchValuePath(kWebAppCrx);
     ASSERT_FALSE(webapp_crx_.empty());
   }
 }
 
 void RemoteDesktopBrowserTest::EnableDNSLookupForThisTest(
@@ skipping 11 matching lines @@
   resolver->AllowDirectLookup("*.googleapis.com");
   mock_host_resolver_override_.reset(
       new net::ScopedDefaultHostResolverProc(resolver.get()));
 }
 
 void RemoteDesktopBrowserTest::DisableDNSLookupForThisTest() {
   mock_host_resolver_override_.reset();
 }
 
 void RemoteDesktopBrowserTest::VerifyInternetAccess() {
-  content::WindowedNotificationObserver observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::Source<content::NavigationController>(
-          &browser()->tab_strip_model()->GetActiveWebContents()->
-              GetController()));
-
   GURL google_url("http://www.google.com");
-  ui_test_utils::NavigateToURL(browser(), google_url);
-  observer.Wait();
+  NavigateToURLAndWait(google_url);
 
   EXPECT_EQ(GetCurrentURL().host(), "www.google.com");
 }
 
 void RemoteDesktopBrowserTest::InstallChromotingApp() {
   base::FilePath install_dir(WebAppCrxPath());
   scoped_refptr<const Extension> extension(InstallExtensionWithUIAutoConfirm(
       install_dir, 1, browser()));
 
   EXPECT_FALSE(extension.get() == NULL);
 }
 
 void RemoteDesktopBrowserTest::UninstallChromotingApp() {
   UninstallExtension(ChromotingID());
   chromoting_id_.clear();
 }
 
 void RemoteDesktopBrowserTest::LaunchChromotingApp() {
   ASSERT_FALSE(ChromotingID().empty());
+
   std::string url = "chrome-extension://" + ChromotingID() + "/main.html";
   const GURL chromoting_main(url);
-
-  content::WindowedNotificationObserver observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::Source<content::NavigationController>(
-          &browser()->tab_strip_model()->GetActiveWebContents()->
-              GetController()));
-
-  ui_test_utils::NavigateToURL(browser(), chromoting_main);
-  observer.Wait();
+  NavigateToURLAndWait(chromoting_main);
 
   EXPECT_EQ(GetCurrentURL(), chromoting_main);
 }
 
 void RemoteDesktopBrowserTest::VerifyChromotingLoaded(bool expected) {
   const ExtensionSet* extensions = extension_service()->extensions();
   scoped_refptr<const extensions::Extension> extension;
   ExtensionSet::const_iterator iter;
   bool installed = false;
 
@@ skipping 21 matching lines @@
 }
 
 void RemoteDesktopBrowserTest::Authorize() {
   // The chromoting extension should be installed.
   ASSERT_FALSE(ChromotingID().empty());
 
   // The chromoting main page should be loaded in the current tab
   // and isAuthenticated() should be false (auth dialog visible).
   std::string url = "chrome-extension://" + ChromotingID() + "/main.html";
   ASSERT_EQ(GetCurrentURL().spec(), url);
+  ASSERT_FALSE(ExecuteScriptAndExtractBool(
+      "remoting.OAuth2.prototype.isAuthenticated()"));
 
-  bool result;
-  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      "window.domAutomationController.send("
-          "remoting.OAuth2.prototype.isAuthenticated());",
-      &result));
-  EXPECT_FALSE(result);
-
-  content::WindowedNotificationObserver observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::Source<content::NavigationController>(
-          &browser()->tab_strip_model()->GetActiveWebContents()->
-              GetController()));
-
-  ASSERT_TRUE(content::ExecuteScript(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      "remoting.OAuth2.prototype.doAuthRedirect()"));
-  observer.Wait();
+  ExecuteScriptAndWait("remoting.OAuth2.prototype.doAuthRedirect();");
 
   // Verify the active tab is at the "Google Accounts" login page.
   EXPECT_EQ(GetCurrentURL().host(), "accounts.google.com");
+  EXPECT_TRUE(HtmlElementExists("Email"));
+  EXPECT_TRUE(HtmlElementExists("Passwd"));
+}
 
-  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      "window.domAutomationController.send("
-          "document.getElementById(\"Email\") != null);",
-      &result));
-  EXPECT_TRUE(result);
+void RemoteDesktopBrowserTest::Authenticate() {
+  // The chromoting extension should be installed.
+  ASSERT_FALSE(ChromotingID().empty());
 
-  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      "window.domAutomationController.send("
-          "document.getElementById(\"Passwd\") != null);",
-      &result));
-  EXPECT_TRUE(result);
+  // The active tab should have the "Google Accounts" login page loaded.
+  ASSERT_EQ(GetCurrentURL().host(), "accounts.google.com");
+  ASSERT_TRUE(HtmlElementExists("Email"));
+  ASSERT_TRUE(HtmlElementExists("Passwd"));
+
+  // Now log in using the username and password passed in from the command line.
+  ExecuteScriptAndWait(
+      "document.getElementById(\"Email\").value = \"" + username_ + "\";" +
+      "document.getElementById(\"Passwd\").value = \"" + password_ +"\";" +
+      "document.forms[\"gaia_loginform\"].submit();");
+
+  EXPECT_EQ(GetCurrentURL().host(), "accounts.google.com");
+
+  // Is there a better way to verify we are on the "Request for Permission"

[garykac, 2013/08/09 17:29:05]

This sounds like it should have a TODO at the start of the comment.

+  // page?
+  EXPECT_TRUE(HtmlElementExists("submit_approve_access"));
 }
 
 IN_PROC_BROWSER_TEST_F(RemoteDesktopBrowserTest, MANUAL_Launch) {
   VerifyInternetAccess();
 
   if (!NoInstall()) {
     VerifyChromotingLoaded(false);
     InstallChromotingApp();
   }
 
@@ skipping 20 matching lines @@
     VerifyChromotingLoaded(false);
     InstallChromotingApp();
   }
 
   VerifyChromotingLoaded(true);
 
   LaunchChromotingApp();
 
   Authorize();
 
+  Authenticate();
+
   if (!NoCleanup()) {
     UninstallChromotingApp();
     VerifyChromotingLoaded(false);
   }
 }
 
 }  // namespace remoting