Adding the first set of remote test cases and associated framework.

chrome/test/remoting/me2me_browsertest.cc

 // 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/files/file_path.h"
 #include "base/files/file_util.h"
+#include "chrome/test/remoting/key_code_test_map.h"
 #include "chrome/test/remoting/remote_desktop_browsertest.h"
+#include "chrome/test/remoting/remote_test_helper.h"
 #include "chrome/test/remoting/waiter.h"
 
 namespace remoting {
 
 class Me2MeBrowserTest : public RemoteDesktopBrowserTest {
  protected:
-  void TestKeyboardInput();
-  void TestMouseInput();
+  void TestKeypressInput(ui::KeyboardCode, const char*);
+  void TestMouseInput(blink::WebMouseEvent::Button);
 
   void ConnectPinlessAndCleanupPairings(bool cleanup_all);
   bool IsPairingSpinnerHidden();
+  void SetupForRemoteHostTest();
 };
 
 IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
                        MANUAL_Me2Me_Connect_Local_Host) {
   SetUpTestForMe2Me();
 
   ConnectToLocalHost(false);
 
   // TODO(chaitali): Change the mouse input test to also work in the
   // HTTP server framework
@@ skipping 17 matching lines @@
 
   // TODO(weitaosu): Find a way to verify keyboard input injection.
   // We cannot use TestKeyboardInput because it assumes
   // that the client and the host are on the same machine.
 
   DisconnectMe2Me();
   Cleanup();
 }
 
 IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
+                       MANUAL_Me2Me_Remote_Host_Keypress) {
+  SetupForRemoteHostTest();
+
+  // Test all key characters
+  int length = sizeof(test_key_map)/sizeof(KeyCodeTestMap);
+  for (int i = 0; i < length; i++) {
+    KeyCodeTestMap key = test_key_map[i];
+    TestKeypressInput(key.vkey_code, key.code);
+  }
+  DisconnectMe2Me();
+  Cleanup();
+}
+
+IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
+                       MANUAL_Me2Me_Remote_Host_Digitpress) {
+  SetupForRemoteHostTest();
+
+  // Test all digit characters
+  int length = sizeof(test_digit_map)/sizeof(KeyCodeTestMap);
+  for (int i = 0; i < length; i++) {
+    KeyCodeTestMap key = test_digit_map[i];
+    TestKeypressInput(key.vkey_code, key.code);
+  }
+  DisconnectMe2Me();
+  Cleanup();
+}
+
+IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
+                       MANUAL_Me2Me_Remote_Host_Specialpress) {
+  SetupForRemoteHostTest();
+
+  // Test all special characters
+  int length = sizeof(test_special_map)/sizeof(KeyCodeTestMap);
+  for (int i = 0; i < length; i++) {
+    KeyCodeTestMap key = test_special_map[i];
+    TestKeypressInput(key.vkey_code, key.code);
+  }
+  DisconnectMe2Me();
+  Cleanup();
+}
+
+IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
+                       MANUAL_Me2Me_Remote_Host_Numpadpress) {
+  SetupForRemoteHostTest();
+  SimulateKeyPressWithCode(ui::VKEY_SPACE, "Space", false, false, true, false);

[Jamie, 2014/12/17 03:15:40]

None of the other tests do this. Why is it needed here?

[Mike Meade, 2014/12/18 18:54:24]

Its left over from when I had to wake the machine up during testing. I actually
moved a wake up keystroke to SetupForRemoteHostTest() and forgot to remove it
here.

+  // Test all numpad characters
+  int length = sizeof(test_numpad_map)/sizeof(KeyCodeTestMap);
+  for (int i = 0; i < length; i++) {
+    KeyCodeTestMap key = test_numpad_map[i];
+    TestKeypressInput(key.vkey_code, key.code);
+  }
+  DisconnectMe2Me();
+  Cleanup();
+}
+
+IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
+                       MANUAL_Me2Me_Remote_Host_Mouseclick) {
+  SetupForRemoteHostTest();
+
+  TestMouseInput(blink::WebMouseEvent::ButtonLeft);
+  TestMouseInput(blink::WebMouseEvent::ButtonMiddle);
+  TestMouseInput(blink::WebMouseEvent::ButtonRight);
+  // Dismiss the context menu from the right button press.
+  // The button press that cancels the context menu is not captured by the
+  // javascript on the page. This ensures that the next run will be clean.

[Jamie, 2014/12/17 03:15:40]

Is this needed? Cleanup uninstalls the app, which I assume closes the tab and
the associated context menu.

[Mike Meade, 2014/12/18 18:54:24]

This is here for when the tests are run manually, which I understand will be the
first way to validate functionality while working on multi-machine
configurations. This way anyone running the test manually won't have the context
menu up for the next run.

[Jamie, 2014/12/18 21:31:44]

I still don't understand; whether it's run manually or automatically, the last
thing this test does is uninstall the app, so it seems redundant to close the
context menu explicitly. What happens if you remove this?

[Mike Meade, 2015/01/05 23:18:58]

The context menu is opened in Chrome on a remote host machine and the test
cannot currently uninstall the app between runs. Once multi-machine support is
added to Omnibot this won't be a problem, but until then we will have a
persistent state between runs to worry about.

+  SimulateMouseLeftClickAt(100, 100);
+  DisconnectMe2Me();
+  Cleanup();
+}
+
+IN_PROC_BROWSER_TEST_F(Me2MeBrowserTest,
                        MANUAL_Me2Me_Connect_Pinless) {
   SetUpTestForMe2Me();
 
   ASSERT_FALSE(HtmlElementVisible("paired-client-manager-message"))
       << "The host must have no pairings before running the pinless test.";
 
   // Test that cleanup works with either the Delete or Delete all buttons.
   ConnectPinlessAndCleanupPairings(false);
   ConnectPinlessAndCleanupPairings(true);
 
   Cleanup();
 }
 
