[Payments] Show admin area complete names on PR form.

components/payments/core/subkey_requester_unittest.cc

 // Copyright 2017 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 "components/payments/core/subkey_requester.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/null_storage.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/source.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/storage.h"
 #include "third_party/libaddressinput/src/cpp/test/testdata_source.h"
 
 namespace payments {
 namespace {
 
 using ::i18n::addressinput::NullStorage;
 using ::i18n::addressinput::Source;
 using ::i18n::addressinput::Storage;
 using ::i18n::addressinput::TestdataSource;
 
 const char kLocale[] = "OZ";
+const char kLanguage[] = "en";
 const int kInvalidSize = -1;
 const int kCorrectSize = 2;  // for subkeys = Do, Re
 const int kEmptySize = 0;
 
 class SubKeyReceiver : public base::RefCountedThreadSafe<SubKeyReceiver> {
  public:
   SubKeyReceiver() : subkeys_size_(kInvalidSize) {}
 
-  void OnSubKeysReceived(const std::vector<std::string>& subkeys) {
-    subkeys_size_ = subkeys.size();
+  void OnSubKeysReceived(const std::vector<std::string>& subkeys_codes,
+                         const std::vector<std::string>& subkeys_names) {
+    subkeys_size_ = subkeys_codes.size();
   }
 
   int subkeys_size() const { return subkeys_size_; }
 
  private:
   friend class base::RefCountedThreadSafe<SubKeyReceiver>;
   ~SubKeyReceiver() {}
 
   int subkeys_size_;
 
   DISALLOW_COPY_AND_ASSIGN(SubKeyReceiver);
 };
 
 // Used to load region rules for this test.
 class ChromiumTestdataSource : public TestdataSource {
  public:
   ChromiumTestdataSource() : TestdataSource(true) {}
 
   ~ChromiumTestdataSource() override {}
 
   // For this test, only load the rules for the kLocale.
   void Get(const std::string& key, const Callback& data_ready) const override {
     data_ready(
         true, key,
         new std::string(
             "{\"data/OZ\": "
             "{\"id\":\"data/OZ\",\"key\":\"OZ\",\"name\":\"Oz \", "
-            "\"lang\":\"en\",\"languages\":\"en\",\"sub_keys\":\"DO~Re\"}}"));
+            "\"lang\":\"en\",\"sub_keys\":\"DO~RE\", \"sub_names\":\"Do~Re\"},"
+            "\"data/OZ/DO\": "
+            "{\"id\":\"data/OZ/DO\",\"key\":\"DO\",\"name\":\"Do \", "
+            "\"lang\":\"en\"},"
+            "\"data/OZ/RE\": "
+            "{\"id\":\"data/OZ/RE\",\"key\":\"RE\",\"name\":\"Re \", "
+            "\"lang\":\"en\"}}"));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromiumTestdataSource);
 };
 
 // A test subclass of the SubKeyRequesterImpl. Used to simulate rules not
 // being loaded.
 class TestSubKeyRequester : public SubKeyRequester {
  public:
@@ skipping 55 matching lines @@
   scoped_refptr<SubKeyReceiver> subkey_receiver_ = new SubKeyReceiver();
 
   SubKeyReceiverCallback cb =
       base::BindOnce(&SubKeyReceiver::OnSubKeysReceived, subkey_receiver_);
 
   // Load the rules.
   requester_->LoadRulesForRegion(kLocale);
   EXPECT_TRUE(requester_->AreRulesLoadedForRegion(kLocale));
 
   // Start the request.
-  requester_->StartRegionSubKeysRequest(kLocale, 0, std::move(cb));
+  requester_->StartRegionSubKeysRequest(kLocale, kLanguage, 0, std::move(cb));
 
   // Since the rules are already loaded, the subkeys should be received
   // synchronously.
   EXPECT_EQ(subkey_receiver_->subkeys_size(), kCorrectSize);
 }
 
 // Tests that if the rules are not loaded before the request and cannot be
 // loaded after, the subkeys will not be received and the delegate will be
 // notified.
 TEST_F(SubKeyRequesterTest, StartRequest_RulesNotLoaded_WillNotLoad) {
   scoped_refptr<SubKeyReceiver> subkey_receiver_ = new SubKeyReceiver();
 
   SubKeyReceiverCallback cb =
       base::BindOnce(&SubKeyReceiver::OnSubKeysReceived, subkey_receiver_);
 
   // Make sure the rules will not be loaded in the StartRegionSubKeysRequest
   // call.
   requester_->ShouldLoadRules(false);
 
   // Start the normalization.
-  requester_->StartRegionSubKeysRequest(kLocale, 0, std::move(cb));
+  requester_->StartRegionSubKeysRequest(kLocale, kLanguage, 0, std::move(cb));
 
   // Let the timeout execute.
   base::RunLoop().RunUntilIdle();
 
   // Since the rules are never loaded and the timeout is 0, the delegate should
   // get notified that the subkeys could not be received.
   EXPECT_EQ(subkey_receiver_->subkeys_size(), kEmptySize);
 }
 
 // Tests that if the rules are not loaded before the call to
 // StartRegionSubKeysRequest, they will be loaded in the call.
 TEST_F(SubKeyRequesterTest, StartRequest_RulesNotLoaded_WillLoad) {
   scoped_refptr<SubKeyReceiver> subkey_receiver_ = new SubKeyReceiver();
 
   SubKeyReceiverCallback cb =
       base::BindOnce(&SubKeyReceiver::OnSubKeysReceived, subkey_receiver_);
 
   // Make sure the rules will not be loaded in the StartRegionSubKeysRequest
   // call.
   requester_->ShouldLoadRules(true);
   // Start the request.
-  requester_->StartRegionSubKeysRequest(kLocale, 0, std::move(cb));
+  requester_->StartRegionSubKeysRequest(kLocale, kLanguage, 0, std::move(cb));
 
   // Even if the rules are not loaded before the call to
   // StartRegionSubKeysRequest, they should get loaded in the call. Since our
   // test source is synchronous, the request will happen synchronously
   // too.
   EXPECT_TRUE(requester_->AreRulesLoadedForRegion(kLocale));
   EXPECT_EQ(subkey_receiver_->subkeys_size(), kCorrectSize);
 }
 
 }  // namespace payments