braintree 2.104.0 → 4.9.0

data/spec/unit/braintree/dispute_spec.rb

@@ -7,6 +7,7 @@ describe Braintree::Dispute do
       :amount => "31.00",
       :amount_disputed => "500.00",
       :amount_won => "0.00",
+      :chargeback_protection_level => nil,
       :created_at => Time.utc(2009, 3, 9, 10, 50, 39),
       :processor_comments => "forwarded comments",
       :date_opened => "2009-03-09",
@@ -46,7 +47,14 @@ describe Braintree::Dispute do
         :order_id => nil,
         :purchase_order_number => "po",
         :payment_instrument_subtype => "Visa",
-      }
+      },
+      :paypal_messages => [
+        {
+          :message => "message",
+          :sender => "seller",
+          :sent_at => Time.utc(2009, 3, 9, 10, 50, 39),
+        }
+      ]
     }
   end
 
@@ -137,13 +145,13 @@ describe Braintree::Dispute do
       it "does not raise an exception if the optional parameters are valid" do
         Braintree::Http.stub(:new).and_return double.as_null_object
         expect do
-          Braintree::Dispute.add_file_evidence("dispute_id", { category: "GENERAL", document_id: "document_id" })
+          Braintree::Dispute.add_file_evidence("dispute_id", {category: "GENERAL", document_id: "document_id"})
         end.to_not raise_error
       end
 
       it "raises an exception if the optional params contain invalid keys" do
         expect do
-          Braintree::Dispute.add_file_evidence("dispute_id", { random_param: "" })
+          Braintree::Dispute.add_file_evidence("dispute_id", {random_param: ""})
         end.to raise_error(ArgumentError)
       end
 
@@ -151,7 +159,7 @@ describe Braintree::Dispute do
         Braintree::Http.stub(:new).and_return double.as_null_object
 
         expect do
-          Braintree::Dispute.add_file_evidence("dispute_id", { category: 3, document_id: "document_id" })
+          Braintree::Dispute.add_file_evidence("dispute_id", {category: 3, document_id: "document_id"})
         end.to raise_error(ArgumentError)
       end
     end
@@ -200,38 +208,31 @@ describe Braintree::Dispute do
       it "does not raise an exception if the optional parameters are valid" do
         Braintree::Http.stub(:new).and_return double.as_null_object
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { content: "a", tag: "", sequence_number: 3 })
-        end.to_not raise_error
-      end
-
-      it "does not raise an exception if the category parameter is provided" do
-        Braintree::Http.stub(:new).and_return double.as_null_object
-        expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { content: "a", category: "", sequence_number: 3 })
+          Braintree::Dispute.add_text_evidence("dispute_id", {content: "a", category: "", sequence_number: 3})
         end.to_not raise_error
       end
 
       it "raises an exception if the optional params contain invalid keys" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { random_param: "" })
+          Braintree::Dispute.add_text_evidence("dispute_id", {random_param: ""})
         end.to raise_error(ArgumentError)
       end
 
       it "raises an exception if sequence_number is provided and not an integer" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { sequence_number: "abc" })
+          Braintree::Dispute.add_text_evidence("dispute_id", {sequence_number: "abc"})
         end.to raise_error(ArgumentError)
       end
 
       it "raises an exception if the param tag is not a string" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { tag: 3 })
+          Braintree::Dispute.add_text_evidence("dispute_id", {tag: 3})
         end.to raise_error(ArgumentError)
       end
 
       it "raises an exception if the param category is not a string" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { category: 3 })
+          Braintree::Dispute.add_text_evidence("dispute_id", {category: 3})
         end.to raise_error(ArgumentError)
       end
     end
@@ -283,6 +284,45 @@ describe Braintree::Dispute do
       dispute.amount_won.should == 0.0
     end
 
