braintree 2.104.0 → 4.9.0

data/spec/unit/braintree/local_payment_completed_spec.rb

@@ -32,5 +32,19 @@ describe Braintree::LocalPaymentCompleted do
       local_payment_completed.transaction.order_id.should eq("an-order-id")
       local_payment_completed.transaction.status.should eq(Braintree::Transaction::Status::Authorized)
     end
+
+    it "initializes the object with the appropriate attributes set if no transaction is provided" do
+      params = {
+        payment_id: "a-payment-id",
+        payer_id: "a-payer-id",
+        payment_method_nonce: "a-nonce",
+      }
+      local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
+
+      local_payment_completed.payment_id.should eq("a-payment-id")
+      local_payment_completed.payer_id.should eq("a-payer-id")
+      local_payment_completed.payment_method_nonce.should eq("a-nonce")
+      local_payment_completed.transaction.should 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)
+
+      local_payment_expired.payment_id.should eq("a-payment-id")
+      local_payment_expired.payment_context_id.should 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)
+
+      local_payment_funded.payment_id.should eq("a-payment-id")
+      local_payment_funded.payment_context_id.should eq("a-payment-context-id")
+      local_payment_funded.transaction.id.should eq("a-transaction-id")
+      local_payment_funded.transaction.amount.should eq(31.0)
+      local_payment_funded.transaction.order_id.should eq("an-order-id")
+      local_payment_funded.transaction.status.should eq(Braintree::Transaction::Status::Settled)
+    end
+  end
+end

data/spec/unit/braintree/merchant_account_spec.rb

@@ -13,7 +13,7 @@ describe Braintree::MerchantAccount do
         nil,
         :id => "merchant_account",
         :status => "active",
-        :master_merchant_account => {:id => "master_merchant_account", :status => "active", :master_merchant_account => nil}
+        :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>"

