// 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/content/payment_request_spec.h"

#include <memory>
#include <utility>

#include "base/memory/weak_ptr.h"
#include "base/strings/utf_string_conversions.h"
#include "components/strings/grit/components_strings.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/mojom/payments/payment_request.mojom.h"
#include "ui/base/l10n/l10n_util.h"

namespace payments {

class PaymentRequestSpecTest : public testing::Test,
                               public PaymentRequestSpec::Observer {
 protected:
  ~PaymentRequestSpecTest() override {}

  void OnSpecUpdated() override { on_spec_updated_called_ = true; }

  void RecreateSpecWithMethodData(
      std::vector<mojom::PaymentMethodDataPtr> method_data) {
    spec_ = std::make_unique<PaymentRequestSpec>(
        mojom::PaymentOptions::New(), mojom::PaymentDetails::New(),
        std::move(method_data), this, "en-US");
  }

  void RecreateSpecWithOptionsAndDetails(mojom::PaymentOptionsPtr options,
                                         mojom::PaymentDetailsPtr details) {
    spec_ = std::make_unique<PaymentRequestSpec>(
        std::move(options), std::move(details),
        std::vector<mojom::PaymentMethodDataPtr>(), this, "en-US");
  }

  PaymentRequestSpec* spec() { return spec_.get(); }

 private:
  std::unique_ptr<PaymentRequestSpec> spec_;
  bool on_spec_updated_called_ = false;
};

// Test that empty method data is parsed correctly.
TEST_F(PaymentRequestSpecTest, EmptyMethodData) {
  std::vector<mojom::PaymentMethodDataPtr> method_data;
  RecreateSpecWithMethodData(std::move(method_data));

  // No supported card networks.
  EXPECT_EQ(0u, spec()->supported_card_networks().size());
}

TEST_F(PaymentRequestSpecTest, IsMethodSupportedThroughBasicCard) {
  mojom::PaymentMethodDataPtr entry1 = mojom::PaymentMethodData::New();
  entry1->supported_method = "visa";
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  entry2->supported_method = "mastercard";
  mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
  entry3->supported_method = "invalid";
  mojom::PaymentMethodDataPtr entry4 = mojom::PaymentMethodData::New();
  entry4->supported_method = "visa";
  mojom::PaymentMethodDataPtr entry5 = mojom::PaymentMethodData::New();
  entry5->supported_method = "basic-card";
  entry5->supported_networks.push_back(mojom::BasicCardNetwork::UNIONPAY);
  entry5->supported_networks.push_back(mojom::BasicCardNetwork::JCB);
  entry5->supported_networks.push_back(mojom::BasicCardNetwork::VISA);

  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry1));
  method_data.push_back(std::move(entry2));
  method_data.push_back(std::move(entry3));
  method_data.push_back(std::move(entry4));
  method_data.push_back(std::move(entry5));

  RecreateSpecWithMethodData(std::move(method_data));

  // unionpay and jcb are supported through basic-card. visa is supported
  // through basic card because it was specified in basic-card in addition to
  // supportedMethods.
  EXPECT_TRUE(spec()->IsMethodSupportedThroughBasicCard("unionpay"));
  EXPECT_TRUE(spec()->IsMethodSupportedThroughBasicCard("jcb"));
  EXPECT_TRUE(spec()->IsMethodSupportedThroughBasicCard("visa"));
  EXPECT_FALSE(spec()->IsMethodSupportedThroughBasicCard("mastercard"));
  EXPECT_FALSE(spec()->IsMethodSupportedThroughBasicCard("diners"));
  EXPECT_FALSE(spec()->IsMethodSupportedThroughBasicCard("garbage"));
}

// Order matters when parsing the supportedMethods and basic card networks.
TEST_F(PaymentRequestSpecTest,
       IsMethodSupportedThroughBasicCard_DifferentOrder) {
  mojom::PaymentMethodDataPtr entry1 = mojom::PaymentMethodData::New();
  entry1->supported_method = "basic-card";
  entry1->supported_networks.push_back(mojom::BasicCardNetwork::UNIONPAY);
  entry1->supported_networks.push_back(mojom::BasicCardNetwork::VISA);
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  entry2->supported_method = "visa";
  mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
  entry3->supported_method = "unionpay";
  mojom::PaymentMethodDataPtr entry4 = mojom::PaymentMethodData::New();
  entry4->supported_method = "jcb";

  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry1));
  method_data.push_back(std::move(entry2));
  method_data.push_back(std::move(entry3));
  method_data.push_back(std::move(entry4));

  RecreateSpecWithMethodData(std::move(method_data));

  // unionpay and visa are supported through basic-card; they were specified
  // first as basic card networks.
  EXPECT_TRUE(spec()->IsMethodSupportedThroughBasicCard("unionpay"));
  EXPECT_TRUE(spec()->IsMethodSupportedThroughBasicCard("visa"));
  // "jcb" is NOT supported through basic card; it was specified directly
  // as a supportedMethods
  EXPECT_FALSE(spec()->IsMethodSupportedThroughBasicCard("jcb"));
}

