Refactor Assert[No]CookieExists to return a boolean

ios/chrome/browser/net/cookies_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.
 
 #include <map>
 #include <memory>
 #include <string>
 
 #import <EarlGrey/EarlGrey.h>
 #import <XCTest/XCTest.h>
@@ skipping 11 matching lines @@
 #include "url/gurl.h"
 
 namespace {
 
 const char kTestUrlNormalBrowsing[] = "http://choux/normal/browsing";
 const char kTestUrlNormalSetCookie[] = "http://choux/normal/set_cookie";
 const char kTestUrlIncognitoBrowsing[] = "http://choux/incognito/browsing";
 const char kTestUrlIncognitoSetCookie[] = "http://choux/incognito/set_cookie";
 
 const char kTestResponse[] = "fleur";
-NSString* const kNoCookieText = @"No cookies!";
-NSString* const kNormalCookieKey = @"request";
+NSString* const kNormalCookieName = @"request";
 NSString* const kNormalCookieValue = @"pony";
-NSString* const kIncognitoCookieKey = @"secret";
+NSString* const kIncognitoCookieName = @"secret";
 NSString* const kIncognitoCookieValue = @"rainbow";
 
-NSString* const kGetCookieScript =
-    @"var c = document.cookie ? document.cookie.split(/;\\s*/) : [];"
-     "if (!c.length) {"
-     "  document.documentElement.innerHTML = 'No cookies!';"
-     "} else {"
-     "  document.documentElement.innerHTML = 'OK: ' + c.join(',');"
-     "}";
-
-// Checks that a cookie of key=value is the only cookie exists in current domain
-// in current web state.
-// Returns true if cookie |key| of value |value| is the only cookie that exists.
-bool CheckCookieExists(NSString* key, NSString* value) {
-  NSError* error = nil;
-  id result = chrome_test_util::ExecuteJavaScript(kGetCookieScript, &error);
-  if (error)
-    return false;
-  NSString* stringResult = base::mac::ObjCCastStrict<NSString>(result);
-  NSString* expectedText = [NSString stringWithFormat:@"OK: %@=%@", key, value];
-  return [stringResult isEqualToString:expectedText];
-}
-
-// Checks that there is no cookie in current domain in current web state.
-bool CheckNoCookieExists() {
-  NSError* error = nil;
-  id result = chrome_test_util::ExecuteJavaScript(kGetCookieScript, &error);
-  if (error)
-    return false;
-  NSString* stringResult = base::mac::ObjCCastStrict<NSString>(result);
-  return [stringResult isEqualToString:kNoCookieText];
-}
-
 }  // namespace
 
 @interface CookiesTestCase : ChromeTestCase
 @end
 
 @implementation CookiesTestCase
 
 #pragma mark - Overrides superclass
 
 + (void)setUp {
   [super setUp];
   // Creates a map of canned responses and set up the test HTML server.
   // |kTestUrlNormalSetCookie| and |kTestUrlIncognitoSetCookie| always sets
   // cookie in response header while |kTestUrlNormalBrowsing| and
   // |kTestUrlIncognitoBrowsing| doesn't.
   std::map<GURL, std::pair<std::string, std::string>> responses;
 
   NSString* normalCookie = [NSString
-      stringWithFormat:@"%@=%@", kNormalCookieKey, kNormalCookieValue];
+      stringWithFormat:@"%@=%@", kNormalCookieName, kNormalCookieValue];
   NSString* incognitoCookie = [NSString
-      stringWithFormat:@"%@=%@", kIncognitoCookieKey, kIncognitoCookieValue];
+      stringWithFormat:@"%@=%@", kIncognitoCookieName, kIncognitoCookieValue];
 
   responses[web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)] =
       std::pair<std::string, std::string>("", kTestResponse);
   responses[web::test::HttpServer::MakeUrl(kTestUrlNormalSetCookie)] =
       std::pair<std::string, std::string>(base::SysNSStringToUTF8(normalCookie),
                                           kTestResponse);
   responses[web::test::HttpServer::MakeUrl(kTestUrlIncognitoBrowsing)] =
       std::pair<std::string, std::string>("", kTestResponse);
   responses[web::test::HttpServer::MakeUrl(kTestUrlIncognitoSetCookie)] =
       std::pair<std::string, std::string>(
@@ skipping 25 matching lines @@
 // Tests toggling between Normal tabs and Incognito tabs. Different cookies
 // (request=pony for normal tabs, secret=rainbow for incognito tabs) are set.
 // The goal is to verify that cookies set in incognito tabs are available in
 // incognito tabs but not available in normal tabs. Cookies set in incognito
 // tabs are also deleted when all incognito tabs are closed.
 - (void)testClearIncognitoFromMain {
   // Loads a dummy page in normal tab. Sets a normal test cookie. Verifies that
   // the incognito test cookie is not found.
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Failed to set normal cookie in normal mode. (1)");
-  GREYAssertFalse(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                  @"Incognito cookie should not be found in normal mode. (1)");
+  NSDictionary* cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kNormalCookieValue, cookies[kNormalCookieName],
+                         @"Failed to set normal cookie in normal mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in normal mode.");
 
   // Opens an incognito tab, loads the dummy page, and sets incognito test
   // cookie.
   chrome_test_util::OpenNewIncognitoTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                 @"Failed to set incognito cookie in incognito mode. (2)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kIncognitoCookieValue, cookies[kIncognitoCookieName],
+                         @"Failed to set incognito cookie in incognito mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in incognito mode.");
 
   // Switches back to normal profile by opening up a new tab. Test cookie
   // should not be found.
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Normal cookie should be found in normal mode. (3)");
-  GREYAssertFalse(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                  @"Incognito cookie should not be found in normal mode. (3)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kNormalCookieValue, cookies[kNormalCookieName],
+                         @"Normal cookie should still exist in normal mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in normal mode.");
 
   // Finally, closes all incognito tabs while still in normal tab.
   // Checks that incognito cookie is gone.
   chrome_test_util::CloseAllIncognitoTabs();
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey
-      loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Normal cookie should be found in normal mode. (4)");
-  GREYAssertFalse(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                  @"Incognito cookie should be gone from normal mode. (4)");
+      loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoBrowsing)];
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqual(0U, cookies.count,
+                  @"Incognito cookie should be gone from normal mode.");
 }
 
 // Tests that a cookie set in incognito tab is removed after closing all
 // incognito tabs and then when new incognito tab is created the cookie will
 // not reappear.
 - (void)testClearIncognitoFromIncognito {
   // Loads a page in normal tab.
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
 
   // Opens an incognito tab, loads a page, and sets an incognito cookie.
   chrome_test_util::OpenNewIncognitoTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                 @"Failed to set incognito cookie in incognito mode. (1)");
