braintree 2.10.0 → 4.26.0

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

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::UpdateCustomerSessionInput do
+  let(:input_data) do
+  {
+    merchant_account_id: "merchant-account-id",
+    session_id: "session-id",
+    customer: {email: "test@example.com"}
+  }
+  end
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::UpdateCustomerSessionInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.merchant_account_id).to eq("merchant-account-id")
+      expect(input.session_id).to eq("session-id")
+      expect(input.customer).to be_a(Braintree::CustomerSessionInput)
+      expect(input.customer.email).to eq("test@example.com")
+    end
+
+    it "disallows nil session id" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+      }
+      expect do
+        Braintree::UpdateCustomerSessionInput.new(attributes)
+      end.to raise_error(ArgumentError, "Expected hash to contain a :session_id")
+    end
+
+    it "handles nil customer" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+      }
+      input = Braintree::UpdateCustomerSessionInput.new(attributes)
+
+      expect(input.customer).to be_nil
+    end
+  end
+
+
+  describe "#inspect" do
+      it "returns a string representation of the object" do
+        input = Braintree::UpdateCustomerSessionInput.new(input_data)
+        expected_string = "#<Braintree::UpdateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\">>"
+        expect(input.inspect).to eq(expected_string)
+
+      end
+
+      it "handles nil values" do
+        attributes = {
+          merchant_account_id: "merchant-account-id",
+          session_id: "session-id",
+        }
+        input = Braintree::UpdateCustomerSessionInput.new(attributes)
+        expected_string = "#<Braintree::UpdateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\">"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::UpdateCustomerSessionInput.new(input_data)
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+        "customer" => {"email" => "test@example.com"},
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "handles nil values" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+      }
+      input = Braintree::UpdateCustomerSessionInput.new(attributes)
+
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+end

data/spec/unit/braintree/graphql_client_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::GraphQLClient do
+
+  describe ".get_validation_errors" do
+    it "returns nil if no errors" do
+      expect(Braintree::GraphQLClient.get_validation_errors({})).to be_nil
+    end
+
+    it "returns nil if errors is not an array" do
+      expect(Braintree::GraphQLClient.get_validation_errors({:errors => "string"})).to be_nil
+    end
+
+    it "returns validation errors" do
+      response = {
+        :errors => [
+          {:message => "Invalid input", :extensions => {:legacyCode => "81803"}},
+          {:message => "Another error", :extensions => {:legacyCode => "91903"}}
+        ]
+      }
+      expected_errors = {
+        :errors => [
+          {:attribute => "", :code => "81803", :message => "Invalid input"},
+          {:attribute => "", :code => "91903", :message => "Another error"}
+        ]
+      }
+      expect(Braintree::GraphQLClient.get_validation_errors(response)).to eq(expected_errors)
+    end
+
+
+    it "handles missing legacyCode" do
+      response = {:errors => [{:message => "Invalid input"}]}
+      expected_errors = {:errors => [{:attribute => "", :code => nil, :message => "Invalid input"}]}
+      expect(Braintree::GraphQLClient.get_validation_errors(response)).to eq(expected_errors)
+    end
+  end
+end

data/spec/unit/braintree/http_spec.rb

@@ -15,7 +15,7 @@ END
 [Braintree]   <last-name>Doe</last-name>
 [Braintree] </customer>
 END
-      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      expect(Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml)).to eq(expected_xml)
     end
 
     it "sanitizes credit card number and cvv" do
@@ -25,6 +25,7 @@ END
   <last-name>Doe</last-name>
   <number>1234560000001234</number>
   <cvv>123</cvv>
+  <encrypted-card-data>8F34DFB312DC79C24FD5320622F3E11682D79E6B0C0FD881</encrypted-card-data>
 </customer>
       END
 
@@ -34,9 +35,170 @@ END
 [Braintree]   <last-name>Doe</last-name>
 [Braintree]   <number>123456******1234</number>
 [Braintree]   <cvv>***</cvv>
+[Braintree]   <encrypted-card-data>***</encrypted-card-data>
 [Braintree] </customer>
 END