+    it "returns 'Effortless Chargeback Protection tool' when initial chargeback_protection_level is effortless" do
+      attributes.merge!(:chargeback_protection_level => Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
+    end
+
+    it "returns 'Chargeback Protection tool' when initial chargeback_protection_level is standard" do
+      attributes.merge!(:chargeback_protection_level => Braintree::Dispute::ChargebackProtectionLevel::Standard)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Standard)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::StandardCBP)
+    end
+
+    it "returns 'No Protection' when initial chargeback_protection_level is nil" do
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(nil)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::NoProtection)
+    end
+
+    it "returns 'No Protection' when initial chargeback_protection_level is empty" do
+      attributes.merge!(:chargeback_protection_level => "")
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq("")
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::NoProtection)
+    end
+
+    it "returns 'No Protection' when initial chargeback_protection_level is not_protected" do
+      attributes.merge!(:chargeback_protection_level => Braintree::Dispute::ChargebackProtectionLevel::NotProtected)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::NotProtected)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::NoProtection)
+    end
+
     [
       :reply_by_date,
       :amount,
@@ -327,7 +367,7 @@ describe Braintree::Dispute do
       dispute.transaction.payment_instrument_subtype.should == "Visa"
     end
 
-    it "converts status_history hash into an array of Dispute::HistoryEvent objects" do
+    it "converts status_history hash into an array of Dispute::StatusHistory objects" do
       dispute = Braintree::Dispute._new(attributes)
 
       dispute.status_history.length.should == 1
@@ -355,6 +395,16 @@ describe Braintree::Dispute do
       evidence2.url.should == nil
     end
 
+    it "converts paypal_messages hash into an array of Dispute::PayPalMessage objects" do
+      dispute = Braintree::Dispute._new(attributes)
+
+      dispute.paypal_messages.length.should == 1
+      paypal_message_1 = dispute.paypal_messages.first
+      paypal_message_1.message.should == "message"
+      paypal_message_1.sender.should == "seller"
+      paypal_message_1.sent_at.should == Time.utc(2009, 3, 9, 10, 50, 39)
+    end
+
     it "handles nil evidence" do
       attributes.delete(:evidence)
 
@@ -363,6 +413,14 @@ describe Braintree::Dispute do
       dispute.evidence.should == nil
     end
 
+    it "handles nil paypal_messages" do
+      attributes.delete(:paypal_messages)
+
+      dispute = Braintree::Dispute._new(attributes)
+
+      dispute.paypal_messages.should == nil
+    end
+
     it "sets the older webhook fields for backwards compatibility" do
       dispute = Braintree::Dispute._new(attributes)
 
@@ -398,10 +456,6 @@ describe Braintree::Dispute do
   describe "comments" do
     let(:dispute) { Braintree::Dispute._new(attributes) }
 
-    it "#forwarded_comments returns `processor_comments`" do
-      expect(dispute.forwarded_comments).to eq(dispute.processor_comments)
-    end
-
     it "#processor_comments" do
       expect(dispute.processor_comments).to eq(attributes[:processor_comments])
     end

data/spec/unit/braintree/enriched_customer_data_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::EnrichedCustomerData do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::EnrichedCustomerData.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 = {
+        fields_updated: ["username"],
+        profile_data: {
+          username: "a-username",
+          first_name: "a-first-name",
+          last_name: "a-last-name",
+          phone_number: "a-phone-number",
+          email: "a-email",
+        },
+      }
+
+      payment_method_customer_data_updated = Braintree::EnrichedCustomerData._new(params)
+
+      payment_method_customer_data_updated.profile_data.should be_a(Braintree::VenmoProfileData)
+      payment_method_customer_data_updated.fields_updated.should eq(["username"])
+    end
+  end
+end

data/spec/unit/braintree/error_result_spec.rb

@@ -10,7 +10,7 @@ describe Braintree::ErrorResult do
           :params => "params",
           :errors => {:errors => []},
           :extra => "is ignored",
-          :message => "foo bar"
+          :message => "foo bar",
         )
       end.to_not raise_error
     end
@@ -36,7 +36,7 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => {},
-        :transaction => nil
+        :transaction => nil,
       )
       result.inspect.should include("credit_card_verification: #<Braintree::CreditCardVerification status: ")
     end
@@ -47,7 +47,7 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => nil,
-        :transaction => nil
+        :transaction => nil,
       )
       result.inspect.should_not include("credit_card_verification")
     end