// Test that parsing supported methods (with invalid values and duplicates)
// works as expected.
TEST_F(PaymentRequestSpecTest, SupportedMethods) {
  mojom::PaymentMethodDataPtr entry1 = mojom::PaymentMethodData::New();
  entry1->supported_method = "visa";
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  entry2->supported_method = "mastercard";
  mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
  entry3->supported_method = "invalid";
  mojom::PaymentMethodDataPtr entry4 = mojom::PaymentMethodData::New();
  entry4->supported_method = "";
  mojom::PaymentMethodDataPtr entry5 = mojom::PaymentMethodData::New();
  entry5->supported_method = "visa";
  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry1));
  method_data.push_back(std::move(entry2));
  method_data.push_back(std::move(entry3));
  method_data.push_back(std::move(entry4));
  method_data.push_back(std::move(entry5));

  RecreateSpecWithMethodData(std::move(method_data));

  // Only "visa" and "mastercard" remain, in order.
  EXPECT_EQ(2u, spec()->supported_card_networks().size());
  EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
  EXPECT_EQ("mastercard", spec()->supported_card_networks()[1]);
}

// Test that parsing supported methods in different method data entries (with
// invalid values and duplicates) works as expected.
TEST_F(PaymentRequestSpecTest, SupportedMethods_MultipleEntries) {
  mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
  entry->supported_method = "visa";
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  entry2->supported_method = "mastercard";
  mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
  entry3->supported_method = "invalid";

  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry));
  method_data.push_back(std::move(entry2));
  method_data.push_back(std::move(entry3));

  RecreateSpecWithMethodData(std::move(method_data));

  // Only "visa" and "mastercard" remain, in order.
  EXPECT_EQ(2u, spec()->supported_card_networks().size());
  EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
  EXPECT_EQ("mastercard", spec()->supported_card_networks()[1]);
}

// Test that parsing supported methods in different method data entries fails as
// soon as one entry doesn't specify anything in supported_methods.
TEST_F(PaymentRequestSpecTest, SupportedMethods_MultipleEntries_OneEmpty) {
  // First entry is valid.
  mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
  entry->supported_method = "visa";
  // Empty method data entry.
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  // Valid one follows the empty.
  mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
  entry3->supported_method = "mastercard";

  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry));
  method_data.push_back(std::move(entry2));
  method_data.push_back(std::move(entry3));

  RecreateSpecWithMethodData(std::move(method_data));

  // Visa was parsed, but not mastercard.
  EXPECT_EQ(1u, spec()->supported_card_networks().size());
  EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
}

// Test that only specifying basic-card means that all are supported.
TEST_F(PaymentRequestSpecTest, SupportedMethods_OnlyBasicCard) {
  mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
  entry->supported_method = "basic-card";
  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry));

  RecreateSpecWithMethodData(std::move(method_data));

  // All of the basic card networks are supported.
  EXPECT_EQ(8u, spec()->supported_card_networks().size());
  EXPECT_EQ("amex", spec()->supported_card_networks()[0]);
  EXPECT_EQ("diners", spec()->supported_card_networks()[1]);
  EXPECT_EQ("discover", spec()->supported_card_networks()[2]);
  EXPECT_EQ("jcb", spec()->supported_card_networks()[3]);
  EXPECT_EQ("mastercard", spec()->supported_card_networks()[4]);
  EXPECT_EQ("mir", spec()->supported_card_networks()[5]);
  EXPECT_EQ("unionpay", spec()->supported_card_networks()[6]);
  EXPECT_EQ("visa", spec()->supported_card_networks()[7]);
}