-      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      expect(Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml)).to eq(expected_xml)
+    end
+
+    it "sanitizes credit card number and cvv with newlines" do
+      input_xml = <<-END
+<customer>
+  <first-name>Joe</first-name>
+  <last-name>Doe</last-name>
+  <number>123456000\n0001234</number>
+  <cvv>1\n23</cvv>
+</customer>
+      END
+
+      expected_xml = <<-END
+[Braintree] <customer>
+[Braintree]   <first-name>Joe</first-name>
+[Braintree]   <last-name>Doe</last-name>
+[Braintree]   <number>123456******1234</number>
+[Braintree]   <cvv>***</cvv>
+[Braintree] </customer>
+END
+      expect(Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml)).to eq(expected_xml)
+    end
+  end
+
+  describe "self._http_do" do
+    it "connects when proxy address is specified" do
+      config = Braintree::Configuration.new(
+        :proxy_address => "localhost",
+        :proxy_port => 8080,
+        :proxy_user => "user",
+        :proxy_pass => "test",
+      )
+
+      http = Braintree::Http.new(config)
+      net_http_instance = instance_double(
+        "Net::HTTP",
+        :open_timeout= => nil,
+        :read_timeout= => nil,
+        :start => nil,
+      )
+
+      expect(Net::HTTP).to receive(:new).with(nil, nil, "localhost", 8080, "user", "test").and_return(net_http_instance)
+
+      http._http_do("GET", "/plans")
+    end
+
+    it "accepts a partially specified proxy" do
+      config = Braintree::Configuration.new(
+        :proxy_address => "localhost",
+        :proxy_port => 8080,
+      )
+
+      http = Braintree::Http.new(config)
+      net_http_instance = instance_double(
+        "Net::HTTP",
+        :open_timeout= => nil,
+        :read_timeout= => nil,
+        :start => nil,
+      )
+
+      expect(Net::HTTP).to receive(:new).with(nil, nil, "localhost", 8080, nil, nil).and_return(net_http_instance)
+
+      http._http_do("GET", "/plans")
+    end
+
+    it "does not specify a proxy if proxy_address is not set" do
+      config = Braintree::Configuration.new
+      http = Braintree::Http.new(config)
+      net_http_instance = instance_double(
+        "Net::HTTP",
+        :open_timeout= => nil,
+        :read_timeout= => nil,
+        :start => nil,
+      )
+
+      expect(Net::HTTP).to receive(:new).with(nil, nil).and_return(net_http_instance)
+
+      http._http_do("GET", "/plans")
+    end
+  end
+
+  describe "_compose_headers" do
+    before(:each) do
+      config = Braintree::Configuration.new
+      @http = Braintree::Http.new(config)
+    end
+
+    it "returns a hash of default headers" do
+      default_headers = @http._compose_headers
+      expect(default_headers["Accept"]).to eq("application/xml")
+      expect(default_headers["Accept-Encoding"]).to eq("gzip")
+      expect(default_headers["Content-Type"]).to eq("application/xml")
+      expect(default_headers["User-Agent"]).to match(/Braintree Ruby Gem .*/)
+      expect(default_headers["X-ApiVersion"]).to eq("6")
+    end
+
+    it "overwrites defaults with override headers" do
+      override_headers = {
+        "Accept" => "application/pdf",
+        "Authorization" => "token"
+      }
+      headers = @http._compose_headers(override_headers)
+      expect(headers["Accept"]).to eq("application/pdf")
+      expect(headers["Accept-Encoding"]).to eq("gzip")
+      expect(headers["Authorization"]).to eq("token")
+      expect(headers["Content-Type"]).to eq("application/xml")
+      expect(headers["User-Agent"]).to match(/Braintree Ruby Gem .*/)
+      expect(headers["X-ApiVersion"]).to eq("6")
+    end
+
+    it "extends default headers when new headers are specified" do
+      override_headers = {
+        "New-Header" => "New Value"
+      }
+      headers = @http._compose_headers(override_headers)
+      expect(headers["Accept"]).to eq("application/xml")
+      expect(headers["Accept-Encoding"]).to eq("gzip")
+      expect(headers["Content-Type"]).to eq("application/xml")
+      expect(headers["User-Agent"]).to match(/Braintree Ruby Gem .*/)
+      expect(headers["X-ApiVersion"]).to eq("6")
+      expect(headers["New-Header"]).to eq("New Value")
+    end
+  end
+
+  describe "_setup_connection" do
+    it "creates a new Net::HTTP object using default server and port" do
+      config = Braintree::Configuration.new
+      http = Braintree::Http.new(config)
+
+      connection = http._setup_connection
+      expect(connection.address).to eq(nil)
+      expect(connection.port).to eq(80)
+    end
+
+    it "overrides the default server and port when replacements are specified" do
+      config = Braintree::Configuration.new
+      http = Braintree::Http.new(config)
+
+      connection = http._setup_connection("localhost", 3443)
+      expect(connection.address).to eq("localhost")
+      expect(connection.port).to eq(3443)
+    end
+  end
+
+  describe "_build_query_string" do
+    it "returns an empty string for empty query params" do
+      expect(Braintree::Http.new(:config)._build_query_string({})).to eq("")
+    end
+
+    it "returns a proper query string for non-nested hashes" do
+      query_params = {:one => 1, :two => 2}
+
+      expect(Braintree::Http.new(:config)._build_query_string(query_params)).to match(/^\?(one=1&two=2|two=2&one=1)$/)
+    end
+
+    it "raises ArgumentError for nested hashes" do
+      query_params = {:one => 1, :two => {:a => 2.1, :b => 2.2}}
+      expect {
+        Braintree::Http.new(:config)._build_query_string(query_params)
+      }.to raise_error(ArgumentError, /nested hash/i)
     end
   end
 end

