braintree 4.14.0 → 4.16.0

data/spec/unit/braintree/subscription_search_spec.rb

@@ -6,14 +6,14 @@ module Braintree
       it "allows Active, Canceled, Expired, and PastDue" do
         search = SubscriptionSearch.new
 
-        lambda do
+        expect do
           search.status.in(
             Subscription::Status::Active,
             Subscription::Status::Canceled,
             Subscription::Status::Expired,
             Subscription::Status::PastDue,
           )
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
@@ -22,14 +22,14 @@ module Braintree
         search = SubscriptionSearch.new
         search.in_trial_period.is true
 
-        search.to_hash.should == {:in_trial_period => [true]}
+        expect(search.to_hash).to eq({:in_trial_period => [true]})
       end
 
       it "allows false" do
         search = SubscriptionSearch.new
         search.in_trial_period.is false
 
-        search.to_hash.should == {:in_trial_period => [false]}
+        expect(search.to_hash).to eq({:in_trial_period => [false]})
       end
     end
 
@@ -38,14 +38,14 @@ module Braintree
         search = SubscriptionSearch.new
         search.days_past_due.is "30"
 
-        search.to_hash.should == {:days_past_due => {:is => "30"}}
+        expect(search.to_hash).to eq({:days_past_due => {:is => "30"}})
       end
 
       it "coverts ints to strings" do
         search = SubscriptionSearch.new
         search.days_past_due.is 30
 
-        search.to_hash.should == {:days_past_due => {:is => "30"}}
+        expect(search.to_hash).to eq({:days_past_due => {:is => "30"}})
       end
     end
 
@@ -54,7 +54,7 @@ module Braintree
         search = SubscriptionSearch.new
         search.merchant_account_id.in "ma_id1", "ma_id2"
 
-        search.to_hash.should == {:merchant_account_id => ["ma_id1", "ma_id2"]}
+        expect(search.to_hash).to eq({:merchant_account_id => ["ma_id1", "ma_id2"]})
       end
     end
 
@@ -63,63 +63,63 @@ module Braintree
         search = SubscriptionSearch.new
         search.plan_id.starts_with "plan_"
 
-        search.to_hash.should == {:plan_id => {:starts_with => "plan_"}}
+        expect(search.to_hash).to eq({:plan_id => {:starts_with => "plan_"}})
       end
 
       it "ends_with" do
         search = SubscriptionSearch.new
         search.plan_id.ends_with "_id"
 
