gaia_auth_util_unittest.cc 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "google_apis/gaia/gaia_auth_util.h"
  5. #include "base/base64url.h"
  6. #include "google_apis/gaia/oauth2_mint_token_consent_result.pb.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. #include "third_party/abseil-cpp/absl/types/optional.h"
  9. #include "url/gurl.h"
  10. namespace gaia {
  11. namespace {
  12. const char kGaiaId[] = "fake_gaia_id";
  13. std::string GenerateOAuth2MintTokenConsentResult(
  14. absl::optional<bool> approved,
  15. const absl::optional<std::string>& encrypted_approval_data,
  16. const absl::optional<std::string>& obfuscated_id,
  17. base::Base64UrlEncodePolicy encode_policy =
  18. base::Base64UrlEncodePolicy::OMIT_PADDING) {
  19. OAuth2MintTokenConsentResult consent_result;
  20. if (approved.has_value())
  21. consent_result.set_approved(approved.value());
  22. if (encrypted_approval_data.has_value())
  23. consent_result.set_encrypted_approval_data(encrypted_approval_data.value());
  24. if (obfuscated_id.has_value())
  25. consent_result.set_obfuscated_id(obfuscated_id.value());
  26. std::string serialized_consent = consent_result.SerializeAsString();
  27. std::string encoded_consent;
  28. base::Base64UrlEncode(serialized_consent, encode_policy, &encoded_consent);
  29. return encoded_consent;
  30. }
  31. } // namespace
  32. TEST(GaiaAuthUtilTest, EmailAddressNoOp) {
  33. const char lower_case[] = "user@what.com";
  34. EXPECT_EQ(lower_case, CanonicalizeEmail(lower_case));
  35. }
  36. TEST(GaiaAuthUtilTest, InvalidEmailAddress) {
  37. const char invalid_email1[] = "user";
  38. const char invalid_email2[] = "user@@what.com";
  39. EXPECT_EQ(invalid_email1, CanonicalizeEmail(invalid_email1));
  40. EXPECT_EQ(invalid_email2, CanonicalizeEmail(invalid_email2));
  41. EXPECT_EQ("user", CanonicalizeEmail("USER"));
  42. }
  43. TEST(GaiaAuthUtilTest, EmailAddressIgnoreCaps) {
  44. EXPECT_EQ(CanonicalizeEmail("user@what.com"),
  45. CanonicalizeEmail("UsEr@what.com"));
  46. }
  47. TEST(GaiaAuthUtilTest, EmailAddressIgnoreDomainCaps) {
  48. EXPECT_EQ(CanonicalizeEmail("user@what.com"),
  49. CanonicalizeEmail("UsEr@what.COM"));
  50. }
  51. TEST(GaiaAuthUtilTest, EmailAddressRejectOneUsernameDot) {
  52. EXPECT_NE(CanonicalizeEmail("u.ser@what.com"),
  53. CanonicalizeEmail("UsEr@what.com"));
  54. }
  55. TEST(GaiaAuthUtilTest, EmailAddressMatchWithOneUsernameDot) {
  56. EXPECT_EQ(CanonicalizeEmail("u.ser@what.com"),
  57. CanonicalizeEmail("U.sEr@what.com"));
  58. }
  59. TEST(GaiaAuthUtilTest, EmailAddressIgnoreOneUsernameDot) {
  60. EXPECT_EQ(CanonicalizeEmail("us.er@gmail.com"),
  61. CanonicalizeEmail("UsEr@gmail.com"));
  62. }
  63. TEST(GaiaAuthUtilTest, EmailAddressIgnoreOneUsernameDotAndIgnoreCaps) {
  64. EXPECT_EQ(CanonicalizeEmail("user@gmail.com"),
  65. CanonicalizeEmail("US.ER@GMAIL.COM"));
  66. }
  67. TEST(GaiaAuthUtilTest, EmailAddressIgnoreManyUsernameDots) {
  68. EXPECT_EQ(CanonicalizeEmail("u.ser@gmail.com"),
  69. CanonicalizeEmail("Us.E.r@gmail.com"));
  70. }
  71. TEST(GaiaAuthUtilTest, EmailAddressIgnoreConsecutiveUsernameDots) {
  72. EXPECT_EQ(CanonicalizeEmail("use.r@gmail.com"),
  73. CanonicalizeEmail("Us....E.r@gmail.com"));
  74. }
  75. TEST(GaiaAuthUtilTest, EmailAddressDifferentOnesRejected) {
  76. EXPECT_NE(CanonicalizeEmail("who@what.com"),
  77. CanonicalizeEmail("Us....E.r@what.com"));
  78. }
  79. TEST(GaiaAuthUtilTest, GooglemailNotCanonicalizedToGmail) {
  80. const char googlemail[] = "user@googlemail.com";
  81. EXPECT_EQ(googlemail, CanonicalizeEmail(googlemail));
  82. }
  83. TEST(GaiaAuthUtilTest, CanonicalizeDomain) {
  84. const char domain[] = "example.com";
  85. EXPECT_EQ(domain, CanonicalizeDomain("example.com"));
  86. EXPECT_EQ(domain, CanonicalizeDomain("EXAMPLE.cOm"));
  87. }
  88. TEST(GaiaAuthUtilTest, ExtractDomainName) {
  89. const char domain[] = "example.com";
  90. EXPECT_EQ(domain, ExtractDomainName("who@example.com"));
  91. EXPECT_EQ(domain, ExtractDomainName("who@EXAMPLE.cOm"));
  92. }
  93. TEST(GaiaAuthUtilTest, IsGoogleInternalAccountEmail) {
  94. EXPECT_TRUE(IsGoogleInternalAccountEmail("hello@google.com"));
  95. EXPECT_FALSE(IsGoogleInternalAccountEmail("internal@gmail.com"));
  96. EXPECT_FALSE(IsGoogleInternalAccountEmail(" "));
  97. }
  98. TEST(GaiaAuthUtilTest, SanitizeMissingDomain) {
  99. EXPECT_EQ("nodomain@gmail.com", SanitizeEmail("nodomain"));
  100. }
  101. TEST(GaiaAuthUtilTest, SanitizeExistingDomain) {
  102. const char existing[] = "test@example.com";
  103. EXPECT_EQ(existing, SanitizeEmail(existing));
  104. }
  105. TEST(GaiaAuthUtilTest, AreEmailsSame) {
  106. EXPECT_TRUE(AreEmailsSame("foo", "foo"));
  107. EXPECT_TRUE(AreEmailsSame("foo", "foo@gmail.com"));
  108. EXPECT_TRUE(AreEmailsSame("foo@gmail.com", "Foo@Gmail.com"));
  109. EXPECT_FALSE(AreEmailsSame("foo@gmail.com", "foo@othermail.com"));
  110. EXPECT_FALSE(AreEmailsSame("user@gmail.com", "foo@gmail.com"));
  111. }
  112. TEST(GaiaAuthUtilTest, IsGoogleRobotAccountEmail) {
  113. EXPECT_FALSE(IsGoogleRobotAccountEmail(""));
  114. EXPECT_FALSE(IsGoogleRobotAccountEmail("foo"));
  115. EXPECT_FALSE(IsGoogleRobotAccountEmail("1234567890"));
  116. EXPECT_FALSE(IsGoogleRobotAccountEmail("foo@gmail.com"));
  117. EXPECT_FALSE(IsGoogleRobotAccountEmail("system.gserviceaccount.com"));
  118. EXPECT_TRUE(IsGoogleRobotAccountEmail("foo@system.gserviceaccount.com"));
  119. EXPECT_TRUE(IsGoogleRobotAccountEmail("foo@system.googleusercontent.com"));
  120. EXPECT_TRUE(IsGoogleRobotAccountEmail("foo@System.Gserviceaccount.com"));
  121. EXPECT_TRUE(IsGoogleRobotAccountEmail("foo@System.Googleusercontent.com"));
  122. }
  123. TEST(GaiaAuthUtilTest, GmailAndGooglemailAreSame) {
  124. EXPECT_TRUE(AreEmailsSame("foo@gmail.com", "foo@googlemail.com"));
  125. EXPECT_FALSE(AreEmailsSame("bar@gmail.com", "foo@googlemail.com"));
  126. }
  127. TEST(GaiaAuthUtilTest, HasGaiaSchemeHostPort) {
  128. EXPECT_TRUE(HasGaiaSchemeHostPort(GURL("https://accounts.google.com/")));
  129. // Paths and queries should be ignored.
  130. EXPECT_TRUE(HasGaiaSchemeHostPort(GURL("https://accounts.google.com/foo")));
  131. EXPECT_TRUE(
  132. HasGaiaSchemeHostPort(GURL("https://accounts.google.com/foo?bar=1#baz")));
  133. // Scheme mismatch should lead to false.
  134. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("http://accounts.google.com/")));
  135. // Port mismatch should lead to false.
  136. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("https://accounts.google.com:123/")));
  137. // Host mismatch should lead to false, including Google URLs.
  138. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("https://example.com/")));
  139. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("https://www.example.com/")));
  140. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("https://www.google.com/")));
  141. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("https://google.com/")));
  142. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("https://mail.google.com/")));
  143. // about: scheme.
  144. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("about:blank")));
  145. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL("about:srcdoc")));
  146. // blob: scheme.
  147. EXPECT_FALSE(HasGaiaSchemeHostPort(
  148. GURL("blob:https://accounts.google.com/mocked-blob-guid")));
  149. // Invalid/empty URL.
  150. EXPECT_FALSE(HasGaiaSchemeHostPort(GURL()));
  151. }
  152. TEST(GaiaAuthUtilTest, ParseListAccountsData) {
  153. std::vector<ListedAccount> accounts;
  154. std::vector<ListedAccount> signed_out_accounts;
  155. ASSERT_FALSE(ParseListAccountsData("", &accounts, &signed_out_accounts));
  156. ASSERT_EQ(0u, accounts.size());
  157. ASSERT_EQ(0u, signed_out_accounts.size());
  158. ASSERT_FALSE(ParseListAccountsData("1", &accounts, &signed_out_accounts));
  159. ASSERT_EQ(0u, accounts.size());
  160. ASSERT_EQ(0u, signed_out_accounts.size());
  161. ASSERT_FALSE(ParseListAccountsData("[]", &accounts, &signed_out_accounts));
  162. ASSERT_EQ(0u, accounts.size());
  163. ASSERT_EQ(0u, signed_out_accounts.size());
  164. ASSERT_FALSE(ParseListAccountsData(
  165. "[\"foo\", \"bar\"]", &accounts, &signed_out_accounts));
  166. ASSERT_EQ(0u, accounts.size());
  167. ASSERT_EQ(0u, signed_out_accounts.size());
  168. ASSERT_TRUE(ParseListAccountsData(
  169. "[\"foo\", []]", &accounts, &signed_out_accounts));
  170. ASSERT_EQ(0u, accounts.size());
  171. ASSERT_EQ(0u, signed_out_accounts.size());
  172. ASSERT_TRUE(ParseListAccountsData(
  173. "[\"foo\", [[\"bar\", 0, \"name\", 0, \"photo\", 0, 0, 0]]]",
  174. &accounts,
  175. &signed_out_accounts));
  176. ASSERT_EQ(0u, accounts.size());
  177. ASSERT_EQ(0u, signed_out_accounts.size());
  178. ASSERT_TRUE(ParseListAccountsData(
  179. "[\"foo\", "
  180. "[[\"bar\", 0, \"name\", \"u@g.c\", \"p\", 0, 0, 0, 0, 1, \"45\"]]]",
  181. &accounts,
  182. &signed_out_accounts));
  183. ASSERT_EQ(1u, accounts.size());
  184. ASSERT_EQ("u@g.c", accounts[0].email);
  185. ASSERT_TRUE(accounts[0].valid);
  186. ASSERT_EQ(0u, signed_out_accounts.size());
  187. ASSERT_TRUE(ParseListAccountsData(
  188. "[\"foo\", "
  189. "[[\"bar1\",0,\"name1\",\"u1@g.c\",\"photo1\",0,0,0,0,1,\"45\"], "
  190. "[\"bar2\",0,\"name2\",\"u2@g.c\",\"photo2\",0,0,0,0,1,\"6\"]]]",
  191. &accounts,
  192. &signed_out_accounts));
  193. ASSERT_EQ(2u, accounts.size());
  194. ASSERT_EQ("u1@g.c", accounts[0].email);
  195. ASSERT_TRUE(accounts[0].valid);
  196. ASSERT_EQ("u2@g.c", accounts[1].email);
  197. ASSERT_TRUE(accounts[1].valid);
  198. ASSERT_EQ(0u, signed_out_accounts.size());
  199. ASSERT_TRUE(ParseListAccountsData(
  200. "[\"foo\", "
  201. "[[\"b1\", 0,\"name1\",\"U1@g.c\",\"photo1\",0,0,0,0,1,\"45\"], "
  202. "[\"b2\",0,\"name2\",\"u.2@g.c\",\"photo2\",0,0,0,0,1,\"46\"]]]",
  203. &accounts,
  204. &signed_out_accounts));
  205. ASSERT_EQ(2u, accounts.size());
  206. ASSERT_EQ(CanonicalizeEmail("U1@g.c"), accounts[0].email);
  207. ASSERT_TRUE(accounts[0].valid);
  208. ASSERT_EQ(CanonicalizeEmail("u.2@g.c"), accounts[1].email);
  209. ASSERT_TRUE(accounts[1].valid);
  210. ASSERT_EQ(0u, signed_out_accounts.size());
  211. }
  212. TEST(GaiaAuthUtilTest, ParseListAccountsDataValidSession) {
  213. std::vector<ListedAccount> accounts;
  214. std::vector<ListedAccount> signed_out_accounts;
  215. // Valid session is true means: return account.
  216. ASSERT_TRUE(ParseListAccountsData(
  217. "[\"foo\", [[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,1,\"45\"]]]",
  218. &accounts,
  219. &signed_out_accounts));
  220. ASSERT_EQ(1u, accounts.size());
  221. ASSERT_EQ("u@g.c", accounts[0].email);
  222. ASSERT_TRUE(accounts[0].valid);
  223. ASSERT_EQ(0u, signed_out_accounts.size());
  224. // Valid session is false means: return account with valid bit false.
  225. ASSERT_TRUE(ParseListAccountsData(
  226. "[\"foo\", [[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,0,\"45\"]]]",
  227. &accounts,
  228. &signed_out_accounts));
  229. ASSERT_EQ(1u, accounts.size());
  230. ASSERT_FALSE(accounts[0].valid);
  231. ASSERT_EQ(0u, signed_out_accounts.size());
  232. }
  233. TEST(GaiaAuthUtilTest, ParseListAccountsDataGaiaId) {
  234. std::vector<ListedAccount> accounts;
  235. std::vector<ListedAccount> signed_out_accounts;
  236. // Missing gaia id means: do not return account.
  237. ASSERT_TRUE(ParseListAccountsData(
  238. "[\"foo\", [[\"b\", 0, \"n\", \"u@g.c\", \"photo\", 0, 0, 0, 0, 1]]]",
  239. &accounts,
  240. &signed_out_accounts));
  241. ASSERT_EQ(0u, accounts.size());
  242. ASSERT_EQ(0u, signed_out_accounts.size());
  243. // Valid gaia session means: return gaia session
  244. ASSERT_TRUE(ParseListAccountsData(
  245. "[\"foo\", "
  246. "[[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,1,\"9863\"]]]",
  247. &accounts,
  248. &signed_out_accounts));
  249. ASSERT_EQ(1u, accounts.size());
  250. ASSERT_EQ("u@g.c", accounts[0].email);
  251. ASSERT_TRUE(accounts[0].valid);
  252. ASSERT_EQ("9863", accounts[0].gaia_id);
  253. ASSERT_EQ(0u, signed_out_accounts.size());
  254. }
  255. TEST(GaiaAuthUtilTest, ParseListAccountsWithSignedOutAccounts) {
  256. std::vector<ListedAccount> accounts;
  257. std::vector<ListedAccount> signed_out_accounts;
  258. ASSERT_TRUE(ParseListAccountsData(
  259. "[\"foo\","
  260. "[[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,1,\"45\"],"
  261. "[\"c\",0,\"n\",\"u.2@g.c\",\"photo\",0,0,0,0,1,\"45\","
  262. "null,null,null,1]]]",
  263. &accounts,
  264. &signed_out_accounts));
  265. ASSERT_EQ(1u, accounts.size());
  266. ASSERT_EQ("u@g.c", accounts[0].email);
  267. ASSERT_FALSE(accounts[0].signed_out);
  268. ASSERT_EQ(1u, signed_out_accounts.size());
  269. ASSERT_EQ("u.2@g.c", signed_out_accounts[0].email);
  270. ASSERT_TRUE(signed_out_accounts[0].signed_out);
  271. }
  272. TEST(GaiaAuthUtilTest, ParseListAccountsVerifiedAccounts) {
  273. std::vector<ListedAccount> accounts;
  274. std::vector<ListedAccount> signed_out_accounts;
  275. ASSERT_TRUE(ParseListAccountsData(
  276. "[\"foo\","
  277. "[[\"a\",0,\"n\",\"a@g.c\",\"photo\",0,0,0,0,1,\"45\"],"
  278. "[\"b\",0,\"n\",\"b@g.c\",\"photo\",0,0,0,0,1,\"45\","
  279. "null,null,null,null,0],"
  280. "[\"c\",0,\"n\",\"c@g.c\",\"photo\",0,0,0,0,1,\"45\","
  281. "null,null,null,null,1]]]",
  282. &accounts, &signed_out_accounts));
  283. ASSERT_EQ(3u, accounts.size());
  284. ASSERT_EQ("a@g.c", accounts[0].email);
  285. EXPECT_TRUE(accounts[0].verified); // Accounts are verified by default.
  286. ASSERT_EQ("b@g.c", accounts[1].email);
  287. EXPECT_FALSE(accounts[1].verified);
  288. ASSERT_EQ("c@g.c", accounts[2].email);
  289. EXPECT_TRUE(accounts[2].verified);
  290. ASSERT_EQ(0u, signed_out_accounts.size());
  291. }
  292. TEST(GaiaAuthUtilTest, ParseListAccountsAcceptsNull) {
  293. ASSERT_TRUE(ParseListAccountsData(
  294. "[\"foo\","
  295. "[[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,1,\"45\"],"
  296. "[\"c\",0,\"n\",\"u.2@g.c\",\"photo\",0,0,0,0,1,\"45\","
  297. "null,null,null,1]]]",
  298. nullptr,
  299. nullptr));
  300. std::vector<ListedAccount> accounts;
  301. ASSERT_TRUE(ParseListAccountsData(
  302. "[\"foo\","
  303. "[[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,1,\"45\"],"
  304. "[\"c\",0,\"n\",\"u.2@g.c\",\"photo\",0,0,0,0,1,\"45\","
  305. "null,null,null,1]]]",
  306. &accounts,
  307. nullptr));
  308. ASSERT_EQ(1u, accounts.size());
  309. ASSERT_EQ("u@g.c", accounts[0].email);
  310. ASSERT_FALSE(accounts[0].signed_out);
  311. std::vector<ListedAccount> signed_out_accounts;
  312. ASSERT_TRUE(ParseListAccountsData(
  313. "[\"foo\","
  314. "[[\"b\",0,\"n\",\"u@g.c\",\"photo\",0,0,0,0,1,\"45\"],"
  315. "[\"c\",0,\"n\",\"u.2@g.c\",\"photo\",0,0,0,0,1,\"45\","
  316. "null,null,null,1]]]",
  317. nullptr,
  318. &signed_out_accounts));
  319. ASSERT_EQ(1u, signed_out_accounts.size());
  320. ASSERT_EQ("u.2@g.c", signed_out_accounts[0].email);
  321. ASSERT_TRUE(signed_out_accounts[0].signed_out);
  322. }
  323. TEST(GaiaAuthUtilTest, ParseConsentResultApproved) {
  324. const char kApprovedConsent[] = "CAESCUVOQ1JZUFRFRBoMZmFrZV9nYWlhX2lk";
  325. EXPECT_EQ(kApprovedConsent,
  326. GenerateOAuth2MintTokenConsentResult(true, "ENCRYPTED", kGaiaId));
  327. bool approved = false;
  328. std::string gaia_id;
  329. ASSERT_TRUE(
  330. ParseOAuth2MintTokenConsentResult(kApprovedConsent, &approved, &gaia_id));
  331. EXPECT_TRUE(approved);
  332. EXPECT_EQ(gaia_id, kGaiaId);
  333. }
  334. TEST(GaiaAuthUtilTest, ParseConsentResultApprovedEmptyData) {
  335. const char kApprovedConsent[] = "CAEaDGZha2VfZ2FpYV9pZA";
  336. EXPECT_EQ(kApprovedConsent,
  337. GenerateOAuth2MintTokenConsentResult(true, absl::nullopt, kGaiaId));
  338. bool approved = false;
  339. std::string gaia_id;
  340. ASSERT_TRUE(
  341. ParseOAuth2MintTokenConsentResult(kApprovedConsent, &approved, &gaia_id));
  342. EXPECT_TRUE(approved);
  343. EXPECT_EQ(gaia_id, kGaiaId);
  344. }
  345. TEST(GaiaAuthUtilTest, ParseConsentResultApprovedEmptyGaiaId) {
  346. const char kApprovedConsent[] = "CAESCUVOQ1JZUFRFRA";
  347. EXPECT_EQ(kApprovedConsent, GenerateOAuth2MintTokenConsentResult(
  348. true, "ENCRYPTED", absl::nullopt));
  349. bool approved = false;
  350. std::string gaia_id;
  351. ASSERT_TRUE(
  352. ParseOAuth2MintTokenConsentResult(kApprovedConsent, &approved, &gaia_id));
  353. EXPECT_TRUE(approved);
  354. EXPECT_TRUE(gaia_id.empty());
  355. }
  356. TEST(GaiaAuthUtilTest, ParseConsentResultNotApproved) {
  357. const char kNoGrantConsent[] = "CAAaDGZha2VfZ2FpYV9pZA";
  358. EXPECT_EQ(kNoGrantConsent, GenerateOAuth2MintTokenConsentResult(
  359. false, absl::nullopt, kGaiaId));
  360. bool approved = false;
  361. std::string gaia_id;
  362. ASSERT_TRUE(
  363. ParseOAuth2MintTokenConsentResult(kNoGrantConsent, &approved, &gaia_id));
  364. EXPECT_FALSE(approved);
  365. EXPECT_EQ(gaia_id, kGaiaId);
  366. }
  367. TEST(GaiaAuthUtilTest, ParseConsentResultEmpty) {
  368. EXPECT_EQ("", GenerateOAuth2MintTokenConsentResult(
  369. absl::nullopt, absl::nullopt, absl::nullopt));
  370. bool approved = false;
  371. std::string gaia_id;
  372. ASSERT_TRUE(ParseOAuth2MintTokenConsentResult("", &approved, &gaia_id));
  373. // false is the default value for a bool in proto.
  374. EXPECT_FALSE(approved);
  375. // String is empty in proto by default.
  376. EXPECT_TRUE(gaia_id.empty());
  377. }
  378. TEST(GaiaAuthUtilTest, ParseConsentResultBase64UrlDisallowedPadding) {
  379. const char kApprovedConsentWithPadding[] = "CAE=";
  380. EXPECT_EQ(kApprovedConsentWithPadding,
  381. GenerateOAuth2MintTokenConsentResult(
  382. true, absl::nullopt, absl::nullopt,
  383. base::Base64UrlEncodePolicy::INCLUDE_PADDING));
  384. bool approved = false;
  385. std::string gaia_id;
  386. EXPECT_FALSE(ParseOAuth2MintTokenConsentResult(kApprovedConsentWithPadding,
  387. &approved, &gaia_id));
  388. }
  389. TEST(GaiaAuthUtilTest, ParseConsentResultInvalidBase64Url) {
  390. const char kMalformedConsent[] =
  391. "+/"; // '+' and '/' are disallowed in base64url alphabet.
  392. bool approved = false;
  393. std::string gaia_id;
  394. EXPECT_FALSE(ParseOAuth2MintTokenConsentResult(kMalformedConsent, &approved,
  395. &gaia_id));
  396. }
  397. TEST(GaiaAuthUtilTest, ParseConsentResultInvalidProto) {
  398. const char kMalformedConsent[] =
  399. "ab"; // Valid base64url string but invalid proto.
  400. bool approved = false;
  401. std::string gaia_id;
  402. EXPECT_FALSE(ParseOAuth2MintTokenConsentResult(kMalformedConsent, &approved,
  403. &gaia_id));
  404. }
  405. } // namespace gaia