// Test that specifying a method AND basic-card means that all are supported,
// but with the method as first.
TEST_F(PaymentRequestSpecTest, SupportedMethods_BasicCard_WithSpecificMethod) {
  mojom::PaymentMethodDataPtr entry1 = mojom::PaymentMethodData::New();
  entry1->supported_method = "jcb";
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  entry2->supported_method = "basic-card";
  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry1));
  method_data.push_back(std::move(entry2));

  RecreateSpecWithMethodData(std::move(method_data));

  // All of the basic card networks are supported, but JCB is first because it
  // was specified first.
  EXPECT_EQ(8u, spec()->supported_card_networks().size());
  EXPECT_EQ("jcb", spec()->supported_card_networks()[0]);
  EXPECT_EQ("amex", spec()->supported_card_networks()[1]);
  EXPECT_EQ("diners", spec()->supported_card_networks()[2]);
  EXPECT_EQ("discover", spec()->supported_card_networks()[3]);
  EXPECT_EQ("mastercard", spec()->supported_card_networks()[4]);
  EXPECT_EQ("mir", spec()->supported_card_networks()[5]);
  EXPECT_EQ("unionpay", spec()->supported_card_networks()[6]);
  EXPECT_EQ("visa", spec()->supported_card_networks()[7]);
}

// Test that specifying basic-card with a supported network (with previous
// supported methods) will work as expected
TEST_F(PaymentRequestSpecTest, SupportedMethods_BasicCard_Overlap) {
  mojom::PaymentMethodDataPtr entry1 = mojom::PaymentMethodData::New();
  entry1->supported_method = "mastercard";
  mojom::PaymentMethodDataPtr entry2 = mojom::PaymentMethodData::New();
  entry2->supported_method = "visa";
  // Visa and mastercard are repeated, but in reverse order.
  mojom::PaymentMethodDataPtr entry3 = mojom::PaymentMethodData::New();
  entry3->supported_method = "basic-card";
  entry3->supported_networks.push_back(mojom::BasicCardNetwork::VISA);
  entry3->supported_networks.push_back(mojom::BasicCardNetwork::MASTERCARD);
  entry3->supported_networks.push_back(mojom::BasicCardNetwork::UNIONPAY);
  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry1));
  method_data.push_back(std::move(entry2));
  method_data.push_back(std::move(entry3));

  RecreateSpecWithMethodData(std::move(method_data));

  EXPECT_EQ(3u, spec()->supported_card_networks().size());
  EXPECT_EQ("mastercard", spec()->supported_card_networks()[0]);
  EXPECT_EQ("visa", spec()->supported_card_networks()[1]);
  EXPECT_EQ("unionpay", spec()->supported_card_networks()[2]);
}

// Test that specifying basic-card with supported networks after specifying
// some methods
TEST_F(PaymentRequestSpecTest,
       SupportedMethods_BasicCard_WithSupportedNetworks) {
  mojom::PaymentMethodDataPtr entry = mojom::PaymentMethodData::New();
  entry->supported_method = "basic-card";
  entry->supported_networks.push_back(mojom::BasicCardNetwork::VISA);
  entry->supported_networks.push_back(mojom::BasicCardNetwork::UNIONPAY);
  std::vector<mojom::PaymentMethodDataPtr> method_data;
  method_data.push_back(std::move(entry));

  RecreateSpecWithMethodData(std::move(method_data));

  // Only the specified networks are supported.
  EXPECT_EQ(2u, spec()->supported_card_networks().size());
  EXPECT_EQ("visa", spec()->supported_card_networks()[0]);
  EXPECT_EQ("unionpay", spec()->supported_card_networks()[1]);
}