data/spec/unit/braintree/local_payment_completed_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::LocalPaymentCompleted do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::LocalPaymentCompleted.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+      params = {
+        bic: "a-bic",
+        iban_last_chars: "1234",
+        payer_id: "a-payer-id",
+        payer_name: "John Doe",
+        payment_id: "a-payment-id",
+        payment_method_nonce: "a-nonce",
+        transaction: {
+          id: "a-transaction-id",
+          amount: "31.00",
+          order_id: "an-order-id",
+          status: Braintree::Transaction::Status::Authorized,
+        },
+      }
+      local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
+
+      expect(local_payment_completed.bic).to eq("a-bic")
+      expect(local_payment_completed.iban_last_chars).to eq("1234")
+      expect(local_payment_completed.payer_id).to eq("a-payer-id")
+      expect(local_payment_completed.payer_name).to eq("John Doe")
+      expect(local_payment_completed.payment_id).to eq("a-payment-id")
+      expect(local_payment_completed.payment_method_nonce).to eq("a-nonce")
+      expect(local_payment_completed.transaction.amount).to eq(31.0)
+      expect(local_payment_completed.transaction.id).to eq("a-transaction-id")
+      expect(local_payment_completed.transaction.order_id).to eq("an-order-id")
+      expect(local_payment_completed.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
+
+    it "initializes the object with the appropriate attributes set if no transaction is provided" do
+      params = {
+        bic: "a-bic",
+        iban_last_chars: "1234",
+        payer_id: "a-payer-id",
+        payer_name: "John Doe",
+        payment_id: "a-payment-id",
+        payment_method_nonce: "a-nonce",
+      }
+      local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
+
+      expect(local_payment_completed.bic).to eq("a-bic")
+      expect(local_payment_completed.blik_aliases).to be_nil
+      expect(local_payment_completed.iban_last_chars).to eq("1234")
+      expect(local_payment_completed.payer_id).to eq("a-payer-id")
+      expect(local_payment_completed.payer_name).to eq("John Doe")
+      expect(local_payment_completed.payment_id).to eq("a-payment-id")
+      expect(local_payment_completed.payment_method_nonce).to eq("a-nonce")
+      expect(local_payment_completed.transaction).to be_nil
+    end
+
+    it "initializes the object with the appropriate attributes when blik_aliases is provided" do
+      params = {
+        bic: "a-bic",
+        blik_aliases: [
+          {
+            key: "an-alias-key",
+            label: "an-alias-label"
+          }
+        ],
+        iban_last_chars: "1234",
+        payer_id: "a-payer-id",
+        payer_name: "John Doe",
+        payment_id: "a-payment-id",
+        payment_method_nonce: "a-nonce",
+      }
+      local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
+
+      expect(local_payment_completed.bic).to eq("a-bic")
+      expect(local_payment_completed.blik_aliases).to match_array([{key: "an-alias-key", label: "an-alias-label"}])
+      expect(local_payment_completed.iban_last_chars).to eq("1234")
+      expect(local_payment_completed.payer_id).to eq("a-payer-id")
+      expect(local_payment_completed.payer_name).to eq("John Doe")
+      expect(local_payment_completed.payment_id).to eq("a-payment-id")
+      expect(local_payment_completed.payment_method_nonce).to eq("a-nonce")
+      expect(local_payment_completed.transaction).to be_nil
+    end
+  end
+end

data/spec/unit/braintree/local_payment_expired_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::LocalPaymentExpired do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::LocalPaymentExpired.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+      params = {
+        payment_id: "a-payment-id",
+        payment_context_id: "a-payment-context-id",
+      }
+      local_payment_expired = Braintree::LocalPaymentExpired._new(params)
+
+      expect(local_payment_expired.payment_id).to eq("a-payment-id")
+      expect(local_payment_expired.payment_context_id).to eq("a-payment-context-id")
+    end
+  end
+end

data/spec/unit/braintree/local_payment_funded_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::LocalPaymentFunded do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::LocalPaymentFunded.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+      params = {
+        payment_id: "a-payment-id",
+        payment_context_id: "a-payment-context-id",
+        transaction: {
+          id: "a-transaction-id",
+          amount: "31.00",
+          order_id: "an-order-id",
+          status: Braintree::Transaction::Status::Settled,
+        },
+      }
+      local_payment_funded = Braintree::LocalPaymentFunded._new(params)
+
+      expect(local_payment_funded.payment_id).to eq("a-payment-id")
+      expect(local_payment_funded.payment_context_id).to eq("a-payment-context-id")
+      expect(local_payment_funded.transaction.id).to eq("a-transaction-id")
+      expect(local_payment_funded.transaction.amount).to eq(31.0)
+      expect(local_payment_funded.transaction.order_id).to eq("an-order-id")
+      expect(local_payment_funded.transaction.status).to eq(Braintree::Transaction::Status::Settled)
+    end
+  end
+end

data/spec/unit/braintree/merchant_account_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MerchantAccount do
+  describe "#inspect" do
+    it "is a string representation of the merchant account" do
+      account = Braintree::MerchantAccount._new(nil, :id => "merchant_account", :status => "active", :master_merchant_account => nil)
+
+      expect(account.inspect).to eq("#<Braintree::MerchantAccount: id: \"merchant_account\", status: \"active\", master_merchant_account: nil>")
+    end
+
+    it "handles a master merchant account" do
+      account = Braintree::MerchantAccount._new(
+        nil,
+        :id => "merchant_account",
+        :status => "active",
+        :master_merchant_account => {:id => "master_merchant_account", :status => "active", :master_merchant_account => nil},
+      )
+
+      master_merchant_account = "#<Braintree::MerchantAccount: id: \"master_merchant_account\", status: \"active\", master_merchant_account: nil>"
+      expect(account.inspect).to eq("#<Braintree::MerchantAccount: id: \"merchant_account\", status: \"active\", master_merchant_account: #{master_merchant_account}>")
+    end
+  end
+
+  describe "default?" do
+    it "is an alias of default" do
+      account = Braintree::MerchantAccount._new(nil, :default => false)
+      expect(account.default?).to eq(false)
+      account = Braintree::MerchantAccount._new(nil, :default => true)
+      expect(account.default?).to eq(true)
+    end
+  end
+end
+

data/spec/unit/braintree/meta_checkout_card_details_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction::MetaCheckoutCardDetails do
+    let(:attributes) do {
+
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end

data/spec/unit/braintree/meta_checkout_card_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MetaCheckoutCard do
+  let(:attributes) do {
+
+    :bin => "abc1234",
+    :card_type => "Visa",
+    :cardholder_name => "Meta Checkout Card CardHolder",
+    :commercial => "NO",
+    :container_id => "a-container-id",
+    :country_of_issuance => "US",
+    :created_at => "2023-05-05T21:28:37Z",
+    :debit => "NO",
+    :durbin_regulated => "NO",
+    :expiration_month => "05",
+    :expiration_year => "2024",
+    :healthcare => "NO",
+    :last_4 => "1234",
+    :payroll => "NO",
+    :prepaid => "NO",
+    :prepaid_reloadable => "NO",
+    :token => "token1",
+    :unique_number_identifier => "abc1234",
+    :updated_at => "2023-05-05T21:28:37Z"
+  }
+  end
+
+  describe "unit tests" do
+    it "initializes with the correct attributes" do
+      card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+
+      card.bin.should == "abc1234"
+      card.card_type.should == "Visa"
+      card.cardholder_name.should == "Meta Checkout Card CardHolder"
+      card.commercial == "NO"
+      card.container_id.should == "a-container-id"
+      card.country_of_issuance == "US"
+      card.created_at == "2023-05-05T21:28:37Z"
+      card.debit == "NO"
+      card.expiration_month.should == "05"
+      card.expiration_year.should == "2024"
+      card.healthcare == "NO"
+      card.last_4.should == "1234"
+      card.payroll == "NO"
+      card.prepaid == "NO"
+      card.prepaid_reloadable == "NO"
+      card.token == "token1"
+      card.unique_number_identifier == "abc1234"
+      card.updated_at == "2023-05-05T21:28:37Z"
+    end
+
+    it "sets expiration date correctly" do
+      card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+      card.expiration_date.should == "05/2024"
+    end
+
+    it "masks the card number correctly" do
+      card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+      card.masked_number.should == "abc1234******1234"
+    end
+  end
+end