Verify FormsTestCase forms submission result.

ios/chrome/browser/web/forms_egtest.mm

 // 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.
 
 #import <XCTest/XCTest.h>
 
 #include "base/mac/scoped_nsobject.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/strings/grit/components_strings.h"
 #import "ios/chrome/browser/ui/commands/generic_chrome_command.h"
 #include "ios/chrome/browser/ui/commands/ios_command_ids.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/chrome/test/app/chrome_test_util.h"
 #include "ios/chrome/test/app/navigation_test_util.h"
 #include "ios/chrome/test/app/web_view_interaction_test_util.h"
 #import "ios/chrome/test/earl_grey/chrome_earl_grey.h"
 #import "ios/chrome/test/earl_grey/chrome_matchers.h"
 #import "ios/chrome/test/earl_grey/chrome_test_case.h"
 #import "ios/testing/wait_util.h"
 #import "ios/web/public/test/http_server.h"
 #import "ios/web/public/test/http_server_util.h"
-#include "ios/web/public/test/response_providers/html_response_provider.h"
-#include "ios/web/public/test/response_providers/html_response_provider_impl.h"
+#include "ios/web/public/test/response_providers/data_response_provider.h"
 
 namespace {
 
 // URL for a generic website in the user navigation flow.
 const char kGenericUrl[] = "http://generic";
 
-// URL for the server to print the HTTP method and the request body.
+// URL to print the HTTP method and the request body.
 const char kPrintFormDataUrl[] = "http://printFormData";
 
-// URL for the server that redirects to kPrintPostData with a 302.
+// URL that redirects to kPrintPostData with a 302.
 const char kRedirectUrl[] = "http://redirect";
 
-// URL for the server to return a page that posts a form with some data to
+// URL to return a page that posts a form with some data to
 // |kPrintPostData|.
 const char kFormUrl[] = "http://formURL";
 
-// URL for the server to return a page that posts to |kRedirect|.
+// URL to return a page that posts to |kRedirect|.
 const char kRedirectFormUrl[] = "http://redirectFormURL";
 
 // Label for the button in the form.
 const char kSubmitButton[] = "Submit";
 
 // Expected response from the server.
 const char kExpectedPostData[] = "POST Data=Unicorn";
 
+#pragma mark - TestResponseProvider
+
+// A ResponseProvider that provides html response or a redirect.
+class TestResponseProvider : public web::DataResponseProvider {
+ public:
+  // URL for the server at |kGenericUrl|.
+  static GURL GetGenericUrl() {
+    return web::test::HttpServer::MakeUrl(kGenericUrl);
+  }
+  // URL for the server at |kPrintFormDataUrl|.
+  static GURL GetPrintFormDataUrl() {
+    return web::test::HttpServer::MakeUrl(kPrintFormDataUrl);
+  }
+  // URL for the server at |kRedirectUrl|.
+  static GURL GetRedirectUrl() {
+    return web::test::HttpServer::MakeUrl(kRedirectUrl);
+  }
+  // URL for the server at |kFormUrl|.
+  static GURL GetFormUrl() { return web::test::HttpServer::MakeUrl(kFormUrl); }
+  // URL for the server at |kRedirectFormUrl|.
+  static GURL GetRedirectFormUrl() {
+    return web::test::HttpServer::MakeUrl(kRedirectFormUrl);
+  }
+  // TestResponseProvider implementation.
+  bool CanHandleRequest(const Request& request) override;
+  void GetResponseHeadersAndBody(
+      const Request& request,
+      scoped_refptr<net::HttpResponseHeaders>* headers,
+      std::string* response_body) override;
+};
+
+bool TestResponseProvider::CanHandleRequest(const Request& request) {
+  const GURL& url = request.url;
+  return url == TestResponseProvider::GetPrintFormDataUrl() ||
+         url == TestResponseProvider::GetRedirectUrl() ||
+         url == TestResponseProvider::GetFormUrl() ||
+         url == TestResponseProvider::GetRedirectFormUrl();
+}
+
+void TestResponseProvider::GetResponseHeadersAndBody(
+    const Request& request,
+    scoped_refptr<net::HttpResponseHeaders>* headers,
+    std::string* response_body) {
+  const GURL& url = request.url;
+  if (url == TestResponseProvider::GetRedirectUrl()) {
+    *headers = web::ResponseProvider::GetRedirectResponseHeaders(
+        TestResponseProvider::GetPrintFormDataUrl().spec(), net::HTTP_FOUND);
+    return;
+  }
+
+  const char* form_html =
+      "<form method=\"post\" action=\"%s\">"
+      "<textarea rows=\"1\" name=\"Data\">Unicorn</textarea>"
+      "<input type=\"submit\" value=\"%s\" id=\"%s\">"
+      "</form>";
+
+  *headers = web::ResponseProvider::GetDefaultResponseHeaders();
+  if (url == TestResponseProvider::GetFormUrl()) {
+    *response_body = base::StringPrintf(
+        form_html, TestResponseProvider::GetPrintFormDataUrl().spec().c_str(),
+        kSubmitButton, kSubmitButton);
+    return;
+  } else if (url == TestResponseProvider::GetRedirectFormUrl()) {
+    *response_body = base::StringPrintf(
+        form_html, TestResponseProvider::GetRedirectUrl().spec().c_str(),
+        kSubmitButton, kSubmitButton);
+    return;
+  } else if (url == TestResponseProvider::GetPrintFormDataUrl()) {
+    *response_body = request.method + std::string(" ") + request.body;
+    return;
+  }
+  NOTREACHED();
+}
+
 }  // namespace
 
 // Tests submition of HTTP forms POST data including cases involving navigation.
 @interface FormsTestCase : ChromeTestCase
 @end
 
 @implementation FormsTestCase
 
 // Sets up server urls and responses.
 - (void)setUp {
   [super setUp];
-  std::map<GURL, HtmlResponseProviderImpl::Response> responses;
 
-  const char* formHtml =
-      "<form method=\"post\" action=\"%s\">"
-      "<textarea rows=\"1\" name=\"Data\">Unicorn</textarea>"
-      "<input type=\"submit\" value=\"%s\" id=\"%s\">"
-      "</form>";
-  GURL printFormDataUrl = web::test::HttpServer::MakeUrl(kPrintFormDataUrl);
-
-  const GURL formUrl = web::test::HttpServer::MakeUrl(kFormUrl);
-  responses[formUrl] = HtmlResponseProviderImpl::GetSimpleResponse(
-      base::StringPrintf(formHtml, printFormDataUrl.spec().c_str(),
-                         kSubmitButton, kSubmitButton));
-
-  const GURL redirectFormUrl = web::test::HttpServer::MakeUrl(kRedirectFormUrl);
-  const std::string redirectFormResponse = base::StringPrintf(
-      formHtml, web::test::HttpServer::MakeUrl(kRedirectUrl).spec().c_str(),
-      kSubmitButton, kSubmitButton);
-  responses[redirectFormUrl] =
-      HtmlResponseProviderImpl::GetSimpleResponse(redirectFormResponse);
-
-  const GURL redirectUrl = web::test::HttpServer::MakeUrl(kRedirectUrl);
-  responses[redirectUrl] = HtmlResponseProviderImpl::GetRedirectResponse(
-      printFormDataUrl, net::HTTP_FOUND);
-
-  std::unique_ptr<web::DataResponseProvider> provider(
-      new HtmlResponseProvider(responses));
-  web::test::SetUpHttpServer(std::move(provider));
+  web::test::SetUpHttpServer(base::MakeUnique<TestResponseProvider>());
 }
 
 // Submits the html form and verifies the destination url.
 - (void)submitForm {
   chrome_test_util::TapWebViewElementWithId(kSubmitButton);
 
-  GURL url = web::test::HttpServer::MakeUrl(kPrintFormDataUrl);
+  GURL url = TestResponseProvider::GetPrintFormDataUrl();
   id<GREYMatcher> URLMatcher = chrome_test_util::OmniboxText(url.GetContent());
   [[EarlGrey selectElementWithMatcher:URLMatcher]
       assertWithMatcher:grey_notNil()];
 }
 
 // Waits for the |expectedResponse| within the web view.
 - (void)waitForExpectedResponse:(std::string)expectedResponse {
-  [[GREYCondition
+  GREYCondition* condition = [GREYCondition
       conditionWithName:@"Waiting for webview to display resulting text."
                   block:^BOOL {
                     id<GREYMatcher> webViewMatcher =
                         chrome_test_util::WebViewContainingText(
                             expectedResponse);
                     NSError* error = nil;
                     [[EarlGrey selectElementWithMatcher:webViewMatcher]
                         assertWithMatcher:grey_notNil()
                                     error:&error];
                     return error == nil;
-                  }] waitWithTimeout:5];
+                  }];
+  GREYAssert([condition waitWithTimeout:5], @"Webview text was not displayed.");
 }
 
 // Waits for view with Tab History accessibility ID.
 - (void)waitForTabHistoryView {
-  [[GREYCondition conditionWithName:@"Waiting for Tab History to display."
-                              block:^BOOL {
-                                NSError* error = nil;
-                                id<GREYMatcher> tabHistory =
-                                    grey_accessibilityID(@"Tab History");
-                                [[EarlGrey selectElementWithMatcher:tabHistory]
-                                    assertWithMatcher:grey_notNil()
-                                                error:&error];
-                                return error == nil;
-                              }] waitWithTimeout:5];
+  GREYCondition* condition = [GREYCondition
+      conditionWithName:@"Waiting for Tab History to display."
+                  block:^BOOL {
+                    NSError* error = nil;
+                    id<GREYMatcher> tabHistory =
+                        grey_accessibilityID(@"Tab History");
+                    [[EarlGrey selectElementWithMatcher:tabHistory]
+                        assertWithMatcher:grey_notNil()
+                                    error:&error];
+                    return error == nil;
+                  }];
+  GREYAssert([condition waitWithTimeout:5], @"Tab History View not displayed.");
 }
 
 // Reloads the web view and waits for the loading to complete.
 // TODO(crbug.com/638674): Evaluate if this can move to shared code
 - (void)reloadPage {
   base::scoped_nsobject<GenericChromeCommand> reloadCommand(
       [[GenericChromeCommand alloc] initWithTag:IDC_RELOAD]);
   chrome_test_util::RunCommandWithActiveViewController(reloadCommand);
 
   [ChromeEarlGrey waitForPageToFinishLoading];
@@ skipping 28 matching lines @@
 - (void)confirmResendWarning {
   id<GREYMatcher> resendWarning =
       chrome_test_util::ButtonWithAccessibilityLabelId(
           IDS_HTTP_POST_WARNING_RESEND);
   [[EarlGrey selectElementWithMatcher:resendWarning]
       performAction:grey_longPress()];
 }
 
 // Tests whether the request data is reposted correctly.
 - (void)testRepostForm {
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kFormUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetFormUrl()];
 
   [self submitForm];
   [self waitForExpectedResponse:kExpectedPostData];
 
   [self reloadPage];
   [self confirmResendWarning];
 
   [self waitForExpectedResponse:kExpectedPostData];
 }
 
 // Tests that a POST followed by navigating to a new page and then tapping back
 // to the form result page resends data.
 - (void)testRepostFormAfterTappingBack {
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kFormUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetFormUrl()];
 
   [self submitForm];
 
   // Go to a new page.
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kGenericUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetGenericUrl()];
 
   // Go back and check that the data is reposted.
   [self goBack];
   [self confirmResendWarning];
   [self waitForExpectedResponse:kExpectedPostData];
 }
 
 // Tests that a POST followed by tapping back to the form page and then tapping
 // forward to the result page resends data.
 - (void)testRepostFormAfterTappingBackAndForward {
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kFormUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetFormUrl()];
   [self submitForm];
 
   [self goBack];
   [self goForward];
   [self confirmResendWarning];
   [self waitForExpectedResponse:kExpectedPostData];
 }
 
 // Tests that a POST followed by a new request and then index navigation to get
 // back to the result page resends data.
 - (void)testRepostFormAfterIndexNavigation {
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kFormUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetFormUrl()];
   [self submitForm];
 
   // Go to a new page.
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kGenericUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetGenericUrl()];
 
   [self openBackHistory];
   [self waitForTabHistoryView];
 