// Test that the last shipping option is selected, even in the case of
// updateWith.
TEST_F(PaymentRequestSpecTest, ShippingOptionsSelection) {
  std::vector<mojom::PaymentShippingOptionPtr> shipping_options;
  mojom::PaymentShippingOptionPtr option = mojom::PaymentShippingOption::New();
  option->id = "option:1";
  option->selected = false;
  shipping_options.push_back(std::move(option));
  mojom::PaymentShippingOptionPtr option2 = mojom::PaymentShippingOption::New();
  option2->id = "option:2";
  option2->selected = true;
  shipping_options.push_back(std::move(option2));
  mojom::PaymentDetailsPtr details = mojom::PaymentDetails::New();
  details->shipping_options = std::move(shipping_options);

  mojom::PaymentOptionsPtr options = mojom::PaymentOptions::New();
  options->request_shipping = true;
  RecreateSpecWithOptionsAndDetails(std::move(options), std::move(details));

  EXPECT_EQ("option:2", spec()->selected_shipping_option()->id);
  EXPECT_TRUE(spec()->selected_shipping_option_error().empty());

  // Call updateWith with option:1 now selected.
  std::vector<mojom::PaymentShippingOptionPtr> new_shipping_options;
  mojom::PaymentShippingOptionPtr new_option =
      mojom::PaymentShippingOption::New();
  new_option->id = "option:1";
  new_option->selected = true;
  new_shipping_options.push_back(std::move(new_option));
  mojom::PaymentShippingOptionPtr new_option2 =
      mojom::PaymentShippingOption::New();
  new_option2->id = "option:2";
  new_option2->selected = false;
  new_shipping_options.push_back(std::move(new_option2));
  mojom::PaymentDetailsPtr new_details = mojom::PaymentDetails::New();
  new_details->shipping_options = std::move(new_shipping_options);

  spec()->UpdateWith(std::move(new_details));

  EXPECT_EQ("option:1", spec()->selected_shipping_option()->id);
  EXPECT_TRUE(spec()->selected_shipping_option_error().empty());
}

// Test that the last shipping option is selected, even in the case of
// updateWith.
TEST_F(PaymentRequestSpecTest, ShippingOptionsSelection_NoOptionsAtAll) {
  // No options are provided at first.
  mojom::PaymentOptionsPtr options = mojom::PaymentOptions::New();
  options->request_shipping = true;
  RecreateSpecWithOptionsAndDetails(std::move(options),
                                    mojom::PaymentDetails::New());

  // No option selected, but no error either (the flow just started and no
  // address has been selected yet).
  EXPECT_EQ(nullptr, spec()->selected_shipping_option());
  EXPECT_TRUE(spec()->selected_shipping_option_error().empty());

  // Call updateWith with still no options.
  spec()->UpdateWith(mojom::PaymentDetails::New());

  // Now it's more serious. No option selected, but there is a generic error.
  EXPECT_EQ(nullptr, spec()->selected_shipping_option());
  EXPECT_EQ(
      l10n_util::GetStringUTF16(IDS_PAYMENTS_UNSUPPORTED_SHIPPING_ADDRESS),
      spec()->selected_shipping_option_error());

  // Call updateWith with still no options, but a customized error string.
  mojom::PaymentDetailsPtr details = mojom::PaymentDetails::New();
  details->error = "No can do shipping.";
  spec()->UpdateWith(std::move(details));

  // No option selected, but there is an error provided by the mercahnt.
  EXPECT_EQ(nullptr, spec()->selected_shipping_option());
  EXPECT_EQ(base::ASCIIToUTF16("No can do shipping."),
            spec()->selected_shipping_option_error());
}

TEST_F(PaymentRequestSpecTest, SingleCurrencyWithoutDisplayItems) {
  mojom::PaymentDetailsPtr details = mojom::PaymentDetails::New();
  mojom::PaymentItemPtr total = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr amount = mojom::PaymentCurrencyAmount::New();
  amount->currency = "USD";
  total->amount = std::move(amount);
  details->total = std::move(total);

  RecreateSpecWithOptionsAndDetails(mojom::PaymentOptions::New(),
                                    std::move(details));
  // If the request only has a total, it must not have mixed currencies.
  EXPECT_FALSE(spec()->IsMixedCurrency());
}

TEST_F(PaymentRequestSpecTest, SingleCurrencyWithDisplayItems) {
  mojom::PaymentDetailsPtr details = mojom::PaymentDetails::New();
  mojom::PaymentItemPtr total = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr amount = mojom::PaymentCurrencyAmount::New();
  amount->currency = "USD";
  total->amount = std::move(amount);
  details->total = std::move(total);

  mojom::PaymentItemPtr display_item = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr display_amount =
      mojom::PaymentCurrencyAmount::New();
  display_amount->currency = "USD";
  display_item->amount = std::move(display_amount);
  details->display_items.push_back(std::move(display_item));

  RecreateSpecWithOptionsAndDetails(mojom::PaymentOptions::New(),
                                    std::move(details));
  // Both the total and the display item have matching currency codes, this
  // isn't a mixed currency case.
  EXPECT_FALSE(spec()->IsMixedCurrency());
}