-        search.to_hash.should == {:plan_id => {:ends_with => "_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:ends_with => "_id"}})
       end
 
       it "is" do
         search = SubscriptionSearch.new
         search.plan_id.is "p_id"
 
-        search.to_hash.should == {:plan_id => {:is => "p_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:is => "p_id"}})
       end
 
       it "is_not" do
         search = SubscriptionSearch.new
         search.plan_id.is_not "p_id"
 
-        search.to_hash.should == {:plan_id => {:is_not => "p_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:is_not => "p_id"}})
       end
 
       it "contains" do
         search = SubscriptionSearch.new
         search.plan_id.contains "p_id"
 
-        search.to_hash.should == {:plan_id => {:contains => "p_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:contains => "p_id"}})
       end
 
       it "in" do
         search = SubscriptionSearch.new
         search.plan_id.in ["plan1", "plan2"]
 
-        search.to_hash.should == {:plan_id => ["plan1", "plan2"]}
+        expect(search.to_hash).to eq({:plan_id => ["plan1", "plan2"]})
       end
     end
 
     context "days_past_due" do
       it "is a range node" do
         search = SubscriptionSearch.new
-        search.days_past_due.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.days_past_due).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
     context "billing_cycles_remaining" do
       it "is a range node" do
         search = SubscriptionSearch.new
-        search.billing_cycles_remaining.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.billing_cycles_remaining).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
     context "created_at" do
       it "is a range node" do
         search = SubscriptionSearch.new
-        search.created_at.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
@@ -128,7 +128,7 @@ module Braintree
         search = SubscriptionSearch.new
         search.id.is "s_id"
 
-        search.to_hash.should == {:id => {:is => "s_id"}}
+        expect(search.to_hash).to eq({:id => {:is => "s_id"}})
       end
     end
   end

data/spec/unit/braintree/subscription_spec.rb

@@ -11,8 +11,8 @@ describe Braintree::Subscription do
 
   context "price" do
     it "accepts price as either a String or a BigDecimal" do
-      Braintree::Subscription._new(:gateway, default_params.merge(:price => "12.34")).price.should == BigDecimal("12.34")
-      Braintree::Subscription._new(:gateway, default_params.merge(:price => BigDecimal("12.34"))).price.should == BigDecimal("12.34")
+      expect(Braintree::Subscription._new(:gateway, default_params.merge(:price => "12.34")).price).to eq(BigDecimal("12.34"))
+      expect(Braintree::Subscription._new(:gateway, default_params.merge(:price => BigDecimal("12.34"))).price).to eq(BigDecimal("12.34"))
     end
 
     it "blows up if price is not a string or BigDecimal" do
@@ -42,7 +42,7 @@ describe Braintree::Subscription do
     end
 
     it "does not raise an error if subscription id does not respond to strip" do
-      Braintree::Http.stub(:new).and_return double(:get => {:subscription => default_params})
+      allow(Braintree::Http).to receive(:new).and_return double(:get => {:subscription => default_params})
       expect do
         Braintree::Subscription.find(8675309)
       end.to_not raise_error
@@ -51,11 +51,11 @@ describe Braintree::Subscription do
 
   describe "self.search" do
     it "only allows specified values for status" do
-      lambda do
+      expect do
         Braintree::Subscription.search do |search|
           search.status.in "Hammer"
         end
-      end.should raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -63,18 +63,18 @@ describe Braintree::Subscription do
     it "returns true for subscriptions with the same id" do
       subscription1 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
       subscription2 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
-      subscription1.should == subscription2
+      expect(subscription1).to eq(subscription2)
     end
 
     it "returns false for subscriptions with different ids" do
       subscription1 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
       subscription2 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "not_123"))
-      subscription1.should_not == subscription2
+      expect(subscription1).not_to eq(subscription2)
     end
 
     it "returns false if not comparing to a subscription" do
       subscription = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
-      subscription.should_not == "not a subscription"
+      expect(subscription).not_to eq("not a subscription")
     end
   end
 end

data/spec/unit/braintree/successful_result_spec.rb

@@ -7,21 +7,21 @@ describe Braintree::SuccessfulResult do
         :transaction => "transaction_value",
         :credit_card => "credit_card_value",
       )
-      result.success?.should == true
-      result.transaction.should == "transaction_value"
-      result.credit_card.should == "credit_card_value"
+      expect(result.success?).to eq(true)
+      expect(result.transaction).to eq("transaction_value")
+      expect(result.credit_card).to eq("credit_card_value")
     end
 
     it "can be initialized without any values" do
       result = Braintree::SuccessfulResult.new
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
   end
 
   describe "inspect" do
     it "is pretty" do
       result = Braintree::SuccessfulResult.new(:transaction => "transaction_value")
-      result.inspect.should == "#<Braintree::SuccessfulResult transaction:\"transaction_value\">"
+      expect(result.inspect).to eq("#<Braintree::SuccessfulResult transaction:\"transaction_value\">")
     end
   end
 end

data/spec/unit/braintree/three_d_secure_info_spec.rb

@@ -29,41 +29,41 @@ describe Braintree::ThreeDSecureInfo do
 
   describe "#initialize" do
     it "sets attributes" do
-      three_d_secure_info.acs_transaction_id.should == "acs_id"
-      three_d_secure_info.cavv.should == "cavvvalue"
-      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"
+      expect(three_d_secure_info.acs_transaction_id).to eq("acs_id")
+      expect(three_d_secure_info.cavv).to eq("cavvvalue")
+      expect(three_d_secure_info.ds_transaction_id).to eq("dstrxid")
+      expect(three_d_secure_info.eci_flag).to eq("06")
+      expect(three_d_secure_info.enrolled).to eq("Y")
+      expect(three_d_secure_info.liability_shift_possible).to eq(true)
+      expect(three_d_secure_info.liability_shifted).to eq(true)
+      expect(three_d_secure_info.pares_status).to eq("Y")
+      expect(three_d_secure_info.status).to eq("authenticate_successful")
+      expect(three_d_secure_info.three_d_secure_authentication_id).to eq("auth_id")
+      expect(three_d_secure_info.three_d_secure_transaction_id).to eq("trans_id")
+      expect(three_d_secure_info.three_d_secure_version).to eq("1.0.2")
+      expect(three_d_secure_info.xid).to eq("xidvalue")
+      expect(three_d_secure_info.lookup[:trans_status]).to eq("lookupstatus")
+      expect(three_d_secure_info.lookup[:trans_status_reason]).to eq("lookupstatusreason")
+      expect(three_d_secure_info.authentication[:trans_status]).to eq("authstatus")
+      expect(three_d_secure_info.authentication[:trans_status_reason]).to eq("authstatusreason")
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      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">)
+      expect(three_d_secure_info.inspect).to eq(%(#<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
 
   describe "liability_shifted" do
     it "is aliased to liability_shifted?" do
-      three_d_secure_info.liability_shifted?.should == true
+      expect(three_d_secure_info.liability_shifted?).to eq(true)
     end
   end
 
   describe "liability_shift_possible" do
     it "is aliased to liability_shift_possible?" do
-      three_d_secure_info.liability_shift_possible?.should == true
+      expect(three_d_secure_info.liability_shift_possible?).to eq(true)
     end
   end
 end

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

@@ -7,7 +7,7 @@ describe Braintree::Transaction::CreditCardDetails do
         :expiration_month => "08",
         :expiration_year => "2009",
       )
-      details.expiration_date.should == "08/2009"
+      expect(details.expiration_date).to eq("08/2009")
     end
   end
 
@@ -34,7 +34,7 @@ describe Braintree::Transaction::CreditCardDetails do
         :image_url => "example.com/visa.png",
         :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">)
+      expect(details.inspect).to eq(%(#<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
   end
 
@@ -43,7 +43,7 @@ describe Braintree::Transaction::CreditCardDetails do
       details = Braintree::Transaction::CreditCardDetails.new(
         :bin => "510510", :last_4 => "5100",
       )
-      details.masked_number.should == "510510******5100"
+      expect(details.masked_number).to eq("510510******5100")
     end
   end
 
@@ -52,14 +52,14 @@ describe Braintree::Transaction::CreditCardDetails do
       details = Braintree::Transaction::CreditCardDetails.new(
         :is_network_tokenized => true,
       )
-      details.is_network_tokenized?.should == true
+      expect(details.is_network_tokenized?).to eq(true)
     end
 
     it "returns false if is_network_tokenized is false" do
       details = Braintree::Transaction::CreditCardDetails.new(
         :is_network_tokenized => false,
       )
-      details.is_network_tokenized?.should == false
+      expect(details.is_network_tokenized?).to eq(false)
     end
   end
 end

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

@@ -13,7 +13,7 @@ describe Braintree::Transaction::CustomerDetails do
         :phone => "6145551234",
         :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">)
+      expect(details.inspect).to eq(%(#<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
   end
 end

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

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

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

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::Transaction::LocalPaymentDetails do
+  describe "initialize" do
+    let(:params) do
+      {
+        capture_id: "a-capture-id",
+        custom_field: "custom-field",
+        debug_id: "debug-id",
+        description: "description",
+        funding_source: "ideal",
+        implicitly_vaulted_payment_method_global_id: "global-id",
+        implicitly_vaulted_payment_method_token: "payment-method-token",
+        payer_id: "payer-id",
+        payment_id: "payment-id",
+        refund_from_transaction_fee_amount: "2.34",
+        refund_from_transaction_fee_currency_iso_code: "EUR",
+        refund_id: "a-refund-id",
+        transaction_fee_amount: "12.34",
+        transaction_fee_currency_iso_code: "EUR",
+      }
+    end
+
+    subject { described_class.new(params) }
+
+    it "sets all fields" do
+      is_expected.to have_attributes(**params)
+    end
+  end
+end

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -14,9 +14,9 @@ describe Braintree::TransactionGateway do
     it "creates a transactionGateway gateway" do
       result = Braintree::TransactionGateway.new(gateway)
 
-      result.inspect.should include("merchant_id")
-      result.inspect.should include("public_key")
-      result.inspect.should include("private_key")
+      expect(result.inspect).to include("merchant_id")
+      expect(result.inspect).to include("public_key")
+      expect(result.inspect).to include("private_key")
     end
 
     describe "self.create" do
@@ -28,6 +28,9 @@ describe Braintree::TransactionGateway do
       end
     end
 
+    # NEXT_MAJOR_VERSION Remove three_d_secure_token, venmo_sdk_payment_method_code, and venmo_sdk_session
+    # the old venmo SDK has been deprecated
+    # three_d_secure_token has been deprecated in favor of three_d_secure_authentication_id
     it "creates a transaction gateway signature" do
       expect(Braintree::TransactionGateway._create_signature).to match([
         :amount, :billing_address_id, :channel, :customer_id, :device_data, :discount_amount,
@@ -35,8 +38,8 @@ describe Braintree::TransactionGateway do
         :product_sku, :purchase_order_number, :service_fee_amount, :shared_billing_address_id,
         :shared_customer_id, :shared_payment_method_nonce, :shared_payment_method_token,
         :shared_shipping_address_id, :shipping_address_id, :shipping_amount,
-        :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,
-        :three_d_secure_token, :transaction_source, :type, :venmo_sdk_payment_method_code,
+        :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,:three_d_secure_token, #Deprecated
+        :transaction_source, :type, :venmo_sdk_payment_method_code, #Deprecated
         :sca_exemption, :currency_iso_code, :exchange_rate_quote_id,
         {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
         {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
@@ -67,7 +70,7 @@ describe Braintree::TransactionGateway do
           :submit_for_settlement,
           :add_billing_address_to_payment_method,
           :store_shipping_address_in_vault,
-          :venmo_sdk_session,
+          :venmo_sdk_session, #Deprecated
           :payee_id,
           :payee_email,
           :skip_advanced_fraud_checking,
@@ -91,7 +94,7 @@ describe Braintree::TransactionGateway do
         {:industry => [
           :industry_type,
           {:data => [
-            :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate, :room_tax,
+            :country_code, :date_of_birth, :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate, :room_tax,
             :passenger_first_name, :passenger_last_name, :passenger_middle_initial, :passenger_title, :issued_date, :travel_agency_name, :travel_agency_code, :ticket_number,
             :issuing_carrier_code, :customer_code, :fare_amount, :fee_amount, :tax_amount, :restricted_ticket, :no_show, :advanced_deposit, :fire_safe, :property_phone, :ticket_issuer_address, :arrival_date,
             {:legs => [
@@ -108,5 +111,34 @@ describe Braintree::TransactionGateway do
         {:installments => [:count]},
       ])
     end
+
+    it "creates a transaction gateway submit for settlement signature" do
+      expect(Braintree::TransactionGateway._submit_for_settlement_signature).to match([
+        :order_id,
+        {:descriptor => [:name, :phone, :url]},
+        {:industry => [
+          :industry_type,
+          {:data => [
+            :country_code, :date_of_birth, :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate, :room_tax,
+            :passenger_first_name, :passenger_last_name, :passenger_middle_initial, :passenger_title, :issued_date, :travel_agency_name, :travel_agency_code, :ticket_number,
+            :issuing_carrier_code, :customer_code, :fare_amount, :fee_amount, :tax_amount, :restricted_ticket, :no_show, :advanced_deposit, :fire_safe, :property_phone, :ticket_issuer_address, :arrival_date,
+            {:legs => [
+              :conjunction_ticket, :exchange_ticket, :coupon_number, :service_class, :carrier_code, :fare_basis_code, :flight_number, :departure_date, :departure_airport_code, :departure_time,
+              :arrival_airport_code, :arrival_time, :stopover_permitted, :fare_amount, :fee_amount, :tax_amount, :endorsement_or_restrictions,
+            ]},
+            {:additional_charges => [
+              :kind, :amount,
+            ]},
+          ]},
+        ]},
+        :purchase_order_number,
+        :tax_amount,
+        :tax_exempt,
+        :discount_amount,
+        :shipping_amount,
+        :ships_from_postal_code,
+        :line_items => [:commodity_code, :description, :discount_amount, :kind, :name, :product_code, :quantity, :tax_amount, :total_amount, :unit_amount, :unit_of_measure, :unit_tax_amount, :url, :tax_amount],
+      ])
+    end
   end
 end

data/spec/unit/braintree/transaction_search_spec.rb

@@ -5,14 +5,14 @@ describe Braintree::TransactionSearch do
     search = Braintree::TransactionSearch.new
     search.billing_company.is "one"
     search.billing_company.is "two"
-    search.to_hash.should == {:billing_company => {:is => "two"}}
+    expect(search.to_hash).to eq({:billing_company => {:is => "two"}})
   end
 
   it "overrides previous 'in' with new 'in' for the same field" do
     search = Braintree::TransactionSearch.new
     search.status.in Braintree::Transaction::Status::Authorized
     search.status.in Braintree::Transaction::Status::SubmittedForSettlement
-    search.to_hash.should == {:status => [Braintree::Transaction::Status::SubmittedForSettlement]}
+    expect(search.to_hash).to eq({:status => [Braintree::Transaction::Status::SubmittedForSettlement]})
   end
 
   it "raises if the operator 'is' is left off" do