gaia_auth_util_unittest.cc revision a02191e04bc25c4935f804f2c080ae28663d096d 
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
5#include "google_apis/gaia/gaia_auth_util.h"
6
7#include "testing/gtest/include/gtest/gtest.h"
8#include "url/gurl.h"
9
10namespace gaia {
11
12TEST(GaiaAuthUtilTest, EmailAddressNoOp) {
13  const char lower_case[] = "user@what.com";
14  EXPECT_EQ(lower_case, CanonicalizeEmail(lower_case));
15}
16
17TEST(GaiaAuthUtilTest, EmailAddressIgnoreCaps) {
18  EXPECT_EQ(CanonicalizeEmail("user@what.com"),
19            CanonicalizeEmail("UsEr@what.com"));
20}
21
22TEST(GaiaAuthUtilTest, EmailAddressIgnoreDomainCaps) {
23  EXPECT_EQ(CanonicalizeEmail("user@what.com"),
24            CanonicalizeEmail("UsEr@what.COM"));
25}
26
27TEST(GaiaAuthUtilTest, EmailAddressRejectOneUsernameDot) {
28  EXPECT_NE(CanonicalizeEmail("u.ser@what.com"),
29            CanonicalizeEmail("UsEr@what.com"));
30}
31
32TEST(GaiaAuthUtilTest, EmailAddressMatchWithOneUsernameDot) {
33  EXPECT_EQ(CanonicalizeEmail("u.ser@what.com"),
34            CanonicalizeEmail("U.sEr@what.com"));
35}
36
37TEST(GaiaAuthUtilTest, EmailAddressIgnoreOneUsernameDot) {
38  EXPECT_EQ(CanonicalizeEmail("us.er@gmail.com"),
39            CanonicalizeEmail("UsEr@gmail.com"));
40}
41
42TEST(GaiaAuthUtilTest, EmailAddressIgnoreManyUsernameDots) {
43  EXPECT_EQ(CanonicalizeEmail("u.ser@gmail.com"),
44            CanonicalizeEmail("Us.E.r@gmail.com"));
45}
46
47TEST(GaiaAuthUtilTest, EmailAddressIgnoreConsecutiveUsernameDots) {
48  EXPECT_EQ(CanonicalizeEmail("use.r@gmail.com"),
49            CanonicalizeEmail("Us....E.r@gmail.com"));
50}
51
52TEST(GaiaAuthUtilTest, EmailAddressDifferentOnesRejected) {
53  EXPECT_NE(CanonicalizeEmail("who@what.com"),
54            CanonicalizeEmail("Us....E.r@what.com"));
55}
56
57TEST(GaiaAuthUtilTest, GooglemailNotCanonicalizedToGmail) {
58  const char googlemail[] = "user@googlemail.com";
59  EXPECT_EQ(googlemail, CanonicalizeEmail(googlemail));
60}
61
62TEST(GaiaAuthUtilTest, CanonicalizeDomain) {
63  const char domain[] = "example.com";
64  EXPECT_EQ(domain, CanonicalizeDomain("example.com"));
65  EXPECT_EQ(domain, CanonicalizeDomain("EXAMPLE.cOm"));
66}
67
68TEST(GaiaAuthUtilTest, ExtractDomainName) {
69  const char domain[] = "example.com";
70  EXPECT_EQ(domain, ExtractDomainName("who@example.com"));
71  EXPECT_EQ(domain, ExtractDomainName("who@EXAMPLE.cOm"));
72}
73
74TEST(GaiaAuthUtilTest, SanitizeMissingDomain) {
75  EXPECT_EQ("nodomain@gmail.com", SanitizeEmail("nodomain"));
76}
77
78TEST(GaiaAuthUtilTest, SanitizeExistingDomain) {
79  const char existing[] = "test@example.com";
80  EXPECT_EQ(existing, SanitizeEmail(existing));
81}
82
83TEST(GaiaAuthUtilTest, AreEmailsSame) {
84  EXPECT_TRUE(AreEmailsSame("foo", "foo"));
85  EXPECT_TRUE(AreEmailsSame("foo", "foo@gmail.com"));
86  EXPECT_TRUE(AreEmailsSame("foo@gmail.com", "Foo@Gmail.com"));
87  EXPECT_FALSE(AreEmailsSame("foo@gmail.com", "foo@othermail.com"));
88  EXPECT_FALSE(AreEmailsSame("user@gmail.com", "foo@gmail.com"));
89}
90
91TEST(GaiaAuthUtilTest, GmailAndGooglemailAreSame) {
92  EXPECT_TRUE(AreEmailsSame("foo@gmail.com", "foo@googlemail.com"));
93  EXPECT_FALSE(AreEmailsSame("bar@gmail.com", "foo@googlemail.com"));
94}
95
96TEST(GaiaAuthUtilTest, IsGaiaSignonRealm) {
97  // Only https versions of Gaia URLs should be considered valid.
98  EXPECT_TRUE(IsGaiaSignonRealm(GURL("https://accounts.google.com/")));
99  EXPECT_FALSE(IsGaiaSignonRealm(GURL("http://accounts.google.com/")));
100
101  // Other Google URLs are not valid.
102  EXPECT_FALSE(IsGaiaSignonRealm(GURL("https://www.google.com/")));
103  EXPECT_FALSE(IsGaiaSignonRealm(GURL("http://www.google.com/")));
104  EXPECT_FALSE(IsGaiaSignonRealm(GURL("https://google.com/")));
105  EXPECT_FALSE(IsGaiaSignonRealm(GURL("https://mail.google.com/")));
106
107  // Other https URLs are not valid.
108  EXPECT_FALSE(IsGaiaSignonRealm(GURL("https://www.example.com/")));
109}
110
111TEST(GaiaAuthUtilTest, ParseListAccountsData) {
112  std::vector<std::pair<std::string, bool> > accounts;
113  ASSERT_FALSE(ParseListAccountsData("", &accounts));
114  ASSERT_EQ(0u, accounts.size());
115
116  ASSERT_FALSE(ParseListAccountsData("1", &accounts));
117  ASSERT_EQ(0u, accounts.size());
118
119  ASSERT_FALSE(ParseListAccountsData("[]", &accounts));
120  ASSERT_EQ(0u, accounts.size());
121
122  ASSERT_FALSE(ParseListAccountsData("[\"foo\", \"bar\"]", &accounts));
123  ASSERT_EQ(0u, accounts.size());
124
125  ASSERT_TRUE(ParseListAccountsData("[\"foo\", []]", &accounts));
126  ASSERT_EQ(0u, accounts.size());
127
128  ASSERT_TRUE(ParseListAccountsData(
129      "[\"foo\", [[\"bar\", 0, \"name\", 0, \"photo\", 0, 0, 0]]]", &accounts));
130  ASSERT_EQ(0u, accounts.size());
131
132  ASSERT_TRUE(ParseListAccountsData(
133      "[\"foo\", [[\"bar\", 0, \"name\", \"u@g.c\", \"photo\", 0, 0, 0]]]",
134      &accounts));
135  ASSERT_EQ(1u, accounts.size());
136  ASSERT_EQ("u@g.c", accounts[0].first);
137  ASSERT_TRUE(accounts[0].second);
138
139  ASSERT_TRUE(ParseListAccountsData(
140      "[\"foo\", [[\"bar1\", 0, \"name1\", \"u1@g.c\", \"photo1\", 0, 0, 0], "
141                 "[\"bar2\", 0, \"name2\", \"u2@g.c\", \"photo2\", 0, 0, 0]]]",
142      &accounts));
143  ASSERT_EQ(2u, accounts.size());
144  ASSERT_EQ("u1@g.c", accounts[0].first);
145  ASSERT_TRUE(accounts[0].second);
146  ASSERT_EQ("u2@g.c", accounts[1].first);
147  ASSERT_TRUE(accounts[1].second);
148
149  ASSERT_TRUE(ParseListAccountsData(
150      "[\"foo\", [[\"b1\", 0, \"name1\", \"U1@g.c\", \"photo1\", 0, 0, 0], "
151                 "[\"b2\", 0, \"name2\", \"u.2@g.c\", \"photo2\", 0, 0, 0]]]",
152      &accounts));
153  ASSERT_EQ(2u, accounts.size());
154  ASSERT_EQ(CanonicalizeEmail("U1@g.c"), accounts[0].first);
155  ASSERT_TRUE(accounts[0].second);
156  ASSERT_EQ(CanonicalizeEmail("u.2@g.c"), accounts[1].first);
157  ASSERT_TRUE(accounts[1].second);
158}
159
160TEST(GaiaAuthUtilTest, ParseListAccountsDataValidSession) {
161  std::vector<std::pair<std::string, bool> > accounts;
162
163  // Missing valid session means: return account.
164  ASSERT_TRUE(ParseListAccountsData(
165      "[\"foo\", [[\"b\", 0, \"n\", \"u@g.c\", \"p\", 0, 0, 0]]]",
166      &accounts));
167  ASSERT_EQ(1u, accounts.size());
168  ASSERT_EQ("u@g.c", accounts[0].first);
169  ASSERT_TRUE(accounts[0].second);
170
171  // Valid session is true means: return account.
172  ASSERT_TRUE(ParseListAccountsData(
173      "[\"foo\", [[\"b\", 0, \"n\", \"u@g.c\", \"p\", 0, 0, 0, 0, 1]]]",
174      &accounts));
175  ASSERT_EQ(1u, accounts.size());
176  ASSERT_EQ("u@g.c", accounts[0].first);
177  ASSERT_TRUE(accounts[0].second);
178
179  // Valid session is false means: return account with valid bit false.
180  ASSERT_TRUE(ParseListAccountsData(
181      "[\"foo\", [[\"b\", 0, \"n\", \"u@g.c\", \"p\", 0, 0, 0, 0, 0]]]",
182      &accounts));
183  ASSERT_EQ(1u, accounts.size());
184  ASSERT_FALSE(accounts[0].second);
185}
186
187}  // namespace gaia
188