@@ -58,7 +58,7 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => nil,
-        :transaction => {}
+        :transaction => {},
       )
       result.inspect.should include("transaction: #<Braintree::Transaction id: ")
     end
@@ -69,7 +69,7 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => nil,
-        :transaction => nil
+        :transaction => nil,
       )
       result.inspect.should_not include("transaction")
     end

data/spec/unit/braintree/errors_spec.rb

@@ -4,7 +4,7 @@ describe Braintree::Errors do
   describe "for" do
     it "accesses errors for the given scope" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
       errors.for(:level1).size.should == 1
       errors.for(:level1)[0].code.should == "code1"
@@ -12,7 +12,7 @@ describe Braintree::Errors do
 
     it "returns nil if there are no errors at the given scope" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
       errors.for(:no_errors_here).should == nil
     end
@@ -21,7 +21,7 @@ describe Braintree::Errors do
   describe "inspect" do
     it "is better than the default inspect" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
       errors.inspect.should == "#<Braintree::Errors level1:[(code1) message]>"
     end
@@ -33,7 +33,7 @@ describe Braintree::Errors do
           :level2 => {
             :errors => [{:code => "code2", :attribute => "attr2", :message => "message2"}],
           }
-        }
+        },
       )
       errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2]>"
     end
@@ -48,7 +48,7 @@ describe Braintree::Errors do
               :errors => [{:code => "code3", :attribute => "attr3", :message => "message3"}],
             }
           }
-        }
+        },
       )
       errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2], level1/level2/level3:[(code3) message3]>"
     end
@@ -65,7 +65,7 @@ describe Braintree::Errors do
               {:code => "3", :attribute => "attr3", :message => "message3"}
             ],
           }
-        }
+        },
       )
       errors.map { |e| e.code }.sort.should == %w[1 2 3]
     end
@@ -74,7 +74,7 @@ describe Braintree::Errors do
   describe "size" do
     it "returns the number of validation errors at the first level if only has one level" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]},
       )
       errors.size.should == 1
     end
@@ -89,7 +89,7 @@ describe Braintree::Errors do
               {:code => "3", :attribute => "attr3", :message => "message3"}
             ],
           }
-        }
+        },
       )
       errors.size.should == 3
     end

