braintree 4.9.0 → 4.11.0

data/spec/integration/braintree/transaction_spec.rb

@@ -1001,6 +1001,27 @@ describe Braintree::Transaction do
         result.success?.should == false
         result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::TokenIssuance
       end
+
+      xit "exposes the excessive_retry gateway rejection reason" do
+        with_duplicate_checking_merchant do
+          result = nil
+          counter = 0
+          excessive_retry = false
+          until excessive_retry || counter == 20
+            result = Braintree::Transaction.sale(
+              :amount => Braintree::Test::TransactionAmounts::Decline,
+              :credit_card => {
+                :number => Braintree::Test::CreditCardNumbers::Visa,
+                :expiration_month => "05",
+                :expiration_year => "2011"
+              },
+              )
+            excessive_retry = result.transaction.status == "gateway_rejected"
+            counter +=1
+          end
+          expect(result.transaction.gateway_rejection_reason). to eq(Braintree::Transaction::GatewayRejectionReason::ExcessiveRetry)
+        end
+      end
     end
 
     it "accepts credit card expiration month and expiration year" do
@@ -1486,6 +1507,32 @@ describe Braintree::Transaction do
         result.transaction.recurring.should == true
       end
 
+      it "successfully creates a transaction with installment_first" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :transaction_source => "installment_first",
+        )
+        result.success?.should == true
+      end
+
+      it "successfully creates a transaction with installment" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :transaction_source => "installment",
+        )
+        result.success?.should == true
+      end
+
       it "marks a transactions as merchant" do
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -1710,35 +1757,6 @@ describe Braintree::Transaction do
       end
     end
 
-    describe "venmo_sdk" do
-      it "can create a card with a venmo sdk payment method code" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode,
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.bin.should == "400934"
-        result.transaction.credit_card_details.last_4.should == "1881"
-      end
-
-      it "can create a transaction with venmo sdk session" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :options => {
-            :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-          },
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-    end
-
     context "client API" do
       it "can create a transaction with a shared card nonce" do
         nonce = nonce_for_new_payment_method(
@@ -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,50 @@ describe Braintree::Transaction do
       end
     end
 
-    context "Amex Pay with Points" do
+
+    context "3rd party Card on File Network Token" do
+      it "Works with all params" do
+        params = {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+            :network_tokenization_attributes => {
+              :cryptogram => "/wAAAAAAAcb8AlGUF/1JQEkAAAA=",
+              :ecommerce_indicator => "05",
+              :token_requestor_id => "45310020105"
+            },
+          }
+        }
+        result = Braintree::Transaction.sale(params)
+        expect(result.success?).to eq true
+        expect(result.transaction.status).to eq Braintree::Transaction::Status::Authorized
+        expect(result.transaction.processed_with_network_token?).to eq true
+
+        network_token_details = result.transaction.network_token_details
+        expect(network_token_details.is_network_tokenized?).to eq true
+      end
+
+      it "returns errors if validations on cryptogram fails" do
+        params = {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+            :network_tokenization_attributes => {
+              :ecommerce_indicator => "05",
+              :token_requestor_id => "45310020105"
+            },
+          }
+        }
+        result = Braintree::Transaction.sale(params)
+
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:transaction).for(:credit_card).map { |e| e.code }.sort).to eq [Braintree::ErrorCodes::CreditCard::NetworkTokenizationAttributeCryptogramIsRequired]
+      end
+    end
+
+    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 +5578,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 +5602,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 +6384,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
 
@@ -6650,61 +6711,6 @@ describe Braintree::Transaction do
     Braintree::Transaction.find(transaction.id)
   end
 