TEST_F(PaymentRequestSpecTest, MultipleCurrenciesWithOneDisplayItem) {
  mojom::PaymentDetailsPtr details = mojom::PaymentDetails::New();
  mojom::PaymentItemPtr total = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr amount = mojom::PaymentCurrencyAmount::New();
  amount->currency = "USD";
  total->amount = std::move(amount);
  details->total = std::move(total);

  mojom::PaymentItemPtr display_item = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr display_amount =
      mojom::PaymentCurrencyAmount::New();
  display_amount->currency = "CAD";
  display_item->amount = std::move(display_amount);
  details->display_items.push_back(std::move(display_item));

  RecreateSpecWithOptionsAndDetails(mojom::PaymentOptions::New(),
                                    std::move(details));

  // The display item currency and the total's currency don't match, this is a
  // mixed currencies case.
  EXPECT_TRUE(spec()->IsMixedCurrency());
}

TEST_F(PaymentRequestSpecTest, MultipleCurrenciesWithTwoDisplayItem) {
  mojom::PaymentDetailsPtr details = mojom::PaymentDetails::New();
  mojom::PaymentItemPtr total = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr amount = mojom::PaymentCurrencyAmount::New();
  amount->currency = "USD";
  total->amount = std::move(amount);
  details->total = std::move(total);

  mojom::PaymentItemPtr display_item1 = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr display_amount1 =
      mojom::PaymentCurrencyAmount::New();
  display_amount1->currency = "CAD";
  display_item1->amount = std::move(display_amount1);
  details->display_items.push_back(std::move(display_item1));

  mojom::PaymentItemPtr display_item2 = mojom::PaymentItem::New();
  mojom::PaymentCurrencyAmountPtr display_amount2 =
      mojom::PaymentCurrencyAmount::New();
  display_amount2->currency = "USD";
  display_item2->amount = std::move(display_amount2);
  details->display_items.push_back(std::move(display_item2));

  RecreateSpecWithOptionsAndDetails(mojom::PaymentOptions::New(),
                                    std::move(details));

  // At least one of the display items has a different currency, this is a mixed
  // currency case.
  EXPECT_TRUE(spec()->IsMixedCurrency());
}

TEST_F(PaymentRequestSpecTest, ShippingAddressErrors) {
  mojom::PaymentOptionsPtr options = mojom::PaymentOptions::New();
  options->request_shipping = true;
  RecreateSpecWithOptionsAndDetails(std::move(options),
                                    mojom::PaymentDetails::New());

  EXPECT_FALSE(spec()->has_shipping_address_error());

  mojom::AddressErrorsPtr shipping_address_errors = mojom::AddressErrors::New();
  shipping_address_errors->address_line = "Invalid address line";
  shipping_address_errors->city = "Invalid city";
  spec()->UpdateShippingAddressErrors(std::move(shipping_address_errors));

  EXPECT_EQ(base::UTF8ToUTF16("Invalid city"),
            spec()->GetShippingAddressError(autofill::ADDRESS_HOME_CITY));
  EXPECT_EQ(
      base::UTF8ToUTF16("Invalid address line"),
      spec()->GetShippingAddressError(autofill::ADDRESS_HOME_STREET_ADDRESS));

  EXPECT_TRUE(spec()->has_shipping_address_error());
}

TEST_F(PaymentRequestSpecTest, PayerErrors) {
  mojom::PaymentOptionsPtr options = mojom::PaymentOptions::New();
  options->request_payer_email = true;
  options->request_payer_name = true;
  options->request_payer_phone = true;
  RecreateSpecWithOptionsAndDetails(std::move(options),
                                    mojom::PaymentDetails::New());

  EXPECT_FALSE(spec()->has_payer_error());

  mojom::PayerErrorFieldsPtr payer_errors = mojom::PayerErrorFields::New();
  payer_errors->email = "Invalid email";
  payer_errors->name = "Invalid name";
  payer_errors->phone = "Invalid phone";
  spec()->UpdatePayerErrors(std::move(payer_errors));

  EXPECT_EQ(base::UTF8ToUTF16("Invalid email"),
            spec()->GetPayerError(autofill::EMAIL_ADDRESS));
  EXPECT_EQ(base::UTF8ToUTF16("Invalid name"),
            spec()->GetPayerError(autofill::NAME_FULL));
  EXPECT_EQ(base::UTF8ToUTF16("Invalid phone"),
            spec()->GetPayerError(autofill::PHONE_HOME_WHOLE_NUMBER));

  EXPECT_TRUE(spec()->has_payer_error());
}

}  // namespace payments