braintree 4.34.0 → 4.36.0

data/spec/unit/braintree/customer_spec.rb

@@ -28,7 +28,8 @@ describe Braintree::Customer do
       expect(output).to include(%q(first_name: "Patrick"))
       expect(output).to include(%q(last_name: "Smith"))
       expect(output).to include(%q(phone: "802-483-5932"))
-      expect(output).to include(%q(international_phone: {:country_code=>"1", :national_number=>"3121234567"}))
+      international_phone_hash = {:country_code => "1", :national_number => "3121234567"}.inspect
+      expect(output).to include("international_phone: #{international_phone_hash}")
       expect(output).to include(%q(website: "patrick.smith.com"))
       expect(output).to include(%q(addresses: []))
       expect(output).to include(%q(credit_cards: []))
@@ -91,6 +92,38 @@ describe Braintree::Customer do
         :device_data,
         :payment_method_nonce,
         {:risk_data => [:customer_browser, :customer_ip]},
+        {:apple_pay_card => [
+          :cardholder_name,
+          :cryptogram,
+          :eci_indicator,
+          :expiration_month,
+          :expiration_year,
+          :network_transaction_id,
+          :number,
+          :token,
+          {:billing_address => [
+            :company,
+            :country_code_alpha2,
+            :country_code_alpha3,
+            :country_code_numeric,
+            :country_name,
+            :extended_address,
+            :first_name,
+            {:international_phone=>[:country_code, :national_number]},
+            :last_name,
+            :locality,
+            :phone_number,
+            :postal_code,
+            :region,
+            :street_address
+          ]},
+          {:options => match_array([
+            :verification_account_type,
+            :verification_amount,
+            :verification_merchant_account_id,
+            :verify_card
+          ])},
+        ]},
         {:credit_card => [
           :billing_address_id,
           :cardholder_name,
@@ -188,6 +221,39 @@ describe Braintree::Customer do
         :device_data,
         :payment_method_nonce,
         :default_payment_method_token,
+        {:apple_pay_card => [
+          :cardholder_name,
+          :cryptogram,
+          :eci_indicator,
+          :expiration_month,
+          :expiration_year,
+          :network_transaction_id,
+          :number,
+          :token,
+          {:billing_address => [
+            :company,
+            :country_code_alpha2,
+            :country_code_alpha3,
+            :country_code_numeric,
+            :country_name,
+            :extended_address,
+            :first_name,
+            {:international_phone=>[:country_code, :national_number]},
+            :last_name,
+            :locality,
+            :phone_number,
+            :postal_code,
+            :region,
+            :street_address
+          ]},
+          {:options => match_array([
+            :make_default,
+            :verification_account_type,
+            :verification_amount,
+            :verification_merchant_account_id,
+            :verify_card
+          ])},
+        ]},
         {:credit_card => [
           :billing_address_id,
           :cardholder_name,

data/spec/unit/braintree/graphql/billing_address_input_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::BillingAddressInput do
+  describe "#initialize" do
+    it "initializes with all attributes" do
+      attributes = {
+        street_address: "123 Main St",
+        extended_address: "Apt 4B",
+        locality: "Mexico City",
+        region: "CDMX",
+        postal_code: "01000",
+        country_code_alpha2: "MX"
+      }
+      input = Braintree::BillingAddressInput.new(attributes)
+
+      expect(input.street_address).to eq("123 Main St")
+      expect(input.extended_address).to eq("Apt 4B")
+      expect(input.locality).to eq("Mexico City")
+      expect(input.region).to eq("CDMX")
+      expect(input.postal_code).to eq("01000")
+      expect(input.country_code_alpha2).to eq("MX")
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      attributes = {
+        street_address: "123 Main St",
+        locality: "Mexico City",
+        postal_code: "01000",
+        country_code_alpha2: "MX"
+      }
+      input = Braintree::BillingAddressInput.new(attributes)
+      expected_variables = {
+        "streetAddress" => "123 Main St",
+        "locality" => "Mexico City",
+        "postalCode" => "01000",
+        "countryCode" => "MX"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "omits nil values" do
+      attributes = {street_address: "123 Main St"}
+      input = Braintree::BillingAddressInput.new(attributes)
+      expected_variables = {"streetAddress" => "123 Main St"}
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      attributes = {
+        street_address: "123 Main St",
+        locality: "Mexico City",
+        postal_code: "01000"
+      }
+      input = Braintree::BillingAddressInput.new(attributes)
+      result = input.inspect
+
+      expect(result).to include("BillingAddressInput")
+      expect(result).to include("street_address:")
+      expect(result).to include("locality:")
+    end
+  end
+end

data/spec/unit/braintree/graphql/create_local_payment_context_input_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::CreateLocalPaymentContextInput do
+  let(:input_data) do
+    {
+      amount: {value: "10.00", currency_code: "EUR"},
+      type: Braintree::LocalPaymentType::MBWAY,
+      payer_info: {
+        given_name: "John",
+        surname: "Doe"
+      },
+      order_id: "order-123"
+    }
+  end
+
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CreateLocalPaymentContextInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.type).to eq(Braintree::LocalPaymentType::MBWAY)
+      expect(input.order_id).to eq("order-123")
+      expect(input.amount).to be_a(Braintree::MonetaryAmountInput)
+      expect(input.payer_info).to be_a(Braintree::PayerInfoInput)
+    end
+
+    it "handles nil payer_info" do
+      attributes = {amount: {value: "10.00", currency_code: "EUR"}, type: "OXXO"}
+      input = Braintree::CreateLocalPaymentContextInput.new(attributes)
+      expect(input.payer_info).to be_nil
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      input = Braintree::CreateLocalPaymentContextInput.new(input_data)
+      expected_variables = {
+        "paymentContext" => {
+          "amount" => {"value" => "10.00", "currencyCode" => "EUR"},
+          "orderId" => "order-123",
+          "payerInfo" => {
+            "givenName" => "John",
+            "surname" => "Doe"
+          },
+          "type" => Braintree::LocalPaymentType::MBWAY
+        }
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      input = Braintree::CreateLocalPaymentContextInput.new(input_data)
+      result = input.inspect
+
+      expect(result).to include("CreateLocalPaymentContextInput")
+      expect(result).to include("amount:")
+      expect(result).to include("type:")
+    end
+  end
+end

data/spec/unit/braintree/graphql/monetary_amount_input_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::MonetaryAmountInput do
+  describe "#initialize" do
+    it "initializes with all attributes" do
+      attributes = {
+        value: "10.00",
+        currency_code: "USD"
+      }
+      input = Braintree::MonetaryAmountInput.new(attributes)
+
+      expect(input.value).to eq("10.00")
+      expect(input.currency_code).to eq("USD")
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      attributes = {
+        value: "25.50",
+        currency_code: "EUR"
+      }
+      input = Braintree::MonetaryAmountInput.new(attributes)
+      expected_variables = {
+        "value" => "25.50",
+        "currencyCode" => "EUR"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "omits nil values" do
+      attributes = {value: "10.00"}
+      input = Braintree::MonetaryAmountInput.new(attributes)
+      expected_variables = {"value" => "10.00"}
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      attributes = {
+        value: "25.50",
+        currency_code: "EUR"
+      }
+      input = Braintree::MonetaryAmountInput.new(attributes)
+      result = input.inspect
+
+      expect(result).to include("MonetaryAmountInput")
+      expect(result).to include("value:")
+      expect(result).to include("currency_code:")
+    end
+  end
+end

data/spec/unit/braintree/graphql/payer_info_input_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::PayerInfoInput do
+  describe "#initialize" do
+    it "initializes with all attributes" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        phone_country_code: "+351",
+        phone_number: "912345678",
+        billing_address: {
+          street_address: "123 Main St",
+          locality: "Lisbon"
+        }
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+
+      expect(input.given_name).to eq("John")
+      expect(input.surname).to eq("Doe")
+      expect(input.phone_country_code).to eq("+351")
+      expect(input.phone_number).to eq("912345678")
+      expect(input.billing_address).to be_a(Braintree::BillingAddressInput)
+    end
+
+    it "handles nil billing_address" do
+      attributes = {given_name: "John", surname: "Doe"}
+      input = Braintree::PayerInfoInput.new(attributes)
+      expect(input.billing_address).to be_nil
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        phone_country_code: "+351",
+        phone_number: "912345678"
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+      expected_variables = {
+        "givenName" => "John",
+        "phoneCountryCode" => "+351",
+        "phoneNumber" => "912345678",
+        "surname" => "Doe"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "includes nested billing_address" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        billing_address: {
+          street_address: "123 Main St",
+          postal_code: "1000-001"
+        }
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+      variables = input.to_graphql_variables
+
+      expect(variables["billingAddress"]).to be_a(Hash)
+      expect(variables["billingAddress"]["streetAddress"]).to eq("123 Main St")
+      expect(variables["billingAddress"]["postalCode"]).to eq("1000-001")
+    end
+
+    it "omits nil values" do
+      attributes = {given_name: "John"}
+      input = Braintree::PayerInfoInput.new(attributes)
+      expected_variables = {"givenName" => "John"}
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        email: "john@example.com"
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+      result = input.inspect
+
+      expect(result).to include("PayerInfoInput")
+      expect(result).to include("given_name:")
+      expect(result).to include("surname:")
+    end
+  end
+end

data/spec/unit/braintree/local_payment_context_gateway_spec.rb

@@ -0,0 +1,149 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::LocalPaymentContextGateway do
+  let(:gateway) { double(:gateway) }
+  let(:graphql_client) { double(:graphql_client) }
+  let(:local_payment_gateway) { Braintree::LocalPaymentContextGateway.new(gateway, graphql_client) }
+
+  describe "#create" do
+    let(:input) do
+      {
+        amount: {value: "10.00", currency_code: "EUR"},
+        type: Braintree::LocalPaymentType::MBWAY,
+        payer_info: {
+          given_name: "John",
+          surname: "Doe"
+        }
+      }
+    end
+
+    let(:response) do
+      {
+        data: {
+          createLocalPaymentContext: {
+            paymentContext: {
+              id: "context-id-123",
+              type: "MBWAY",
+              paymentId: "payment-123",
+              approvalUrl: "https://approval.url",
+              merchantAccountId: "merchant-123",
+              orderId: "order-456",
+              createdAt: "2025-01-15T10:00:00Z",
+              transactedAt: nil,
+              approvedAt: nil,
+              amount: {
+                value: "10.00",
+                currencyCode: "EUR"
+              }
+            }
+          }
+        }
+      }
+    end
+
+    it "executes the createLocalPaymentContext mutation" do
+      create_input = Braintree::CreateLocalPaymentContextInput.new(input)
+      expect(graphql_client).to receive(:query).with(
+        Braintree::LocalPaymentContextGateway::CREATE_LOCAL_PAYMENT_CONTEXT,
+        {"input" => create_input.to_graphql_variables},
+      ).and_return(response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(response).and_return(nil)
+
+      result = local_payment_gateway.create(create_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.payment_context).to be_a(Braintree::LocalPaymentContext)
+      expect(result.payment_context.id).to eq("context-id-123")
+      expect(result.payment_context.approval_url).to eq("https://approval.url")
+      expect(result.payment_context.order_id).to eq("order-456")
+      expect(result.payment_context.amount.value).to eq("10.00")
+      expect(result.payment_context.amount.currency_code).to eq("EUR")
+    end
+
+    it "returns an error result if there are validation errors" do
+      create_input = Braintree::CreateLocalPaymentContextInput.new(input)
+      errors = {:errors =>
+        [ {:attribute => "", :code => "123", :message => "Invalid amount"} ]}
+
+      expect(graphql_client).to receive(:query).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(response).and_return(errors)
+
+      result = local_payment_gateway.create(create_input)
+      expect(result).to be_a(Braintree::ErrorResult)
+      expect(result.errors.first.message).to eq("Invalid amount")
+    end
+
+    it "raises an UnexpectedError if response is malformed" do
+      create_input = Braintree::CreateLocalPaymentContextInput.new(input)
+      bad_response = {:data => {}}
+
+      expect(graphql_client).to receive(:query).and_return(bad_response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(bad_response).and_return(nil)
+
+      expect {
+        local_payment_gateway.create(create_input)
+      }.to raise_error(Braintree::UnexpectedError)
+    end
+  end
+
+  describe "#find" do
+    let(:find_response) do
+      {
+        data: {
+          node: {
+            id: "context-id-123",
+            legacyId: "legacy-123",
+            type: "MBWAY",
+            paymentId: "payment-123",
+            orderId: "order-456",
+            approvalUrl: "https://approval.url",
+            merchantAccountId: "merchant-123",
+            createdAt: "2025-01-15T10:00:00Z",
+            updatedAt: "2025-01-15T10:05:00Z",
+            transactedAt: nil,
+            approvedAt: nil,
+            expiredAt: nil,
+            amount: {
+              value: "10.00",
+              currencyIsoCode: "EUR"
+            }
+          }
+        }
+      }
+    end
+
+    it "finds a payment context by ID" do
+      expect(graphql_client).to receive(:query).with(
+        Braintree::LocalPaymentContextGateway::FIND_LOCAL_PAYMENT_CONTEXT,
+        {"id" => "context-id-123"},
+      ).and_return(find_response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(find_response).and_return(nil)
+
+      result = local_payment_gateway.find("context-id-123")
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.payment_context).to be_a(Braintree::LocalPaymentContext)
+      expect(result.payment_context.id).to eq("context-id-123")
+      expect(result.payment_context.legacy_id).to eq("legacy-123")
+      expect(result.payment_context.type).to eq("MBWAY")
+      expect(result.payment_context.order_id).to eq("order-456")
+      expect(result.payment_context.updated_at).to eq("2025-01-15T10:05:00Z")
+    end
+
+    it "raises NotFoundError when payment context does not exist" do
+      not_found_response = {data: {node: nil}}
+
+      expect(graphql_client).to receive(:query).and_return(not_found_response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(not_found_response).and_return(nil)
+
+      expect {
+        local_payment_gateway.find("non-existent-id")
+      }.to raise_error(Braintree::NotFoundError, "Payment context not found")
+    end
+  end
+end

data/spec/unit/braintree/local_payment_context_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::LocalPaymentContext do
+  describe "#initialize" do
+    it "initializes from response hash" do
+      response = {
+        response: {
+          "paymentContext" => {
+            "id" => "context-123",
+            "legacyId" => "legacy-456",
+            "type" => "MBWAY",
+            "paymentId" => "payment-789",
+            "orderId" => "order-abc",
+            "approvalUrl" => "https://example.com/approve",
+            "merchantAccountId" => "merchant-xyz",
+            "createdAt" => "2025-01-15T10:00:00Z",
+            "updatedAt" => "2025-01-15T11:00:00Z",
+            "transactedAt" => "2025-01-15T12:00:00Z",
+            "approvedAt" => "2025-01-15T11:30:00Z",
+            "expiredAt" => nil,
+            "amount" => {
+              "value" => "10.00",
+              "currencyCode" => "EUR"
+            }
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.id).to eq("context-123")
+      expect(context.legacy_id).to eq("legacy-456")
+      expect(context.type).to eq("MBWAY")
+      expect(context.payment_id).to eq("payment-789")
+      expect(context.order_id).to eq("order-abc")
+      expect(context.approval_url).to eq("https://example.com/approve")
+      expect(context.merchant_account_id).to eq("merchant-xyz")
+      expect(context.created_at).to eq("2025-01-15T10:00:00Z")
+      expect(context.updated_at).to eq("2025-01-15T11:00:00Z")
+      expect(context.transacted_at).to eq("2025-01-15T12:00:00Z")
+      expect(context.approved_at).to eq("2025-01-15T11:30:00Z")
+      expect(context.expired_at).to be_nil
+      expect(context.amount).to be_a(Braintree::MonetaryAmount)
+      expect(context.amount.value).to eq("10.00")
+      expect(context.amount.currency_code).to eq("EUR")
+    end
+
+    it "initializes from attributes hash" do
+      attributes = {
+        id: "context-123",
+        type: "OXXO",
+        approval_url: "https://example.com/approve"
+      }
+
+      context = Braintree::LocalPaymentContext._new(attributes)
+
+      expect(context.id).to eq("context-123")
+      expect(context.type).to eq("OXXO")
+      expect(context.approval_url).to eq("https://example.com/approve")
+    end
+
+    it "handles symbol keys in amount hash" do
+      response = {
+        response: {
+          paymentContext: {
+            id: "context-123",
+            type: "MBWAY",
+            amount: {
+              value: "15.00",
+              currencyCode: "USD"
+            }
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.amount.value).to eq("15.00")
+      expect(context.amount.currency_code).to eq("USD")
+    end
+
+    it "handles currencyIsoCode in amount hash" do
+      response = {
+        response: {
+          paymentContext: {
+            id: "context-123",
+            type: "MBWAY",
+            amount: {
+              value: "20.00",
+              currencyIsoCode: "GBP"
+            }
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.amount.currency_code).to eq("GBP")
+    end
+
+    it "returns nil for amount when not present" do
+      response = {
+        response: {
+          paymentContext: {
+            id: "context-123",
+            type: "MBWAY"
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.amount).to be_nil
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string representation" do
+      attributes = {
+        id: "context-123",
+        type: "OXXO",
+        approval_url: "https://example.com/approve"
+      }
+
+      context = Braintree::LocalPaymentContext._new(attributes)
+
+      expect(context.inspect).to include("LocalPaymentContext")
+      expect(context.inspect).to include("id:")
+      expect(context.inspect).to include("type:")
+      expect(context.inspect).to include("approval_url:")
+    end
+  end
+
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::LocalPaymentContext.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+end

data/spec/unit/braintree/monetary_amount_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MonetaryAmount do
+  describe "#initialize" do
+    it "initializes with value and currency_code" do
+      amount = Braintree::MonetaryAmount._new(
+        value: "10.00",
+        currency_code: "USD",
+      )
+
+      expect(amount.value).to eq("10.00")
+      expect(amount.currency_code).to eq("USD")
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string representation" do
+      amount = Braintree::MonetaryAmount._new(
+        value: "25.50",
+        currency_code: "EUR",
+      )
+
+      expect(amount.inspect).to eq('#<MonetaryAmount currency_code:"EUR" value:"25.50">')
+    end
+  end
+
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::MonetaryAmount.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+end