-void Me2MeBrowserTest::TestKeyboardInput() {
-  // We will assume here that the browser window is already open on the host
-  // and in focus.
-  // Press tab to put focus on the textbox.
-  SimulateKeyPressWithCode(ui::VKEY_TAB, "Tab", false, false, false, false);
+void Me2MeBrowserTest::SetupForRemoteHostTest() {
+  VerifyInternetAccess();
+  OpenClientBrowserPage();
+  Install();
+  LaunchChromotingApp();
 
-  // Write some text in the box and press enter
-  std::string text = "Abigail";
-  SimulateStringInput(text);
-  SimulateKeyPressWithCode(
-      ui::VKEY_RETURN, "Enter", false, false, false, false);
+  // Authorize, Authenticate, and Approve.
+  Auth();
+  ExpandMe2Me();
+  ConnectToRemoteHost(remote_host_name(), false);
 
-  // Wait until the client tab sets the right variables
-  ConditionalTimeoutWaiter waiter(
-          base::TimeDelta::FromSeconds(10),
-          base::TimeDelta::FromMilliseconds(500),
-          base::Bind(&RemoteDesktopBrowserTest::IsHostActionComplete,
-                     client_web_content(),
-                     "testResult.keypressSucceeded"));
-  EXPECT_TRUE(waiter.Wait());
-
-  // Check that the text we got is correct
-  EXPECT_TRUE(ExecuteScriptAndExtractBool(
-      client_web_content(),
-      "testResult.keypressText == '" + text + "'"));
+  // Wake up the machine if its sleeping

[Jamie, 2014/12/17 03:15:40]

nit: s/its/it's/

I have concerns about this step. If the machine is asleep then you need some
sort of wait, since it will take some take to awaken. If it's not asleep, then
this is an additional keyboard event that tests may need to account for (though,
if you're only reporting the most recent, it should be fine).

[Mike Meade, 2014/12/18 18:54:24]

Done.

[Jamie, 2014/12/18 21:31:44]

Can you address my concerns about what this means in terms of timing and the
additional keypress?

[Mike Meade, 2015/01/05 23:18:58]

There are 3 things here
1) The server only tracks the last event that was received
2) The first thing each test does is a reset on the server to remove any old
event. This way we can detect when an event wasn't received, even after
verifying multiple events were received.
3) This was only added because I found when running the tests manually that the
Chrome page may not get the first event if I hadn't run a test for a while. It
seemed to me to need a "wake up" event after a while.

[Jamie, 2015/01/06 19:31:38]

Okay, in that case, please remove the reference to "sleeping" in the comment, as
I think it's misleading (I thought you were referring to the OS-level sleep
functionality). Ideally, we should find out what's going on here, otherwise we
could end up with a bug whereby the first event of every session is lost, and
we'd never know. This is better than nothing, but please add a TODO to
investigate the underlying issue.

