Layered component for web payments

components/payments/core/address_normalizer_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/address_normalizer.h"
+#include "components/payments/core/address_normalizer.h"
 
-#include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "components/autofill/core/browser/autofill_profile.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 ::autofill::AutofillProfile;
 using ::i18n::addressinput::NullStorage;
 using ::i18n::addressinput::Source;
 using ::i18n::addressinput::Storage;
 using ::i18n::addressinput::TestdataSource;
 
 // The requester of normalization for this test.
 class NormalizationDelegate : public AddressNormalizer::Delegate {
  public:
   NormalizationDelegate()
       : normalized_called_(false), not_normalized_called_(false) {}
 
   ~NormalizationDelegate() override {}
 
   void OnAddressNormalized(
       const autofill::AutofillProfile& normalized_profile) override {
     normalized_called_ = true;
   }
 
   void OnCouldNotNormalize(const autofill::AutofillProfile& profile) override {
     not_normalized_called_ = true;
   }
 
   bool normalized_called() { return normalized_called_; }
 
   bool not_normalized_called() { return not_normalized_called_; }
 
  private:
   bool normalized_called_;
   bool not_normalized_called_;
+
+  DISALLOW_COPY_AND_ASSIGN(NormalizationDelegate);
 };
 
 // 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 "US".
   void Get(const std::string& key, const Callback& data_ready) const override {
     data_ready(
         true, key,
         new std::string("{\"data/US\": "
                         "{\"id\":\"data/US\",\"key\":\"US\",\"name\":\"UNITED "
                         "STATES\",\"lang\":\"en\",\"languages\":\"en\"}}"));
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromiumTestdataSource);
 };
 
 // A test subclass of the AddressNormalizer. Used to simulate rules not being
 // loaded.
 class TestAddressNormalizer : public AddressNormalizer {
  public:
   TestAddressNormalizer(std::unique_ptr<i18n::addressinput::Source> source,
                         std::unique_ptr<i18n::addressinput::Storage> storage)
       : AddressNormalizer(std::move(source), std::move(storage)),
         should_load_rules_(true) {}
 
   ~TestAddressNormalizer() override {}
 
   void ShouldLoadRules(bool should_load_rules) {
     should_load_rules_ = should_load_rules;
   }
 
   void LoadRulesForRegion(const std::string& region_code) override {
     if (should_load_rules_) {
       AddressNormalizer::LoadRulesForRegion(region_code);
     }
   }
 
  private:
   bool should_load_rules_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestAddressNormalizer);
 };
 
 }  // namespace
 
 class AddressNormalizerTest : public testing::Test {
  protected:
   AddressNormalizerTest()
       : normalizer_(new TestAddressNormalizer(
             std::unique_ptr<Source>(new ChromiumTestdataSource),
             std::unique_ptr<Storage>(new NullStorage))) {}
@@ skipping 73 matching lines @@
   // Even if the rules are not loaded before the call to
   // StartAddressNormalization, they should get loaded in the call. Since our
   // test source is synchronous, the normalization will happen synchronously
   // too.
   EXPECT_TRUE(normalizer_->AreRulesLoadedForRegion("US"));
   EXPECT_TRUE(delegate.normalized_called());
   EXPECT_FALSE(delegate.not_normalized_called());
 }
 
 }  // namespace payments