data/spec/unit/braintree/payment_method_customer_data_updated_metadata_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::PaymentMethodCustomerDataUpdatedMetadata do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::PaymentMethodCustomerDataUpdatedMetadata.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 = {
+        token: "a-token",
+        payment_method: {
+          venmo_account: {
+            venmo_user_id: "venmo-user-id",
+          },
+        },
+        datetime_updated: "2022-01-01T21:28:37Z",
+        enriched_customer_data: {
+          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::PaymentMethodCustomerDataUpdatedMetadata._new(:gateway, params)
+
+      payment_method_customer_data_updated.token.should eq("a-token")
+      payment_method_customer_data_updated.datetime_updated.should eq("2022-01-01T21:28:37Z")
+      payment_method_customer_data_updated.payment_method.should be_a(Braintree::VenmoAccount)
+      payment_method_customer_data_updated.enriched_customer_data.profile_data.first_name.should eq("a-first-name")
+      payment_method_customer_data_updated.enriched_customer_data.profile_data.last_name.should eq("a-last-name")
+      payment_method_customer_data_updated.enriched_customer_data.fields_updated.should eq(["username"])
+    end
+  end
+end

data/spec/unit/braintree/payment_method_nonce_details_payer_info_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::PaymentMethodNonceDetailsPayerInfo do
+  let(:payment_method_nonce_details_payer_info) {
+    Braintree::PaymentMethodNonceDetailsPayerInfo.new(
+      :billing_agreement_id => "billing-agreement-id",
+      :country_code => "US",
+      :email => "test@example.com",
+      :first_name => "First",
+      :last_name => "Last",
+      :payer_id => "payer-id",
+    )
+  }
+
+  describe "#initialize" do
+    it "sets attributes" do
+      payment_method_nonce_details_payer_info.billing_agreement_id.should == "billing-agreement-id"
+      payment_method_nonce_details_payer_info.country_code.should == "US"
+      payment_method_nonce_details_payer_info.email.should == "test@example.com"
+      payment_method_nonce_details_payer_info.first_name.should == "First"
+      payment_method_nonce_details_payer_info.last_name.should == "Last"
+      payment_method_nonce_details_payer_info.payer_id.should == "payer-id"
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      payment_method_nonce_details_payer_info.inspect.should == %(#<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: \"billing-agreement-id\", country_code: \"US\", email: \"test@example.com\", first_name: \"First\", last_name: \"Last\", payer_id: \"payer-id\">)
+    end
+  end
+end

data/spec/unit/braintree/payment_method_nonce_details_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::PaymentMethodNonceDetails do
+  let(:payment_method_nonce_details) {
+    Braintree::PaymentMethodNonceDetails.new(
+      :bin => "bin",
+      :card_type => "American Express",
+      :expiration_month => "12",
+      :expiration_year => "2025",
+      :is_network_tokenized => true,
+      :last_two => "11",
+      :payer_info => {
+        :billing_agreement_id => "1234",
+        :country_code => "US",
+      },
+    )
+  }
+
+  describe "#initialize" do
+    it "sets attributes" do
+      payment_method_nonce_details.bin.should == "bin"
+      payment_method_nonce_details.card_type.should == "American Express"
+      payment_method_nonce_details.expiration_month.should == "12"
+      payment_method_nonce_details.expiration_year.should == "2025"
+      payment_method_nonce_details.is_network_tokenized.should == true
+      payment_method_nonce_details.last_two.should == "11"
+      payment_method_nonce_details.payer_info.billing_agreement_id.should == "1234"
+      payment_method_nonce_details.payer_info.country_code.should == "US"
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      payment_method_nonce_details.inspect.should == %(#<PaymentMethodNonceDetails bin: "bin", card_type: "American Express", expiration_month: "12", expiration_year: "2025", is_network_tokenized: true, last_two: "11", payer_info: #<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: "1234", country_code: "US", email: nil, first_name: nil, last_name: nil, payer_id: nil>>)
+    end
+  end
+
+  describe "is_network_tokenized" do
+    it "is aliased to is_network_tokenized?" do
+      payment_method_nonce_details.is_network_tokenized?.should == true
+    end
+  end
+end

data/spec/unit/braintree/payment_method_nonce_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::PaymentMethodNonce do
+  let(:payment_method_nonce) {
+    Braintree::PaymentMethodNonce._new(
+      :gateway,
+      :nonce => "some-nonce",
+      :type => "CreditCard",
+      :default => true,
+      :details => {
+        :bin => "some-bin"
+      },
+      :three_d_secure_info => {
+        :liability_shift_possible => false,
+        :liability_shifted => false
+      },
+      :bin_data => {
+        :country_of_issuance => "USA"
+      },
+    )
+  }
+
+  describe "#initialize" do
+    it "sets attributes" do
+      expect(payment_method_nonce.nonce).to eq("some-nonce")
+      expect(payment_method_nonce.type).to eq("CreditCard")
+      expect(payment_method_nonce.default).to be true
+      expect(payment_method_nonce.details.bin).to eq("some-bin")
+      expect(payment_method_nonce.three_d_secure_info.liability_shift_possible).to be false
+      expect(payment_method_nonce.three_d_secure_info.liability_shifted).to be false
+      expect(payment_method_nonce.bin_data.country_of_issuance).to eq("USA")
+    end
+  end
+
+  describe "default" do
+    it "is aliased to default?" do
+      expect(payment_method_nonce.default?).to be true
+    end
+  end
+end

data/spec/unit/braintree/payment_method_spec.rb

@@ -28,7 +28,7 @@ describe Braintree::PaymentMethod do
   end
 
   describe "delete" do
-    let(:http_stub) { double('http_stub').as_null_object }
+    let(:http_stub) { double("http_stub").as_null_object }
     it "accepts revoke_all_grants option with value true" do
       Braintree::Http.stub(:new).and_return http_stub
       http_stub.should_receive(:delete).with("/merchants/integration_merchant_id/payment_methods/any/some_token?revoke_all_grants=true")

data/spec/unit/braintree/paypal_account_spec.rb

@@ -8,7 +8,7 @@ describe Braintree::PayPalAccount do
           :invalid_key => "bad stuff",
           :options => {
             :invalid_option => "bad option",
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: invalid_key, options[invalid_option]")
     end
@@ -17,7 +17,7 @@ describe Braintree::PayPalAccount do
   describe "self.update" do
     it "raises an exception if attributes contain an invalid key" do
       expect do
-        Braintree::PayPalAccount.update("some_token", :invalid_key => 'val')
+        Braintree::PayPalAccount.update("some_token", :invalid_key => "val")
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end

data/spec/unit/braintree/resource_collection_spec.rb

@@ -5,7 +5,7 @@ describe "Braintree::ResourceCollection" do
     it "iterates over the elements, yielding to the block in pages" do
       values = %w(a b c d e)
       collection = Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2}) do |ids|
-        ids.map {|id| values[id] }
+        ids.map { |id| values[id] }
       end
 
       count = 0
@@ -18,6 +18,35 @@ describe "Braintree::ResourceCollection" do
     end
   end
 
+  describe "#first" do
+    it "returns nil with no results" do
+      values = %w(a b c d e)
+      collection = Braintree::ResourceCollection.new(:search_results => {:ids => [], :page_size => 2}) do |ids|
+        ids.map { |id| values[id] }
+      end
+
+      collection.first.should == nil
+    end
+
+    context "with results" do
+      let(:collection) do
+        values = %w(a b c d e)
+
+        Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2}) do |ids|
+          ids.map { |id| values[id] }
+        end
+      end
+
+      it "returns the first occourence" do
+        collection.first.should == "a"
+      end
+
+      it "returns the first N occourences" do
+        collection.first(4).should == ["a","b","c","d"]
+      end
+    end
+  end
+
   describe "#ids" do
     it "returns a list of the resource collection ids" do
       collection = Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2})

