# frozen_string_literal: true

require ::File.expand_path("../test_helper", __dir__)

module Stripe
  class CustomerTest < Test::Unit::TestCase
    should "be listable" do
      customers = Stripe::Customer.list
      assert_requested :get, "#{Stripe.api_base}/v1/customers"
      assert customers.data.is_a?(Array)
      assert customers.first.is_a?(Stripe::Customer)
    end

    should "be retrievable" do
      customer = Stripe::Customer.retrieve("cus_123")
      assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123"
      assert customer.is_a?(Stripe::Customer)
    end

    should "be creatable" do
      customer = Stripe::Customer.create
      assert_requested :post, "#{Stripe.api_base}/v1/customers"
      assert customer.is_a?(Stripe::Customer)
    end

    should "be saveable" do
      customer = Stripe::Customer.retrieve("cus_123")
      customer.metadata["key"] = "value"
      customer.save
      assert_requested :post, "#{Stripe.api_base}/v1/customers/#{customer.id}"
    end

    should "be updateable" do
      customer = Stripe::Customer.update("cus_123", metadata: { key: "value" })
      assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123"
      assert customer.is_a?(Stripe::Customer)
    end

    context "#delete" do
      should "be deletable" do
        customer = Stripe::Customer.retrieve("cus_123")
        customer = customer.delete
        assert_requested :delete, "#{Stripe.api_base}/v1/customers/#{customer.id}"
        assert customer.is_a?(Stripe::Customer)
      end
    end

    context ".delete" do
      should "be deletable" do
        customer = Stripe::Customer.delete("cus_123")
        assert_requested :delete, "#{Stripe.api_base}/v1/customers/cus_123"
        assert customer.is_a?(Stripe::Customer)
      end
    end

    context "#delete_discount" do
      should "delete a discount" do
        customer = Stripe::Customer.retrieve("cus_123")
        discount = customer.delete_discount
        assert_requested :delete, "#{Stripe.api_base}/v1/customers/cus_123/discount"
        assert discount.is_a?(Stripe::Discount)
      end
    end

    context ".delete_discount" do
      should "delete a discount" do
        discount = Stripe::Customer.delete_discount("cus_123")
        assert_requested :delete, "#{Stripe.api_base}/v1/customers/cus_123/discount"
        assert discount.is_a?(Stripe::Discount)
      end
    end

    context "#create_source" do
      should "create a source" do
        Stripe::Customer.create_source(
          "cus_123",
          source: "tok_123"
        )
        assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/sources"
      end
    end

    context "#retrieve_source" do
      should "retrieve a source" do
        Stripe::Customer.retrieve_source(
          "cus_123",
          "ba_123"
        )
        assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/sources/ba_123"
      end
    end

    context "#update_source" do
      should "update a source" do
        Stripe::Customer.update_source(
          "cus_123",
          "ba_123",
          metadata: { foo: "bar" }
        )
        assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/sources/ba_123"
      end
    end

    context "#delete_source" do
      should "delete a source" do
        Stripe::Customer.delete_source(
          "cus_123",
          "ba_123"
        )
        assert_requested :delete, "#{Stripe.api_base}/v1/customers/cus_123/sources/ba_123"
      end
    end

    context "#list_sources" do
      should "list the customer's sources" do
        sources = Stripe::Customer.list_sources(
          "cus_123"
        )
        assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/sources"
        assert sources.is_a?(Stripe::ListObject)
        assert sources.data.is_a?(Array)
      end
    end

    context "source field" do
      should "allow setting source with token" do
        c = Stripe::Customer.new("test_customer")
        c.source = "tok_123"
        assert_equal "tok_123", c.source
      end

      should "allow setting source with hash and set flag" do
        c = Stripe::Customer.new("test_customer")
        c.source = {
          object: "card",
        }
        assert_equal true, c.source.save_with_parent
      end
    end

    context "#create_tax_id" do
      should "create a tax id" do
        Stripe::Customer.create_tax_id(
          "cus_123",
          type: "eu_vat",
          value: "11111"
        )
        assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/tax_ids"
      end
    end

    context "#retrieve_tax_id" do
      should "retrieve a tax id" do
        Stripe::Customer.retrieve_tax_id(
          "cus_123",
          "txi_123"
        )
        assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/tax_ids/txi_123"
      end
    end

    context "#delete_tax_id" do
      should "delete a tax id" do
        Stripe::Customer.delete_tax_id(
          "cus_123",
          "txi_123"
        )
        assert_requested :delete, "#{Stripe.api_base}/v1/customers/cus_123/tax_ids/txi_123"
      end
    end

    context "#list_tax_ids" do
      should "list the customer's tax ids" do
        sources = Stripe::Customer.list_tax_ids(
          "cus_123"
        )
        assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/tax_ids"
        assert sources.is_a?(Stripe::ListObject)
        assert sources.data.is_a?(Array)
      end
    end

    context "#create_balance_transaction" do
      should "create a customer balance transaction" do
        Stripe::Customer.create_balance_transaction(
          "cus_123",
          amount: 1234,
          currency: "usd"
        )
        assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/balance_transactions"
      end
    end

    context "#retrieve_balance_transaction" do
      should "retrieve a customer balance transaction" do
        Stripe::Customer.retrieve_balance_transaction(
          "cus_123",
          "cbtxn_123"
        )
        assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/balance_transactions/cbtxn_123"
      end
    end

    context "#update_balance_transaction" do
      should "update a customer balance transaction" do
        Stripe::Customer.update_balance_transaction(
          "cus_123",
          "cbtxn_123",
          description: "new"
        )
        assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/balance_transactions/cbtxn_123"
      end
    end

    context "#list_balance_transactions" do
      should "list the customer balance transactions" do
        sources = Stripe::Customer.list_balance_transactions(
          "cus_123"
        )
        assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/balance_transactions"
        assert sources.is_a?(Stripe::ListObject)
        assert sources.data.is_a?(Array)
      end
    end

    context "cash_balance compatibility" do
      # These tests are present for compatibility purposes. Previously the cash
      # balance methods required nil as a second nested_id parameter. The method
      # has been patched to no longer require this, but we want to preserve
      # compatibility for existing users.

      context "#retrieve_cash_balance" do
        should "legacy call pattern - retrieve_cash_balance(customer_id, nil)" do
          Stripe::Customer.retrieve_cash_balance("cus_123", nil)
          assert_requested :get, "#{Stripe.api_base}/v1/customers/cus_123/cash_balance"
        end

        should "legacy call pattern - retrieve_cash_balance(customer_id, nil, opts)" do
          # Assert that we're actually making a change by swapping out the API base.
          assert Stripe.api_base != Stripe.connect_base

          Stripe::Customer.retrieve_cash_balance("cus_123", nil, { api_base: Stripe.connect_base })
          assert_requested :get, "#{Stripe.connect_base}/v1/customers/cus_123/cash_balance"
        end

        should "modern call pattern - retrieve_cash_balance(customer_id, opts)" do
          # Assert that we're actually making a change by swapping out the API base.
          assert Stripe.api_base != Stripe.connect_base

          Stripe::Customer.retrieve_cash_balance("cus_123", { api_base: Stripe.connect_base })
          assert_requested :get, "#{Stripe.connect_base}/v1/customers/cus_123/cash_balance"
        end
      end

      context "#update_cash_balance" do
        should "legacy call pattern - update_cash_balance(customer, nil, params)" do
          Stripe::Customer.update_cash_balance("cus_123", nil, { settings: { reconciliation_mode: "manual" } })

          assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/cash_balance" do |req|
            req.body == "settings[reconciliation_mode]=manual"
          end
        end

        should "legacy call pattern - update_cash_balance(customer, nil, params, opts)" do
          # Assert that we're actually making a change by swapping out the API base.
          assert Stripe.api_base != Stripe.connect_base

          Stripe::Customer.update_cash_balance(
            "cus_123",
            nil,
            { settings: { reconciliation_mode: "manual" } },
            { api_base: Stripe.connect_base }
          )

          assert_requested :post, "#{Stripe.connect_base}/v1/customers/cus_123/cash_balance" do |req|
            req.body == "settings[reconciliation_mode]=manual"
          end
        end

        should "modern call pattern - update_cash_balance(customer)" do
          Stripe::Customer.update_cash_balance("cus_123")

          assert_requested :post, "#{Stripe.api_base}/v1/customers/cus_123/cash_balance"
        end

        should "modern call pattern - fail if passing in hash to second argument" do
          # We catch this on purpose to avoid mis-using the call as is.
          # Unfortunately we can't automatically shift over arguments (eg.
          # update_cash_balance(customer_id, params, opts) ->
          # update_cash_balance(customer_id, nil, params, opts)) since we have
          # the problematic case of update_cash_balance(customer_id, nil, hash)
          # where we can't differentiate params and opts for the second hash.
          e = assert_raises(ArgumentError) do
            Stripe::Customer.update_cash_balance("cus_123", { settings: { reconciliation_mode: "manual" } })
          end
          assert_match("update_cash_balance requires the second argument always be nil", e.message)
        end
      end
    end
  end
end