braintree 4.8.0 → 4.10.0

data/spec/integration/braintree/sepa_direct_debit_account_spec.rb

@@ -0,0 +1,176 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::SepaDirectDebitAccount do
+  before do
+    Braintree::Configuration.merchant_id = "integration_merchant_id"
+    Braintree::Configuration.public_key = "integration_public_key"
+    Braintree::Configuration.private_key = "integration_private_key"
+  end
+
+  let(:customer) { Braintree::Customer.create.customer }
+  let(:nonce) { Braintree::Test::Nonce::SepaDirectDebit }
+
+  let(:token) do
+    Braintree::PaymentMethod.create(
+      payment_method_nonce: nonce,
+      customer_id: customer.id,
+    ).payment_method.token
+  end
+
+  describe "self.find" do
+    subject do
+      described_class.find(token)
+    end
+
+    context "when payment method exists" do
+      it "returns a payment method" do
+        sepa_direct_debit_account = subject
+        sepa_direct_debit_account.should be_a(Braintree::SepaDirectDebitAccount)
+        sepa_direct_debit_account.last_4.should == "1234"
+        sepa_direct_debit_account.default.should == true
+        sepa_direct_debit_account.customer_id.should == customer.id
+        sepa_direct_debit_account.global_id.should_not be_empty
+        sepa_direct_debit_account.customer_global_id.should_not be_empty
+        sepa_direct_debit_account.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account.token.should_not be_empty
+        sepa_direct_debit_account.image_url.should_not be_empty
+        sepa_direct_debit_account.created_at.should be_a Time
+        sepa_direct_debit_account.updated_at.should be_a Time
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+  end
+
+  describe "self.delete" do
+    subject do
+      described_class.delete(token)
+    end
+
+    context "when payment method exists" do
+      it "deletes a payment method" do
+        should be_success
+
+        expect {
+          described_class.find(token)
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+  end
+
+  describe "self.sale" do
+    let(:params) do
+      {
+        amount: 1.23,
+      }
+    end
+
+    subject do
+      described_class.sale(token, params)
+    end
+
+    context "when payment method exists" do
+      it "creates a transaction" do
+        should be_success
+
+        transaction = subject.transaction
+        transaction.amount.should eq(1.23)
+        transaction.status.should == "settling"
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        sepa_direct_debit_account_details.should be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        sepa_direct_debit_account_details.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account_details.capture_id.should_not be_empty
+        sepa_direct_debit_account_details.debug_id.should be_nil
+        sepa_direct_debit_account_details.global_id.should_not be_empty
+        sepa_direct_debit_account_details.last_4.should == "1234"
+        sepa_direct_debit_account_details.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account_details.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account_details.paypal_v2_order_id.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_amount.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code.should be_nil
+        sepa_direct_debit_account_details.refund_id.should be_nil
+        sepa_direct_debit_account_details.settlement_type.should be_nil
+        sepa_direct_debit_account_details.token.should == token
+        sepa_direct_debit_account_details.transaction_fee_amount.should == "0.01"
+        sepa_direct_debit_account_details.transaction_fee_currency_iso_code.should == "USD"
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "not raises an error" do
+        expect {
+          subject
+        }.to_not raise_error
+      end
+    end
+  end
+
+  describe "self.sale!" do
+    let(:params) do
+      {
+        amount: 1.23,
+      }
+    end
+
+    subject do
+      described_class.sale!(token, params)
+    end
+
+    context "when payment method exists" do
+      it "creates a transaction" do
+        transaction = subject
+        transaction.amount.should eq(1.23)
+        transaction.status.should == "settling"
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        sepa_direct_debit_account_details.should be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        sepa_direct_debit_account_details.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account_details.capture_id.should_not be_empty
+        sepa_direct_debit_account_details.debug_id.should be_nil
+        sepa_direct_debit_account_details.global_id.should_not be_empty
+        sepa_direct_debit_account_details.last_4.should == "1234"
+        sepa_direct_debit_account_details.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account_details.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account_details.paypal_v2_order_id.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_amount.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code.should be_nil
+        sepa_direct_debit_account_details.refund_id.should be_nil
+        sepa_direct_debit_account_details.settlement_type.should be_nil
+        sepa_direct_debit_account_details.token.should == token
+        sepa_direct_debit_account_details.transaction_fee_amount.should == "0.01"
+        sepa_direct_debit_account_details.transaction_fee_currency_iso_code.should == "USD"
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "not raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::ValidationsFailed)
+      end
+    end
+  end
+end

data/spec/integration/braintree/subscription_spec.rb

@@ -96,7 +96,7 @@ describe Braintree::Subscription do
       it "creates a subscription when given a paypal account payment_method_nonce" do
         customer = Braintree::Customer.create!
         payment_method_result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
           :customer_id => customer.id,
         )
 

