Prompt for expiration date for local cards.

components/autofill/core/browser/credit_card_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/components_scaled_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
@@ skipping 704 matching lines @@
 TEST(CreditCardTest, CanBuildFromCardNumberAndExpirationDate) {
   base::string16 card_number = base::ASCIIToUTF16("test");
   int month = 1;
   int year = 3000;
   CreditCard card(card_number, month, year);
   EXPECT_EQ(card_number, card.number());
   EXPECT_EQ(month, card.expiration_month());
   EXPECT_EQ(year, card.expiration_year());
 }
 
+// A test case for credit card expiration year and month.
+class ExpTestCase {

[Mathieu, 2016/04/27 19:54:50]

would a struct simplify things here? possibly less boilerplate and they can also
be instantiated quite simply too
https://code.google.com/p/chromium/codesearch#chromium/src/components/autofil...

[please use gerrit instead, 2016/04/28 00:30:24]

Done.

+ public:
+  ExpTestCase(const base::Time& now,
+              bool update,
+              int month,
+              int year,
+              CreditCard::RecordType type)
+      : current_time_(now),
+        should_update_expiration_(update),
+        month_(month),
+        year_(year),
+        record_type_(type),
+        server_status_(CreditCard::OK) {}
+
+  ExpTestCase(const base::Time& now,
+              bool update,
+              int month,
+              int year,
+              CreditCard::RecordType type,
+              CreditCard::ServerStatus status)
+      : current_time_(now),
+        should_update_expiration_(update),
+        month_(month),
+        year_(year),
+        record_type_(type),
+        server_status_(status) {}
+
+  ~ExpTestCase() {}
+
+  const base::Time& current_time() const { return current_time_; }
+  bool should_update_expiration() const { return should_update_expiration_; }
+  int month() const { return month_; }
+  int year() const { return year_; }
+  CreditCard::RecordType record_type() const { return record_type_; }
+  CreditCard::ServerStatus server_status() const { return server_status_; }
+
+ private:
+  base::Time current_time_;
+  bool should_update_expiration_;
+  int month_;
+  int year_;
+  CreditCard::RecordType record_type_;
+  CreditCard::ServerStatus server_status_;
+};
+
+// A parameterized test fixture for credit card expiration.
+class CreditCardExpTest : public testing::TestWithParam<ExpTestCase> {
+ public:
+  static std::vector<ExpTestCase> GenerateTestCases() {
+    std::vector<ExpTestCase> cases;
+
+    base::Time now = base::Time::Now();
+    base::Time::Exploded last_year;
+    (now - base::TimeDelta::FromDays(365)).LocalExplode(&last_year);
+
+    // Cards that expired last year should always be updated.
+    cases.emplace_back(now, true, last_year.month, last_year.year,
+                       CreditCard::LOCAL_CARD);
+    cases.emplace_back(now, true, last_year.month, last_year.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, last_year.month, last_year.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, last_year.month, last_year.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED);
+    cases.emplace_back(now, true, last_year.month, last_year.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED);
+
+    base::Time::Exploded last_month;
+    (now - base::TimeDelta::FromDays(31)).LocalExplode(&last_month);
+
+    // Cards that expired last month should always be updated.
+    cases.emplace_back(now, true, last_month.month, last_month.year,
+                       CreditCard::LOCAL_CARD);
+    cases.emplace_back(now, true, last_month.month, last_month.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, last_month.month, last_month.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, last_month.month, last_month.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED);
+    cases.emplace_back(now, true, last_month.month, last_month.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED);
+
+    base::Time::Exploded current;
+    now.LocalExplode(&current);
+
+    // Cards that expire this month should be updated only if the server status
+    // is EXPIRED.
+    cases.emplace_back(now, false, current.month, current.year,
+                       CreditCard::LOCAL_CARD);
+    cases.emplace_back(now, false, current.month, current.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, false, current.month, current.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, current.month, current.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED);
+    cases.emplace_back(now, true, current.month, current.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED);
+
+    base::Time::Exploded next_month;
+    (now + base::TimeDelta::FromDays(31)).LocalExplode(&next_month);
+
+    // Cards that expire next month should be updated only if the server status
+    // is EXPIRED.
+    cases.emplace_back(now, false, next_month.month, next_month.year,
+                       CreditCard::LOCAL_CARD);
+    cases.emplace_back(now, false, next_month.month, next_month.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, false, next_month.month, next_month.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, next_month.month, next_month.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED);
+    cases.emplace_back(now, true, next_month.month, next_month.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED);
+
+    base::Time::Exploded next_year;
+    (now + base::TimeDelta::FromDays(365)).LocalExplode(&next_year);
+
+    // Cards that expire next year should be updated only if the server status
+    // is EXPIRED.
+    cases.emplace_back(now, false, next_year.month, next_year.year,
+                       CreditCard::LOCAL_CARD);
+    cases.emplace_back(now, false, next_year.month, next_year.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, false, next_year.month, next_year.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::OK);
+    cases.emplace_back(now, true, next_year.month, next_year.year,
+                       CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED);
+    cases.emplace_back(now, true, next_year.month, next_year.year,
+                       CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED);
+
+    return cases;
+  }
+};
+
+// Verifies that a credit card should be updated.
+TEST_P(CreditCardExpTest, ShouldUpdateExpiration) {
+  CreditCard card(base::ASCIIToUTF16("1234"), GetParam().month(),
+                  GetParam().year());
+  card.set_record_type(GetParam().record_type());
+  if (card.record_type() != CreditCard::LOCAL_CARD)
+    card.SetServerStatus(GetParam().server_status());
+
+  EXPECT_EQ(GetParam().should_update_expiration(),
+            card.ShouldUpdateExpiration(GetParam().current_time()));
+}
+
+INSTANTIATE_TEST_CASE_P(
+    Expiration,
+    CreditCardExpTest,
+    testing::ValuesIn(CreditCardExpTest::GenerateTestCases()));
+
 }  // namespace autofill