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";
+// Test Server scheme.
+const char kHTTPScheme[] = "http://";

[Eugene But (OOO till 7-30), 2017/02/14 21:44:43]

kHttpScheme

[michaeldo, 2017/02/15 00:56:34]

Done.

 
-// URL for the server to print the HTTP method and the request body.
-const char kPrintFormDataUrl[] = "http://printFormData";
+// Test server domain.
+const char kHttpServerDomain[] = "localhost";

[Eugene But (OOO till 7-30), 2017/02/14 21:44:43]

nit: kHttpServerHost ?

[michaeldo, 2017/02/15 00:56:34]

Done.

 
-// URL for the server that redirects to kPrintPostData with a 302.
-const char kRedirectUrl[] = "http://redirect";
+// Path for a generic website in the user navigation flow.
+const char kGenericPath[] = "/generic/";
 
-// URL for the server to return a page that posts a form with some data to
-// |kPrintPostData|.
-const char kFormUrl[] = "http://formURL";
+// Path for the server to print the HTTP method and the request body.
+const char kPrintFormDataPath[] = "/printformdata/";
 
-// URL for the server to return a page that posts to |kRedirect|.
-const char kRedirectFormUrl[] = "http://redirectFormURL";
+// Path for the server that redirects to |kPrintFormDataPath| with a 302.
+const char kRedirectPath[] = "/redirect/";
+
+// Path for the server to return a page that posts a form with some data to
+// |kPrintFormDataPath|.
+const char kFormPath[] = "/form/";
+
+// Path for the server to return a page that posts to |kRedirectPath|.
+const char kRedirectFormPath[] = "/redirectform/";
 
 // 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:
+  // 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.host() == kHttpServerDomain &&
+         (url.path() == kFormPath || url.path() == kRedirectFormPath ||
+          url.path() == kRedirectPath || url.path() == kPrintFormDataPath);
+}
+
+void TestResponseProvider::GetResponseHeadersAndBody(
+    const Request& request,
+    scoped_refptr<net::HttpResponseHeaders>* headers,
+    std::string* response_body) {
+  GURL printFormDataUrl = web::test::HttpServer::MakeUrl(

[Eugene But (OOO till 7-30), 2017/02/14 21:44:43]

print_form_data_url

[michaeldo, 2017/02/15 00:56:34]

Done.

+      std::string(kHTTPScheme) + kPrintFormDataPath);

[Eugene But (OOO till 7-30), 2017/02/14 21:44:43]

How about using url::SchemeHostPort instead of strings concatenation?

[michaeldo, 2017/02/15 00:56:34]

I agree that url::SchemeHostPort is more ideal, but it seems too fragile to add
one call to it here. IMO all MakeUrl calls would need to be migrated at once as
the constants would need to be modified to work with it. For example,
url::SchemeHostPort expects no "://" with the scheme and no slashes on the path.
With the current constants, url::SchemeHostPort simply returns an invalid GURL.
Please let me know if you'd like me to make the change still and I can do it in
a followup CL or maybe even more ideal add a web::test::HttpServer::SchemeHost
method? This would remove the need to ask the server singleton for the port
number.

[Eugene But (OOO till 7-30), 2017/02/15 01:28:04]

I suggested to use url::SchemeHostPort to avoid strings concatenations for URLs.
But adding static methods which return URLs looks like a better direction.

+
+  const GURL& url = request.url;
+  if (url.path() == kRedirectPath) {
+    *headers = web::ResponseProvider::GetRedirectResponseHeaders(
+        printFormDataUrl.spec(), net::HTTP_FOUND);
+    return;
+  }
+
+  const char* formHtml =

[Eugene But (OOO till 7-30), 2017/02/14 21:44:43]

form_html

[michaeldo, 2017/02/15 00:56:34]

Done.

+      "<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.path() == kFormPath) {
+    *response_body =
+        base::StringPrintf(formHtml, printFormDataUrl.spec().c_str(),
+                           kSubmitButton, kSubmitButton);
+    return;
+  } else if (url.path() == kRedirectFormPath) {
+    *response_body = base::StringPrintf(
+        formHtml,
+        web::test::HttpServer::MakeUrl(std::string(kHTTPScheme) + kRedirectPath)
+            .spec()
+            .c_str(),
+        kSubmitButton, kSubmitButton);
+    return;
+  } else if (url.path() == kPrintFormDataPath) {
+    *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 = web::test::HttpServer::MakeUrl(std::string(kHTTPScheme) +

[Eugene But (OOO till 7-30), 2017/02/14 21:44:43]

Optional nit: Do you want to create TestResponseProvider::GetPrintFormURL()
static function and use it here and inside TestResponseProvider?

[michaeldo, 2017/02/15 00:56:34]

Done. This was a great cleanup point so I similarly did it with
TestResponseProvider::GetFormURL()

+                                            kPrintFormDataPath);
   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:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kFormPath)];
 
   [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:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kFormPath)];
 
   [self submitForm];
 
   // Go to a new page.
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kGenericUrl)];
+  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kGenericPath)];
 
   // 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:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kFormPath)];
   [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:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kFormPath)];
   [self submitForm];
 
   // Go to a new page.
-  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kGenericUrl)];
+  [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kGenericPath)];
 
   [self openBackHistory];
   [self waitForTabHistoryView];
 
-  const GURL printURL = web::test::HttpServer::MakeUrl(kPrintFormDataUrl);
+  const GURL printURL = web::test::HttpServer::MakeUrl(
+      std::string(kHTTPScheme) + kPrintFormDataPath);
   id<GREYMatcher> historyItem =
       grey_text(base::SysUTF8ToNSString(printURL.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:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kFormPath)];
   [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:web::test::HttpServer::MakeUrl(
+                              std::string(kHTTPScheme) + kRedirectFormPath)];
   // 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