data/spec/integration/braintree/transaction_search_spec.rb

@@ -133,7 +133,7 @@ describe Braintree::Transaction, "search" do
     it "searches on users" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       collection = Braintree::Transaction.search do |search|
@@ -146,7 +146,7 @@ describe Braintree::Transaction, "search" do
     it "searches on paypal transactions" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       paypal_details = transaction.paypal_details
@@ -396,6 +396,38 @@ describe Braintree::Transaction, "search" do
         collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::LocalPayment
       end
 
+      it "searches by payment instrument type SepaDebitAccountDetail" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::SepaDirectDebit,
+          :options => {:submit_for_settlement => true},
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["SEPADebitAccountDetail"]
+        end
+
+        collection.first.id.should == transaction.id
+        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::SepaDirectDebitAccount
+      end
+
+      it "searches by paypal_v2_order_id" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::SepaDirectDebit,
+          :options => {:submit_for_settlement => true},
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.sepa_debit_paypal_v2_order_id.is transaction.sepa_direct_debit_account_details.paypal_v2_order_id
+        end
+
+        collection.first.id.should == transaction.id
+        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::SepaDirectDebitAccount
+      end
+
       it "searches by payment instrument type ApplePay" do
         transaction = Braintree::Transaction.sale!(
           :amount => Braintree::Test::TransactionAmounts::Authorize,

data/spec/integration/braintree/transaction_spec.rb

@@ -1001,6 +1001,24 @@ describe Braintree::Transaction do
         result.success?.should == false
         result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::TokenIssuance
       end
+
+      it "exposes the excessive_retry gateway rejection reason" do
+        with_duplicate_checking_merchant do
+          result = nil
+          16.times do
+            result = Braintree::Transaction.sale(
+              :amount => Braintree::Test::TransactionAmounts::Decline,
+              :credit_card => {
+                :number => Braintree::Test::CreditCardNumbers::Visa,
+                :expiration_month => "05",
+                :expiration_year => "2011"
+              },
+              )
+          end
+          result.success?.should == false
+          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::ExcessiveRetry
+        end
+      end
     end
 
     it "accepts credit card expiration month and expiration year" do
@@ -2687,7 +2705,7 @@ describe Braintree::Transaction do
         it "can create a transaction" do
           payment_method_result = Braintree::PaymentMethod.create(
             :customer_id => Braintree::Customer.create.customer.id,
-            :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
           )
           result = Braintree::Transaction.create(
             :type => "sale",
@@ -4334,7 +4352,7 @@ describe Braintree::Transaction do
       it "returns a validation error if used with an unsupported instrument type" do
         customer = Braintree::Customer.create!
         result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
           :customer_id => customer.id,
         )
         payment_method_token = result.payment_method.token
@@ -5208,7 +5226,7 @@ describe Braintree::Transaction do
       end
     end
 
-    context "Amex Pay with Points" do
+    xit "Amex Pay with Points" do
       context "transaction creation" do
         it "succeeds when submit_for_settlement is true" do
           result = Braintree::Transaction.sale(
@@ -5517,7 +5535,7 @@ describe Braintree::Transaction do
       end
     end
 
-    it "succeeds when level 2 data is provided" do
+    xit "succeeds when level 2 data is provided" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
@@ -5541,7 +5559,7 @@ describe Braintree::Transaction do
       result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
     end
 
-    it "succeeds when level 3 data is provided" do
+    xit "succeeds when level 3 data is provided" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
@@ -6323,23 +6341,23 @@ describe Braintree::Transaction do
         expect(transaction.three_d_secure_info.authentication).to have_key(:trans_status_reason)
         expect(transaction.three_d_secure_info.lookup).to have_key(:trans_status)
         expect(transaction.three_d_secure_info.lookup).to have_key(:trans_status_reason)
-        transaction.three_d_secure_info.cavv.should == "somebase64value"
-        transaction.three_d_secure_info.ds_transaction_id.should == "dstxnid"
-        transaction.three_d_secure_info.eci_flag.should == "07"
-        transaction.three_d_secure_info.enrolled.should == "Y"
-        transaction.three_d_secure_info.pares_status.should == "Y"
-        transaction.three_d_secure_info.should be_liability_shift_possible
-        transaction.three_d_secure_info.should be_liability_shifted
-        transaction.three_d_secure_info.status.should == "authenticate_successful"
+        expect(transaction.three_d_secure_info.cavv).to eq("somebase64value")
+        expect(transaction.three_d_secure_info.ds_transaction_id).to eq("dstxnid")
+        expect(transaction.three_d_secure_info.eci_flag).to eq("07")
+        expect(transaction.three_d_secure_info.enrolled).to eq("Y")
+        expect(transaction.three_d_secure_info.pares_status).to eq("Y")
+        expect(transaction.three_d_secure_info).to be_liability_shift_possible
+        expect(transaction.three_d_secure_info).to be_liability_shifted
+        expect(transaction.three_d_secure_info.status).to eq("authenticate_successful")
         expect(transaction.three_d_secure_info.three_d_secure_authentication_id).to be
-        transaction.three_d_secure_info.three_d_secure_version.should == "1.0.2"
-        transaction.three_d_secure_info.xid.should == "xidvalue"
+        expect(transaction.three_d_secure_info.three_d_secure_version).not_to be_nil
+        expect(transaction.three_d_secure_info.xid).to eq("xidvalue")
       end
 
       it "is nil if the transaction wasn't 3d secured" do
         transaction = Braintree::Transaction.find("settledtransaction")
 
-        transaction.three_d_secure_info.should be_nil
+        expect(transaction.three_d_secure_info).to be_nil
       end
     end
 
@@ -7215,7 +7233,7 @@ describe Braintree::Transaction do
       end
 
       it "returns failure, when transaction authorization type final or undefined" do
-        additional_params = {:transaction_source => "recurring_first"}
+        additional_params = {:transaction_source => "recurring"}
         initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params.merge(additional_params))
         expect(initial_transaction.success?).to eq(true)
 

data/spec/integration/spec_helper.rb

@@ -67,4 +67,10 @@ unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
   def random_payment_method_token
     "payment-method-token-#{SecureRandom.hex(6)}"
   end
+
+  def with_duplicate_checking_merchant(&block)
+    with_other_merchant("dup_checking_integration_merchant_id", "dup_checking_integration_public_key", "dup_checking_integration_private_key") do
+      block.call
+    end
+  end
 end

data/spec/unit/braintree/apple_pay_card_spec.rb

@@ -1,29 +1,123 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::ApplePayCard do
-  describe "bin" do
-    it "returns Apple pay card bin" do
-      Braintree::ApplePayCard._new(:gateway, bin: "411111").bin.should == "411111"
+  let(:attributes) do
+    {
+      :billing_address => {
+        company: "Braintree",
+        country_code_alpha2: "US",
+        country_code_alpha3: "USA",
+        country_code_numeric: "840",
+        country_name: "United States of America",
+        extended_address: "Apt 1",
+        first_name: "John",
+        last_name: "Miller",
+        locality: "Chicago",
+        phone_number: "17708675309",
+        postal_code: "12345",
+        region: "Illinois",
+        street_address: "123 Sesame Street",
+      },
+      :bin => "411111",
+      :card_type => "Apple Pay - MasterCard",
+      :cardholder_name => "John Miller",
+      :commercial => "No",
+      :country_of_issuance => "USA",
+      :created_at => Time.now,
+      :customer_id => "cid1",
+      :debit => "No",
+      :default => true,
+      :durbin_regulated => "Yes",
+      :expiration_month => "01",
+      :expiration_year => "2025",
+      :expired => false,
+      :healthcare => "No",
+      :image_url => nil,
+      :issuing_bank => "Big Bad Bank",
+      :last_4 => "9876",
+      :payment_instrument_name => nil,
+      :payroll => "No",
+      :prepaid => "No",
+      :product_id => "MAC",
+      :source_description => "blah",
+      :subscriptions => [
+        {
+          balance: "50.00",
+          price: "10.00",
+          descriptor: [],
+          transactions: [],
+          add_ons: [],
+          discounts: [],
+        },
+      ],
+      :token => "123456789",
+      :updated_at => Time.now,
+    }
+  end
+
+  describe "initialize" do
+    it "converts billing address hash to Braintree::Address object" do
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.billing_address).to be_instance_of(Braintree::Address)
+    end
+
+    it "converts subscriptions hash to Braintree::Subscription object" do
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.subscriptions[0]).to be_instance_of(Braintree::Subscription)
+    end
+
+    it "handles nil billing address" do
+      attributes.delete(:billing_address)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.billing_address).to be_nil
+    end
+
+    it "handles nil subscriptions" do
+      attributes.delete(:subscriptions)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.subscriptions).to be_empty
     end
   end
 
   describe "default?" do
     it "is true if the Apple pay card is the default payment method for the customer" do