-  const GURL printURL = web::test::HttpServer::MakeUrl(kPrintFormDataUrl);
-  id<GREYMatcher> historyItem =
-      grey_text(base::SysUTF8ToNSString(printURL.spec()));
+  id<GREYMatcher> historyItem = grey_text(base::SysUTF8ToNSString(
+      TestResponseProvider::GetPrintFormDataUrl().spec()));
   [[EarlGrey selectElementWithMatcher:historyItem] performAction:grey_tap()];
 
   [ChromeEarlGrey waitForPageToFinishLoading];
 
   [self confirmResendWarning];
   [self waitForExpectedResponse:kExpectedPostData];
 }
 
 // When data is not re-sent, the request is done with a GET method.
 - (void)testRepostFormCancelling {
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kFormUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetFormUrl()];
   [self submitForm];
 
   [self reloadPage];
 
   // Abort the reload.
   if (IsIPadIdiom()) {
     // On tablet, dismiss the popover.
     base::scoped_nsobject<GREYElementMatcherBlock> matcher([
         [GREYElementMatcherBlock alloc]
         initWithMatchesBlock:^BOOL(UIView* view) {
           return [NSStringFromClass([view class]) hasPrefix:@"UIDimmingView"];
         }
         descriptionBlock:^(id<GREYDescription> description) {
           [description appendText:@"class prefixed with UIDimmingView"];
         }]);
     [[EarlGrey selectElementWithMatcher:matcher]
         performAction:grey_tapAtPoint(CGPointMake(50.0f, 50.0f))];
   } else {
     // On handset, dismiss via the cancel button.
     [[EarlGrey selectElementWithMatcher:chrome_test_util::CancelButton()]
         performAction:grey_tap()];
   }
   // Check that the POST is changed to a GET
   [self waitForExpectedResponse:"GET"];
 }
 
 // Tests that a POST followed by a redirect does not show the popup.
 - (void)testRepostFormCancellingAfterRedirect {
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kRedirectFormUrl)];
+  [ChromeEarlGrey loadURL:TestResponseProvider::GetRedirectFormUrl()];
   // Submit the form, which redirects before printing the data.
   [self submitForm];
   // Check that the redirect changes the POST to a GET.
   [self waitForExpectedResponse:"GET"];
   [self reloadPage];
 
   // Check that the popup did not show
   id<GREYMatcher> resendWarning =
       chrome_test_util::ButtonWithAccessibilityLabelId(
           IDS_HTTP_POST_WARNING_RESEND);
   [[EarlGrey selectElementWithMatcher:resendWarning]
       assertWithMatcher:grey_nil()];
 
   [self waitForExpectedResponse:"GET"];
 }
 
 @end