+  SimulateKeyPressWithCode(ui::VKEY_RETURN, "Enter");
 }
 
-void Me2MeBrowserTest::TestMouseInput() {
-  SimulateMouseLeftClickAt(10, 50);
-  // TODO: Verify programatically the mouse events are received by the host.
-  // This will be tricky as it depends on the host OS, window manager, desktop
-  // layout, and screen resolution. Until then we need to visually verify that
-  // "Dash Home" is clicked on a Unity window manager.
-  ASSERT_TRUE(TimeoutWaiter(base::TimeDelta::FromSeconds(5)).Wait());
+void Me2MeBrowserTest::TestKeypressInput(
+    ui::KeyboardCode keyCode,
+    const char* code) {
+  remote_test_helper().ClearLastEvent();
+  LOG(INFO) << "Pressing " << code;

[Jamie, 2014/12/17 03:15:40]

Given that we test all keys, this log will be very spammy. I suggest VLOG
instead.

[Mike Meade, 2014/12/18 18:54:24]

Done.

+  SimulateKeyPressWithCode(keyCode, code);
+  Event event;
+  remote_test_helper().GetLastEvent(event);
+  ASSERT_EQ(Action::KEYDOWN, event.action);
+  ASSERT_EQ(keyCode, event.value);
+}
+
+void Me2MeBrowserTest::TestMouseInput(
+    blink::WebMouseEvent::Button button) {
+  remote_test_helper().ClearLastEvent();
+  // Offset the clicks to account for the context menu that appears on a
+  // right click;

[Jamie, 2014/12/17 03:15:40]

I don't understand why the context menu affects where the click should occur.

Also, comments don't need to end in a semi-colon :)

[Jamie, 2014/12/18 21:31:44]

You haven't addressed this comment.

[Mike Meade, 2015/01/05 23:18:58]

I removed this code until we could make it a bit more robust with more
information on the events raised on the remote machine. However, to address your
question, when run manually these tests are run on a persistent, remote machine.
When the context menu is raised its possible for any following events to be
raised in the context menu frame as opposed to the web frame. I offset this key
so that a left or middle click in the standard position would dismiss the
context menu instead of being captured by it.

+  int offset = 0;
+  switch (button) {
+    case blink::WebMouseEvent::ButtonLeft:
+      LOG(INFO) << "Clicking left mouse button";

[Jamie, 2014/12/17 03:15:40]

This should probably also be a VLOG, although it will not be as spammy.

[Mike Meade, 2014/12/18 18:54:24]

Done.

+      break;
+    case blink::WebMouseEvent::ButtonMiddle:
+      LOG(INFO) << "Clicking middle mouse button";
+      break;
+    case blink::WebMouseEvent::ButtonRight:
+      LOG(INFO) << "Clicking right mouse button";
+      offset = 100;
+      break;
+    default:
+      LOG(ERROR) << "The indicated button " << button << "is not valid";
+  }
+  SimulateMouseClickAt(0, button, 100 + offset, 100 + offset);
+  Event event;
+  remote_test_helper().GetLastEvent(event);
+  ASSERT_EQ(Action::BUTTONPRESS, event.action);
+  ASSERT_EQ(button, event.value);

[Jamie, 2014/12/17 03:15:40]

Can we also verify the location somehow? If that makes the test substantially
more complex, consider moving the mouse test into a separate CL.

[Jamie, 2014/12/18 21:31:44]

You haven't addressed this comment.

[Mike Meade, 2015/01/05 23:18:58]

I removed this test for now. It seems to deserve its own cl.

 }
 
 void Me2MeBrowserTest::ConnectPinlessAndCleanupPairings(bool cleanup_all) {
   // First connection: verify that a PIN is requested, and request pairing.
   ConnectToLocalHost(true);
   DisconnectMe2Me();
 
   // TODO(jamiewalch): This reload is only needed because there's a bug in the
   // web-app whereby it doesn't refresh its pairing state correctly.
   // http://crbug.com/311290
@@ skipping 31 matching lines @@
   ClickOnControl("close-paired-client-manager-dialog");
   ASSERT_FALSE(HtmlElementVisible("paired-client-manager-dialog"));
   ASSERT_FALSE(HtmlElementVisible("paired-client-manager-message"));
 }
 
 bool Me2MeBrowserTest::IsPairingSpinnerHidden() {
   return !HtmlElementVisible("paired-client-manager-dialog-working");
 }
 
 }  // namespace remoting