-      Braintree::ApplePayCard._new(:gateway, :default => true).default?.should == true
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.default?).to be true
     end
 
     it "is false if the Apple pay card is not the default payment methodfor the customer" do
-      Braintree::ApplePayCard._new(:gateway, :default => false).default?.should == false
+      attributes.merge!(:default => false)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.default?).to be false
     end
   end
 
   describe "expired?" do
     it "is true if the Apple pay card is expired" do
-      Braintree::ApplePayCard._new(:gateway, :expired => true).expired?.should == true
+      attributes.merge!(:expired => true)
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.expired?).to be true
     end
 
     it "is false if the Apple pay card is not expired" do
-      Braintree::ApplePayCard._new(:gateway, :expired => false).expired?.should == false
+      card = Braintree::ApplePayCard._new(:gateway, attributes)
+
+      expect(card.expired?).to be false
+    end
+  end
+
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::ApplePayCard.new
+      end.to raise_error(NoMethodError, /protected method .new/)
     end
   end
 end

data/spec/unit/braintree/customer_spec.rb

@@ -301,6 +301,10 @@ describe Braintree::Customer do
           {:token => "paypal_1"},
           {:token => "paypal_2"}
         ],
+        :sepa_debit_accounts => [
+          {:token => "sepa_debit_1"},
+          {:token => "sepa_debit_2"}
+        ],
       )
 
       customer.credit_cards.size.should == 2