-  context "venmo sdk" do
-    describe "venmo_sdk_payment_method_code" do
-      it "can create a transaction with venmo_sdk_payment_method_code" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK.generate_test_payment_method_code(Braintree::Test::CreditCardNumbers::Visa),
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-
-      it "errors when an invalid payment method code is passed" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode,
-        )
-        result.success?.should == false
-        result.message.should include("Invalid VenmoSDK payment method code")
-        result.errors.map(&:code).should include("91727")
-      end
-    end
-
-    describe "venmo_sdk_session" do
-      it "can create a transaction and vault a card when a venmo_sdk_session is present" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
-          :options => {
-            :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-          },
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-
-      it "venmo_sdk boolean is false when an invalid session is passed" do
-        result = Braintree::Transaction.sale(
-          :amount => "10.00",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
-          :options => {
-            :venmo_sdk_session => Braintree::Test::VenmoSDK::InvalidSession
-          },
-        )
-        result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == false
-      end
-    end
-  end
-
   context "paypal" do
     it "can create a transaction for a paypal account" do
       result = Braintree::Transaction.sale(
@@ -7215,7 +7221,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,35 +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"
-    end
+  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 "cardholder_name" do
-    it "returns Apple pay card cardholder name" do
-      Braintree::ApplePayCard._new(:gateway, cardholder_name: "John Miller").cardholder_name.should == "John Miller"
+  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/credit_card_verification_gateway_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::CreditCardVerificationGateway do
+  describe "Credit Card Verification Gateway" do
+    let(:gateway) do
+      config = Braintree::Configuration.new(
+        :merchant_id => "merchant_id",
+        :public_key => "public_key",
+        :private_key => "private_key",
+      )
+      Braintree::Gateway.new(config)
+    end
+
+    it "creates a credit card verification gateway" do
+      result = Braintree::CreditCardVerificationGateway.new(gateway)
+
+      result.inspect.should include("merchant_id")
+      result.inspect.should include("public_key")
+      result.inspect.should include("private_key")
+    end
+
+    it "creates a credit card verification gateway signature" do
+      result = Braintree::CreditCardVerificationGateway._create_signature
+      result.inspect.should include("credit_card")
+      result.inspect.should include("credit_card")
+      result.inspect.should include("cardholder_name")
+      result.inspect.should include("cvv")
+      result.inspect.should include("expiration_date")
+      result.inspect.should include("expiration_month")
+      result.inspect.should include("expiration_year")
+      result.inspect.should include("number")
+      result.inspect.should include("billing_address")
+      result.inspect.should include("intended_transaction_source")
+      result.inspect.should include("options")
+      result.inspect.should include("amount")
+      result.inspect.should include("merchant_account_id")
+      result.inspect.should include("account_type")
+      result.inspect.should include("payment_method_nonce")
+      result.inspect.should include("three_d_secure_authentication_id")
+      result.inspect.should include("three_d_secure_pass_thru")
+      result.inspect.should include("eci_flag")
+      result.inspect.should include("cavv")
+      result.inspect.should include("xid")
+      result.inspect.should include("three_d_secure_version")
+      result.inspect.should include("authentication_response")
+      result.inspect.should include("directory_response")
+      result.inspect.should include("cavv_algorithm")
+      result.inspect.should include("ds_transaction_id")
+    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

@@ -47,6 +47,7 @@ describe Braintree::DisputeSearch do
     :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

@@ -16,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,
@@ -428,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
 

data/spec/unit/braintree/sepa_debit_account_nonce_details_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::SepaDirectDebitAccountNonceDetails do
+  subject do
+    described_class.new(
+      :bank_reference_token => "a-bank-reference-token",
+      :last_4 => "abcd",
+      :mandate_type => "ONE_OFF",
+      :merchant_or_partner_customer_id => "a-mp-customer-id",
+    )
+  end
+
+  describe "#initialize" do
+    it "sets attributes" do
+      is_expected.to have_attributes(
+        :bank_reference_token => "a-bank-reference-token",
+        :last_4 => "abcd",
+        :mandate_type => "ONE_OFF",
+        :merchant_or_partner_customer_id => "a-mp-customer-id",
+      )
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      subject.inspect.should == %(#<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
+end