More Blimp browser tests for navigation

blimp/engine/browser_tests/engine_browsertest.cc

 // Copyright 2016 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/memory/ptr_util.h"
 #include "blimp/client/core/contents/ime_feature.h"
 #include "blimp/client/core/contents/mock_ime_feature_delegate.h"
 #include "blimp/client/core/contents/mock_navigation_feature_delegate.h"
 #include "blimp/client/core/contents/navigation_feature.h"
 #include "blimp/client/core/contents/tab_control_feature.h"
@@ skipping 10 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 
 using ::testing::InvokeWithoutArgs;
 
 namespace blimp {
 namespace {
 
 const int kDummyTabId = 0;
+const char kPage1Path[] = "/page1.html";
+const char kPage2Path[] = "/page2.html";
+const char kPage1Title[] = "page1";
+const char kPage2Title[] = "page2";
 
 // Uses a headless client session to test a full engine.
 class EngineBrowserTest : public BlimpBrowserTest {
  public:
   EngineBrowserTest() {}
 
  protected:
   void SetUpOnMainThread() override {
     BlimpBrowserTest::SetUpOnMainThread();
 
@@ skipping 43 matching lines @@
     // so allow more than one.
     EXPECT_CALL(client_nav_feature_delegate_,
                 OnLoadingChanged(kDummyTabId, true))
         .Times(testing::AtLeast(1));
     EXPECT_CALL(client_nav_feature_delegate_,
                 OnLoadingChanged(kDummyTabId, false))
         .WillOnce(
             InvokeWithoutArgs(this, &EngineBrowserTest::SignalCompletion));
   }
 
+  // Expect that the page load status won't change.
+  void ExpectNoPageLoad() {

[Kevin M, 2016/08/30 00:52:39]

Never called?

[Brian Goldman, 2016/08/30 01:01:32]

Oh whoops, this was a helper than turned out to be unhelpful. Deleted.

+    EXPECT_CALL(client_nav_feature_delegate_,
+                OnLoadingChanged(kDummyTabId, testing::_))
+        .Times(0);
+  }
+
   void RunAndVerify() {
     RunUntilCompletion();
     testing::Mock::VerifyAndClearExpectations(&client_rw_feature_delegate_);
     testing::Mock::VerifyAndClearExpectations(&client_nav_feature_delegate_);
   }
 
   client::MockNavigationFeatureDelegate client_nav_feature_delegate_;
   client::MockRenderWidgetFeatureDelegate client_rw_feature_delegate_;
   client::MockImeFeatureDelegate client_ime_feature_delegate_;
   std::unique_ptr<client::TestClientSession> client_session_;
   std::string last_page_title_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EngineBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(EngineBrowserTest, LoadUrl) {
   EXPECT_CALL(client_rw_feature_delegate_, OnRenderWidgetCreated(1));
   ExpectPageLoad();
-  NavigateToLocalUrl("/page1.html");
+  NavigateToLocalUrl(kPage1Path);
   RunAndVerify();
-  EXPECT_EQ("page1", last_page_title_);
+  EXPECT_EQ(kPage1Title, last_page_title_);
 }
 
-IN_PROC_BROWSER_TEST_F(EngineBrowserTest, GoBack) {
+IN_PROC_BROWSER_TEST_F(EngineBrowserTest, Reload) {
   ExpectPageLoad();
-  NavigateToLocalUrl("/page1.html");
+  NavigateToLocalUrl(kPage1Path);
   RunAndVerify();
-  EXPECT_EQ("page1", last_page_title_);
+  EXPECT_EQ(kPage1Title, last_page_title_);
 
   ExpectPageLoad();
-  NavigateToLocalUrl("/page2.html");
+  client_session_->GetNavigationFeature()->Reload(kDummyTabId);
   RunAndVerify();
-  EXPECT_EQ("page2", last_page_title_);
+  EXPECT_EQ(kPage1Title, last_page_title_);
+}
+
+IN_PROC_BROWSER_TEST_F(EngineBrowserTest, GoBackAndGoForward) {
+  ExpectPageLoad();
+  NavigateToLocalUrl(kPage1Path);
+  RunAndVerify();
+  EXPECT_EQ(kPage1Title, last_page_title_);
+
+  ExpectPageLoad();
+  NavigateToLocalUrl(kPage2Path);
+  RunAndVerify();
+  EXPECT_EQ(kPage2Title, last_page_title_);
 
   ExpectPageLoad();
   client_session_->GetNavigationFeature()->GoBack(kDummyTabId);
   RunAndVerify();
-  EXPECT_EQ("page1", last_page_title_);
+  EXPECT_EQ(kPage1Title, last_page_title_);
+
+  ExpectPageLoad();
+  client_session_->GetNavigationFeature()->GoForward(kDummyTabId);
+  RunAndVerify();
+  EXPECT_EQ(kPage2Title, last_page_title_);
+}
+
+IN_PROC_BROWSER_TEST_F(EngineBrowserTest, InvalidGoBack) {
+  // Try an invalid GoBack before loading a page, and assert that the page still
+  // loads correctly.
+  ExpectPageLoad();
+  client_session_->GetNavigationFeature()->GoBack(kDummyTabId);
+  NavigateToLocalUrl(kPage1Path);
+  RunAndVerify();
+  EXPECT_EQ(kPage1Title, last_page_title_);
+}
+
+IN_PROC_BROWSER_TEST_F(EngineBrowserTest, InvalidGoForward) {
+  ExpectPageLoad();
+  NavigateToLocalUrl(kPage1Path);
+  RunAndVerify();
+  EXPECT_EQ(kPage1Title, last_page_title_);
+
+  // Try an invalid GoForward before loading a different page, and
+  // assert that the page still loads correctly.
+  ExpectPageLoad();
+  client_session_->GetNavigationFeature()->GoForward(kDummyTabId);
+  NavigateToLocalUrl(kPage2Path);
+  RunAndVerify();
+  EXPECT_EQ(kPage2Title, last_page_title_);
 }
 
 }  // namespace
 }  // namespace blimp