data/spec/unit/braintree/risk_data/liability_shift.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::Transaction::LiabilityShift do
+  describe "#initialize" do
+    it "sets responsible party and conditions" do
+      liability_shift = Braintree::Transaction::LiabilityShift.new(
+        :responsible_party => "paypal",
+        :conditions => ["unauthorized","item_not_received"],
+      )
+
+      expect(liability_shift.responsible_party).to eql "paypal"
+      expect(liability_shift.conditions.first).to eql "unauthorized"
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      details = Braintree::Transaction::LiabilityShift.new(
+        :responsible_party => "paypal",
+        :conditions => ["unauthorized","item_not_received"],
+      )
+
+      expect(details.inspect).to eql %(#<LiabilityShift responsible_party: "paypal", conditions: ["unauthorized", "item_not_received"]>)
+    end
+  end
+end

data/spec/unit/braintree/risk_data_spec.rb

@@ -2,12 +2,31 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::RiskData do
   describe "#initialize" do
-    it "sets id, decision and device_data_captured" do
-      risk_data = Braintree::RiskData.new(:id => "123", :decision => "YOU WON $1000 DOLLARS", :device_data_captured => true, :fraud_service_provider => "kount")
-      risk_data.id.should == "123"
-      risk_data.decision.should == "YOU WON $1000 DOLLARS"
-      risk_data.device_data_captured.should be_truthy
-      risk_data.fraud_service_provider.should == "kount"
+    it "sets id, decision, device_data_captured, decision_reasons and transaction_risk_score" do
+      risk_data = Braintree::RiskData.new(:id => "123", :decision => "YOU WON $1000 DOLLARS", :device_data_captured => true, :fraud_service_provider => "fraud_protection", :decision_reasons => ["reason"], :transaction_risk_score => "12")
+      expect(risk_data.id).to eql "123"
+      expect(risk_data.decision).to eql "YOU WON $1000 DOLLARS"
+      expect(risk_data.device_data_captured).to be_truthy
+      expect(risk_data.fraud_service_provider).to eql "fraud_protection"
+      expect(risk_data.decision_reasons).to eql ["reason"]
+      expect(risk_data.transaction_risk_score).to eql "12"
+      expect(risk_data.liability_shift).to be_nil
+    end
+
+    it "sets liability shift info" do
+      risk_data = Braintree::RiskData.new(
+        :id => "123",
+        :decision => "YOU WON $1000 DOLLARS",
+        :device_data_captured => true,
+        :fraud_service_provider => "fraud_protection",
+        :decision_reasons => ["reason"],
+        :transaction_risk_score => "12",
+        :liability_shift => {
+          :responsible_party => "paypal",
+          :conditions => ["unauthorized"]},
+      )
+      expect(risk_data.liability_shift.responsible_party).to eql "paypal"
+      expect(risk_data.liability_shift.conditions).to eql ["unauthorized"]
     end
   end
 
@@ -16,10 +35,21 @@ describe Braintree::RiskData do
       details = Braintree::RiskData.new(
         :id => "123",
         :decision => "YOU WON $1000 DOLLARS",
+        :decision_reasons => ["reason"],
         :device_data_captured => true,
-        :fraud_service_provider => "kount",
+        :fraud_service_provider => "fraud_protection",
+        :transaction_risk_score => "12",
+      )
+      expect(details.inspect).to eql %(#<RiskData id: "123", decision: "YOU WON $1000 DOLLARS", decision_reasons: ["reason"], device_data_captured: true, fraud_service_provider: "fraud_protection", liability_shift: nil, transaction_risk_score: "12">)
+    end
+
+    it "prints liability shift attributes, too" do
+      details = Braintree::RiskData.new(
+        :liability_shift => {
+          :responsible_party => "paypal",
+          :conditions => ["unauthorized"]},
       )
-      details.inspect.should == %(#<RiskData id: "123", decision: "YOU WON $1000 DOLLARS", device_data_captured: true, fraud_service_provider: "kount">)
+      expect(details.inspect).to eql %(#<RiskData id: nil, decision: nil, decision_reasons: nil, device_data_captured: nil, fraud_service_provider: nil, liability_shift: #<LiabilityShift responsible_party: "paypal", conditions: ["unauthorized"]>, transaction_risk_score: nil>)
     end
   end
 end

data/spec/unit/braintree/subscription_search_spec.rb

@@ -11,7 +11,7 @@ module Braintree
             Subscription::Status::Active,
             Subscription::Status::Canceled,
             Subscription::Status::Expired,
-            Subscription::Status::PastDue
+            Subscription::Status::PastDue,
           )
         end.should_not raise_error
       end

data/spec/unit/braintree/successful_result_spec.rb

@@ -5,7 +5,7 @@ describe Braintree::SuccessfulResult do
     it "sets instance variables from the values in the hash" do
       result = Braintree::SuccessfulResult.new(
         :transaction => "transaction_value",
-        :credit_card => "credit_card_value"
+        :credit_card => "credit_card_value",
       )
       result.success?.should == true
       result.transaction.should == "transaction_value"

data/spec/unit/braintree/three_d_secure_info_spec.rb

@@ -3,37 +3,55 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 describe Braintree::ThreeDSecureInfo do
   let(:three_d_secure_info) {
     Braintree::ThreeDSecureInfo.new(
+      :acs_transaction_id => "acs_id",
+      :cavv => "cavvvalue",
+      :ds_transaction_id => "dstrxid",
+      :eci_flag => "06",
       :enrolled => "Y",
-      :liability_shifted => true,
       :liability_shift_possible => true,
-      :cavv => "cavvvalue",
-      :xid => "xidvalue",
+      :liability_shifted => true,
+      :pares_status => "Y",
       :status => "authenticate_successful",
-      :eci_flag => "06",
-      :three_d_secure_version => "1.0.2",
-      :ds_transaction_id => "dstrxid",
       :three_d_secure_authentication_id => "auth_id",
+      :three_d_secure_transaction_id => "trans_id",
+      :three_d_secure_version => "1.0.2",
+      :xid => "xidvalue",
+      :authentication => {
+        :trans_status => "authstatus",
+        :trans_status_reason => "authstatusreason"
+      },
+      :lookup => {
+        :trans_status => "lookupstatus",
+        :trans_status_reason => "lookupstatusreason"
+      },
     )
   }
 
   describe "#initialize" do
     it "sets attributes" do
-      three_d_secure_info.enrolled.should == "Y"
-      three_d_secure_info.status.should == "authenticate_successful"
-      three_d_secure_info.liability_shifted.should == true
-      three_d_secure_info.liability_shift_possible.should == true
+      three_d_secure_info.acs_transaction_id.should == "acs_id"
       three_d_secure_info.cavv.should == "cavvvalue"
-      three_d_secure_info.xid.should == "xidvalue"
-      three_d_secure_info.eci_flag.should == "06"
-      three_d_secure_info.three_d_secure_version.should == "1.0.2"
       three_d_secure_info.ds_transaction_id.should == "dstrxid"
+      three_d_secure_info.eci_flag.should == "06"
+      three_d_secure_info.enrolled.should == "Y"
+      three_d_secure_info.liability_shift_possible.should == true
+      three_d_secure_info.liability_shifted.should == true
+      three_d_secure_info.pares_status.should == "Y"
+      three_d_secure_info.status.should == "authenticate_successful"
       three_d_secure_info.three_d_secure_authentication_id.should == "auth_id"
+      three_d_secure_info.three_d_secure_transaction_id.should == "trans_id"
+      three_d_secure_info.three_d_secure_version.should == "1.0.2"
+      three_d_secure_info.xid.should == "xidvalue"
+      three_d_secure_info.lookup[:trans_status].should == "lookupstatus"
+      three_d_secure_info.lookup[:trans_status_reason].should == "lookupstatusreason"
+      three_d_secure_info.authentication[:trans_status].should == "authstatus"
+      three_d_secure_info.authentication[:trans_status_reason].should == "authstatusreason"
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      three_d_secure_info.inspect.should == %(#<ThreeDSecureInfo enrolled: "Y", liability_shifted: true, liability_shift_possible: true, status: "authenticate_successful", cavv: "cavvvalue", xid: "xidvalue", eci_flag: "06", three_d_secure_version: "1.0.2", ds_transaction_id: "dstrxid", three_d_secure_authentication_id: "auth_id">)
+      three_d_secure_info.inspect.should == %(#<ThreeDSecureInfo acs_transaction_id: "acs_id", authentication: {:trans_status=>"authstatus", :trans_status_reason=>"authstatusreason"}, cavv: "cavvvalue", ds_transaction_id: "dstrxid", eci_flag: "06", enrolled: "Y", liability_shift_possible: true, liability_shifted: true, lookup: {:trans_status=>"lookupstatus", :trans_status_reason=>"lookupstatusreason"}, pares_status: "Y", status: "authenticate_successful", three_d_secure_authentication_id: "auth_id", three_d_secure_transaction_id: "trans_id", three_d_secure_version: "1.0.2", xid: "xidvalue">)
     end
   end
 

data/spec/unit/braintree/transaction/credit_card_details_spec.rb

@@ -5,7 +5,7 @@ describe Braintree::Transaction::CreditCardDetails do
     it "concats expiration_month and expiration_year" do
       details = Braintree::Transaction::CreditCardDetails.new(
         :expiration_month => "08",
-        :expiration_year => "2009"
+        :expiration_year => "2009",
       )
       details.expiration_date.should == "08/2009"
     end
@@ -32,7 +32,7 @@ describe Braintree::Transaction::CreditCardDetails do
         :country_of_issuance => "Lilliput",
         :issuing_bank => "Gulliver Bank",
         :image_url => "example.com/visa.png",
-        :unique_number_identifier => "abc123"
+        :unique_number_identifier => "abc123",
       )
       details.inspect.should == %(#<token: "token", bin: "123456", last_4: "6789", card_type: "Visa", expiration_date: "05/2012", cardholder_name: "The Cardholder", customer_location: "US", prepaid: "Yes", healthcare: "No", durbin_regulated: "No", debit: "Yes", commercial: "Unknown", payroll: "Unknown", product_id: "Unknown", country_of_issuance: "Lilliput", issuing_bank: "Gulliver Bank", image_url: "example.com/visa.png", unique_number_identifier: "abc123">)
     end
@@ -41,7 +41,7 @@ describe Braintree::Transaction::CreditCardDetails do
   describe "masked_number" do
     it "concatenates the bin, some *'s, and the last_4" do
       details = Braintree::Transaction::CreditCardDetails.new(
-        :bin => "510510", :last_4 => "5100"
+        :bin => "510510", :last_4 => "5100",
       )
       details.masked_number.should == "510510******5100"
     end

data/spec/unit/braintree/transaction/customer_details_spec.rb

@@ -11,7 +11,7 @@ describe Braintree::Transaction::CustomerDetails do
         :company => "Smith Co.",
         :website => "http://www.example.com",
         :phone => "6145551234",
-        :fax => "3125551234"
+        :fax => "3125551234",
       )
       details.inspect.should == %(#<id: "id", first_name: "Amy", last_name: "Smith", email: "amy.smith@example.com", company: "Smith Co.", website: "http://www.example.com", phone: "6145551234", fax: "3125551234">)
     end

data/spec/unit/braintree/transaction/deposit_details_spec.rb

@@ -4,13 +4,13 @@ describe Braintree::Transaction::DisbursementDetails do
   describe "valid?" do
     it "returns true if disbursement details are initialized" do
       details = Braintree::Transaction::DisbursementDetails.new(
-        :disbursement_date => Date.new(2013, 4, 1)
+        :disbursement_date => Date.new(2013, 4, 1),
       )
       details.valid?.should == true
     end
     it "returns true if disbursement details are initialized" do
       details = Braintree::Transaction::DisbursementDetails.new(
-        :disbursement_date => nil
+        :disbursement_date => nil,
       )
       details.valid?.should == false
     end

data/spec/unit/braintree/transaction/installment_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::Transaction::Installment do
+  describe "inspect" do
+    it "assigns all fields" do
+      adjustment_attributes = {
+        :amount => "0.98",
+        :kind => "REFUND",
+        :projected_disbursement_date => "2020-01-03 01:02:03Z",
+        :actual_disbursement_date => "2020-01-04 01:02:03Z",
+      }
+      installment_attributes = {
+        :id => "abc123",
+        :amount => "1.23",
+        :projected_disbursement_date => "2020-01-01 01:02:03Z",
+        :actual_disbursement_date => "2020-01-02 01:02:03Z",
+        :adjustments => [adjustment_attributes],
+      }
+
+      installment = Braintree::Transaction::Installment.new(installment_attributes)
+
+      expect(installment.inspect).to eq('#<id: "abc123", amount: 0.123e1, projected_disbursement_date: "2020-01-01 01:02:03Z", actual_disbursement_date: "2020-01-02 01:02:03Z", adjustments: [#<amount: 0.98e0, kind: "REFUND", projected_disbursement_date: "2020-01-03 01:02:03Z", actual_disbursement_date: "2020-01-04 01:02:03Z">]>')
+    end
+  end
+end

data/spec/unit/braintree/transaction/paypal_details_spec.rb

@@ -5,6 +5,7 @@ describe Braintree::Transaction::PayPalDetails do
     it "sets all fields" do
       details = Braintree::Transaction::PayPalDetails.new(
         :authorization_id => "id",
+        :billing_agreement_id => "billing-agreement-id",
         :capture_id => "capture-id",
         :custom_field => "custom-field",
         :debug_id => "debug-id",
@@ -24,12 +25,15 @@ describe Braintree::Transaction::PayPalDetails do
         :refund_from_transaction_fee_currency_iso_code => "123",
         :refund_id => "refund-id",
         :seller_protection_status => "seller-protection-status",
+        :tax_id => "tax-id",
+        :tax_id_type => "tax-id-type",
         :token => "token",
         :transaction_fee_amount => "2.00",
-        :transaction_fee_currency_iso_code => "123"
+        :transaction_fee_currency_iso_code => "123",
       )
 
       expect(details.authorization_id).to eq("id")
+      expect(details.billing_agreement_id).to eq("billing-agreement-id")
       expect(details.capture_id).to eq("capture-id")
       expect(details.custom_field).to eq("custom-field")
       expect(details.debug_id).to eq("debug-id")
@@ -49,6 +53,8 @@ describe Braintree::Transaction::PayPalDetails do
       expect(details.refund_from_transaction_fee_currency_iso_code).to eq("123")
       expect(details.refund_id).to eq("refund-id")
       expect(details.seller_protection_status).to eq("seller-protection-status")
+      expect(details.tax_id).to eq("tax-id")
+      expect(details.tax_id_type).to eq("tax-id-type")
       expect(details.token).to eq("token")
       expect(details.transaction_fee_amount).to eq("2.00")
       expect(details.transaction_fee_currency_iso_code).to eq("123")