+  NSDictionary* cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kIncognitoCookieValue, cookies[kIncognitoCookieName],
+                         @"Failed to set incognito cookie in incognito mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in incognito mode.");
 
   // Closes all incognito tabs and switch back to a normal tab.
   chrome_test_util::CloseAllIncognitoTabs();
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
 
   // Opens a new incognito tab and verify that the previously set cookie
   // is no longer there.
   chrome_test_util::OpenNewIncognitoTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoBrowsing)];
-  GREYAssertTrue(CheckNoCookieExists(),
-                 @"Incognito cookie should be gone from incognito mode. (2)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqual(0U, cookies.count,
+                  @"Incognito cookie should be gone from incognito mode.");
 
   // Verifies that new incognito cookies can be set.
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                 @"Failed to set incognito cookie in incognito mode. (3)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kIncognitoCookieValue, cookies[kIncognitoCookieName],
+                         @"Failed to set incognito cookie in incognito mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in incognito mode.");
 }
 
 // Tests that a cookie set in normal tab is not available in an incognito tab.
 - (void)testSwitchToIncognito {
   // Sets cookie in normal tab.
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Failed to set normal cookie in normal mode. (1)");
+  NSDictionary* cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kNormalCookieValue, cookies[kNormalCookieName],
+                         @"Normal cookie should still exist in normal mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in normal mode.");
 
   // Switches to a new incognito tab and verifies that cookie is not there.
   chrome_test_util::OpenNewIncognitoTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoBrowsing)];
-  GREYAssertTrue(CheckNoCookieExists(),
-                 @"Normal cookie should not be found in incognito mode. (2)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqual(0U, cookies.count,
+                  @"Normal cookie should not be found in incognito mode.");
 
   // Closes all incognito tabs and then switching back to a normal tab. Verifies
   // that the cookie set earlier is still there.
   chrome_test_util::CloseAllIncognitoTabs();
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Normal cookie should still be found in normal mode. (3)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(
+      kNormalCookieValue, cookies[kNormalCookieName],
+      @"Normal cookie should still be found in normal mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in normal mode.");
 }
 
 // Tests that a cookie set in incognito tab is only available in another
 // incognito tab. They are not available in a normal tab.
 - (void)testSwitchToMain {
   // Loads a page in normal tab and then switches to a new incognito tab. Sets
   // cookie in incognito tab.
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
   chrome_test_util::OpenNewIncognitoTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                 @"Failed to set incognito cookie in incognito mode. (1)");
+  NSDictionary* cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kIncognitoCookieValue, cookies[kIncognitoCookieName],
+                         @"Failed to set incognito cookie in incognito mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in incognito mode.");
+
   // Switches back to a normal tab and verifies that cookie set in incognito tab
   // is not available.
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
-  GREYAssertTrue(CheckNoCookieExists(),
-                 @"Incognito cookie should not be found in normal mode. (2)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqual(0U, cookies.count,
+                  @"Incognito cookie should not be found in normal mode.");
+
   // Returns back to Incognito tab and cookie is still there.
   chrome_test_util::OpenNewIncognitoTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlIncognitoBrowsing)];
-  GREYAssertTrue(CheckCookieExists(kIncognitoCookieKey, kIncognitoCookieValue),
-                 @"Incognito cookie should be found in incognito mode. (3)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(
+      kIncognitoCookieValue, cookies[kIncognitoCookieName],
+      @"Incognito cookie should be found in incognito mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in incognito mode.");
 }
 
 // Tests that a cookie set in a normal tab can be found in another normal tab.
 - (void)testShareCookiesBetweenTabs {
   // Loads page and sets cookie in first normal tab.
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalSetCookie)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Failed to set normal cookie in normal mode. (1)");
+  NSDictionary* cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(kNormalCookieValue, cookies[kNormalCookieName],
+                         @"Failed to set normal cookie in normal mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in normal mode.");
 
   // Creates another normal tab and verifies that the cookie is also there.
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey
       loadURL:web::test::HttpServer::MakeUrl(kTestUrlNormalBrowsing)];
-  GREYAssertTrue(CheckCookieExists(kNormalCookieKey, kNormalCookieValue),
-                 @"Normal cookie should still be found in normal mode. (2)");
+  cookies = [ChromeEarlGrey cookies];
+  GREYAssertEqualObjects(
+      kNormalCookieValue, cookies[kNormalCookieName],
+      @"Normal cookie should still be found in normal mode.");
+  GREYAssertEqual(1U, cookies.count,
+                  @"Only one cookie should be found in normal mode.");
 }
 
 @end