data/spec/unit/braintree/exchange_rate_quote_input_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuoteInput do
+  let(:exchange_rate_quote_input) do
+    {
+      base_currency: "USD",
+      quote_currency: "EUR",
+      base_amount: "10.00",
+      markup: "2.00"
+    }
+  end
+
+  describe "#initialize" do
+    it "initialize and sets the input keys to attrs variable" do
+      quote_input = described_class.new(exchange_rate_quote_input)
+
+      expect(quote_input.attrs).to include(:base_currency)
+      expect(quote_input.attrs).to include(:quote_currency)
+      expect(quote_input.attrs).to include(:base_amount)
+      expect(quote_input.attrs).to include(:markup)
+      expect(quote_input.attrs.length).to eq(4)
+    end
+  end
+
+  describe "inspect" do
+    it "includes the base_currency first" do
+      output = described_class.new(base_currency: "USD").inspect
+
+      expect(output).to include("#<Braintree::ExchangeRateQuoteInput base_currency:\"USD\">")
+    end
+
+    it "includes all quote input attributes" do
+      quote_input = described_class.new(exchange_rate_quote_input)
+      output = quote_input.inspect
+
+      expect(output).to include("base_currency:\"USD\"")
+      expect(output).to include("quote_currency:\"EUR\"")
+      expect(output).to include("base_amount:\"10.00\"")
+      expect(output).to include("markup:\"2.00\"")
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_quote_request_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuoteRequest do
+  describe "#initialize" do
+    it "creates and validates the exchange rate quote request" do
+      req = Braintree::ExchangeRateQuoteRequest.new(
+          :quotes => [
+            {
+              :base_currency => "USD",
+              :quote_currency => "EUR",
+              :base_amount => "10.00",
+              :markup => "2.00"
+            },
+            {
+              :base_currency => "EUR",
+              :quote_currency => "GBP",
+              :base_amount => "20.00",
+              :markup => "4.00"
+            }
+          ],
+      )
+
+      expect(req.quotes[0].base_currency).to eq("USD")
+      expect(req.quotes[0].quote_currency).to eq("EUR")
+      expect(req.quotes[0].base_amount).to eq("10.00")
+      expect(req.quotes[0].markup).to eq("2.00")
+
+      expect(req.quotes[1].base_currency).to eq("EUR")
+      expect(req.quotes[1].quote_currency).to eq("GBP")
+      expect(req.quotes[1].base_amount).to eq("20.00")
+      expect(req.quotes[1].markup).to eq("4.00")
+    end
+
+    it "creates and validates the exchange rate quote request without amount and markup" do
+      req = Braintree::ExchangeRateQuoteRequest.new(
+          :quotes => [
+            {
+              :base_currency => "USD",
+              :quote_currency => "EUR",
+            },
+            {
+              :base_currency => "EUR",
+              :quote_currency => "GBP",
+            }
+          ],
+      )
+
+      expect(req.quotes[0].base_currency).to eq("USD")
+      expect(req.quotes[0].quote_currency).to eq("EUR")
+      expect(req.quotes[0].base_amount).to be_nil
+      expect(req.quotes[0].markup).to be_nil
+
+      expect(req.quotes[1].base_currency).to eq("EUR")
+      expect(req.quotes[1].quote_currency).to eq("GBP")
+      expect(req.quotes[1].base_amount).to be_nil
+      expect(req.quotes[1].markup).to be_nil
+    end
+
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      exchange_rate_req = Braintree::ExchangeRateQuoteRequest.new(
+          :quotes => [
+            {
+              :base_currency => "USD",
+              :quote_currency => "EUR",
+              :base_amount => "10.00",
+              :markup => "2.00"
+            },
+            {
+              :base_currency => "EUR",
+              :quote_currency => "GBP",
+              :base_amount => "20.00",
+              :markup => "4.00"
+            }
+          ],
+      )
+      expect(exchange_rate_req.inspect).to eq(%(#<Braintree::ExchangeRateQuoteRequest quotes:[#<Braintree::ExchangeRateQuoteInput base_currency:"USD" quote_currency:"EUR" base_amount:"10.00" markup:"2.00">, #<Braintree::ExchangeRateQuoteInput base_currency:"EUR" quote_currency:"GBP" base_amount:"20.00" markup:"4.00">]>))
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_quote_response_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuoteResponse do
+  describe "#initialize" do
+    it "creates and validated the exchange rate quote payload" do
+      quote_payload = Braintree::ExchangeRateQuoteResponse.new(
+        quotes: [
+          {
+            :base_amount => "10.00",
+            :quote_amount => "9.03",
+            :exchange_rate => "0.90"
+          },
+          {
+            :base_amount => "20.00",
+            :quote_amount => "18.06",
+            :exchange_rate => "0.90"
+          }
+        ],
+      )
+
+      quote_1 = quote_payload.quotes[0]
+      quote_2 = quote_payload.quotes[1]
+
+      expect(quote_1.base_amount).to eq("10.00")
+      expect(quote_1.quote_amount).to eq("9.03")
+      expect(quote_1.exchange_rate).to eq("0.90")
+
+      expect(quote_2.base_amount).to eq("20.00")
+      expect(quote_2.quote_amount).to eq("18.06")
+      expect(quote_1.exchange_rate).to eq("0.90")
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      exchange_rate_quote_payload = Braintree::ExchangeRateQuoteResponse.new(
+        quotes: [
+          {
+            :base_amount => "10.00",
+            :quote_amount => "9.03"
+          },
+          {
+            :base_amount => "20.00",
+            :quote_amount => "18.06"
+          }
+        ],
+      )
+
+      expect(exchange_rate_quote_payload.inspect).to eq(%(#<Braintree::ExchangeRateQuoteResponse quotes:[#<Braintree::ExchangeRateQuote base_amount:"10.00" quote_amount:"9.03">, #<Braintree::ExchangeRateQuote base_amount:"20.00" quote_amount:"18.06">]>))
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_quote_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuote do
+  let(:rate_quote) do
+    {
+      id: "1234",
+      base_amount: "10.00",
+      exchange_rate: "74",
+      quote_amount: "740"
+    }
+  end
+
+  describe "#initialize" do
+    it "initialize and sets the input keys to attrs variable" do
+      quote = described_class.new(rate_quote)
+
+      expect(quote.attrs).to include(:id)
+      expect(quote.attrs).to include(:base_amount)
+      expect(quote.attrs).to include(:exchange_rate)
+      expect(quote.attrs).to include(:quote_amount)
+      expect(quote.attrs.length).to eq(4)
+    end
+  end
+
+  describe "inspect" do
+    it "includes the id first" do
+      output = described_class.new(id: "1234").inspect
+
+      expect(output).to include("#<Braintree::ExchangeRateQuote id:\"1234\">")
+    end
+
+    it "includes all quote attributes" do
+      quote = described_class.new(rate_quote)
+      output = quote.inspect
+
+      expect(output).to include("id:\"1234\"")
+      expect(output).to include("base_amount:\"10.00\"")
+      expect(output).to include("exchange_rate:\"74\"")
+      expect(output).to include("quote_amount:\"740\"")
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe ::Braintree::ExchangeRate do
+  let(:rate_quote) do
+    {
+      id: "1234",
+      base_amount: "10.00",
+      exchange_rate: "74",
+      quote_amount: "740"
+    }
+  end
+
+  describe "#initialize" do
+    it "initialize and sets the attributes" do
+      exchange_rate = described_class.new(:gateway, rate_quote).inspect
+
+      expect(exchange_rate).to include("@id=\"1234\"")
+      expect(exchange_rate).to include("@base_amount=\"10.00\"")
+      expect(exchange_rate).to include("@exchange_rate=\"74\"")
+      expect(exchange_rate).to include("@quote_amount=\"740\"")
+    end
+  end
+end

data/spec/unit/braintree/http_spec.rb

@@ -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,6 +35,7 @@ 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
@@ -67,7 +69,7 @@ END
         :proxy_address => "localhost",
         :proxy_port => 8080,
         :proxy_user => "user",
-        :proxy_pass => "test"
+        :proxy_pass => "test",
       )
 
       http = Braintree::Http.new(config)
@@ -75,7 +77,7 @@ END
         "Net::HTTP",
         :open_timeout= => nil,
         :read_timeout= => nil,
-        :start => nil
+        :start => nil,
       )
 
       Net::HTTP.should_receive(:new).with(nil, nil, "localhost", 8080, "user", "test").and_return(net_http_instance)
@@ -86,7 +88,7 @@ END
     it "accepts a partially specified proxy" do
       config = Braintree::Configuration.new(
         :proxy_address => "localhost",
-        :proxy_port => 8080
+        :proxy_port => 8080,
       )
 
       http = Braintree::Http.new(config)
@@ -94,7 +96,7 @@ END
         "Net::HTTP",
         :open_timeout= => nil,
         :read_timeout= => nil,
-        :start => nil
+        :start => nil,
       )
 
       Net::HTTP.should_receive(:new).with(nil, nil, "localhost", 8080, nil, nil).and_return(net_http_instance)
@@ -109,7 +111,7 @@ END
         "Net::HTTP",
         :open_timeout= => nil,
         :read_timeout= => nil,
-        :start => nil
+        :start => nil,
       )
 
       Net::HTTP.should_receive(:new).with(nil, nil).and_return(net_http_instance)
@@ -130,7 +132,7 @@ END
       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("5")
+      expect(default_headers["X-ApiVersion"]).to eq("6")
     end
 
     it "overwrites defaults with override headers" do
@@ -144,7 +146,7 @@ END
       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("5")
+      expect(headers["X-ApiVersion"]).to eq("6")
     end
 
     it "extends default headers when new headers are specified" do
@@ -156,7 +158,7 @@ END
       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("5")
+      expect(headers["X-ApiVersion"]).to eq("6")
       expect(headers["New-Header"]).to eq("New Value")
     end
   end