@@ -311,11 +315,17 @@ describe Braintree::Customer do
       customer.paypal_accounts[0].token.should == "paypal_1"
       customer.paypal_accounts[1].token.should == "paypal_2"
 
-      customer.payment_methods.count.should == 4
+      customer.sepa_direct_debit_accounts.size.should == 2
+      customer.sepa_direct_debit_accounts[0].token.should == "sepa_debit_1"
+      customer.sepa_direct_debit_accounts[1].token.should == "sepa_debit_2"
+
+      customer.payment_methods.count.should == 6
       customer.payment_methods.map(&:token).should include("credit_card_1")
       customer.payment_methods.map(&:token).should include("credit_card_2")
       customer.payment_methods.map(&:token).should include("paypal_1")
       customer.payment_methods.map(&:token).should include("paypal_2")
+      customer.payment_methods.map(&:token).should include("sepa_debit_1")
+      customer.payment_methods.map(&:token).should include("sepa_debit_2")
     end
   end
 

data/spec/unit/braintree/dispute_search_spec.rb

@@ -41,10 +41,13 @@ describe Braintree::DisputeSearch do
   end
 
   [
+    # NEXT_MAJOR_VERSION Remove this assertion when chargeback_protection_level is removed from the SDK
     :chargeback_protection_level,
+    :protection_level,
     :kind,
     :reason,
     :status,
+    :pre_dispute_program,
   ].each do |field|
     it "raises if provided an unknown #{field} value" do
       search = Braintree::DisputeSearch.new

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",
@@ -15,6 +16,7 @@ describe Braintree::Dispute do
       :received_date => "2009-03-09",
       :reply_by_date => nil,
       :updated_at => Time.utc(2009, 3, 9, 10, 50, 39),
+      :pre_dispute_program => Braintree::Dispute::PreDisputeProgram::None,
       :evidence => [
         {
           comment: nil,
@@ -283,6 +285,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,
@@ -388,6 +429,13 @@ describe Braintree::Dispute do
       dispute.date_opened.should == Date.new(2009, 3, 9)
       dispute.date_won.should == Date.new(2009, 4, 15)
     end
+
+    it "returns pre_dispute_program value" do
+      attributes.merge!(:pre_dispute_program => Braintree::Dispute::PreDisputeProgram::VisaRdr)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.pre_dispute_program).to eq(Braintree::Dispute::PreDisputeProgram::VisaRdr)
+    end
   end
 
   describe "==" do

data/spec/unit/braintree/payment_method_nonce_details_spec.rb

@@ -3,12 +3,16 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 describe Braintree::PaymentMethodNonceDetails do
   let(:payment_method_nonce_details) {
     Braintree::PaymentMethodNonceDetails.new(
+      :bank_reference_token => "a-bank-reference-token",
       :bin => "bin",
       :card_type => "American Express",
       :expiration_month => "12",
       :expiration_year => "2025",
       :is_network_tokenized => true,
+      :last_4 => "abcd",
       :last_two => "11",
+      :mandate_type => "ONE_OFF",
+      :merchant_or_partner_customer_id => "a-mp-customer-id",
       :payer_info => {
         :billing_agreement_id => "1234",
         :country_code => "US",
@@ -26,12 +30,16 @@ describe Braintree::PaymentMethodNonceDetails do
       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"
+      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.bank_reference_token.should == "a-bank-reference-token"
+      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.last_4.should == "abcd"
+      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.mandate_type.should == "ONE_OFF"
+      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.merchant_or_partner_customer_id.should == "a-mp-customer-id"
     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>>)
+      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>, sepa_direct_debit_account_nonce_details: #<SepaDirectDebitAccountNonceDetailsbank_reference_token: "a-bank-reference-token", last_4: "abcd", mandate_type: "ONE_OFF", merchant_or_partner_customer_id: "a-mp-customer-id">>)
     end
   end