braintree 2.98.0 → 4.23.0

data/spec/unit/braintree/credit_card_spec.rb

@@ -4,28 +4,28 @@ describe Braintree::CreditCard do
   describe "self.create" do
     it "raises an exception if attributes contain an invalid key" do
       expect do
-        Braintree::CreditCard.create(:invalid_key => 'val')
+        Braintree::CreditCard.create(:invalid_key => "val")
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end
 
   describe "self.create_signature" do
     it "should be what we expect" do
-      Braintree::CreditCardGateway._create_signature.should == [
+      expect(Braintree::CreditCardGateway._create_signature).to match([
         :billing_address_id,
         :cardholder_name,
         :cvv,
-        :device_session_id,
         :expiration_date,
         :expiration_month,
         :expiration_year,
         :number,
         :token,
-        :venmo_sdk_payment_method_code,
+        :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
         :device_data,
-        :fraud_merchant_id,
         :payment_method_nonce,
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
+        {:external_vault=>[:network_transaction_id]},
+        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+          :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -34,34 +34,46 @@ describe Braintree::CreditCard do
           :country_name,
           :extended_address,
           :first_name,
+          {:international_phone=>[:country_code, :national_number]},
           :last_name,
           :locality,
+          :phone_number,
           :postal_code,
           :region,
           :street_address
         ]},
-        :customer_id
-      ]
+        {:three_d_secure_pass_thru => [
+          :eci_flag,
+          :cavv,
+          :xid,
+          :three_d_secure_version,
+          :authentication_response,
+          :directory_response,
+          :cavv_algorithm,
+          :ds_transaction_id,
+        ]},
+        :customer_id,
+      ])
     end
   end
 
   describe "self.update_signature" do
     it "should be what we expect" do
-      Braintree::CreditCardGateway._update_signature.should == [
+      expect(Braintree::CreditCardGateway._update_signature).to match([
         :billing_address_id,
         :cardholder_name,
         :cvv,
-        :device_session_id,
         :expiration_date,
         :expiration_month,
         :expiration_year,
         :number,
         :token,
-        :venmo_sdk_payment_method_code,
+        :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
         :device_data,
-        :fraud_merchant_id,
         :payment_method_nonce,
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
+        {:external_vault=>[:network_transaction_id]},
+        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+          :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -70,29 +82,26 @@ describe Braintree::CreditCard do
           :country_name,
           :extended_address,
           :first_name,
+          {:international_phone=>[:country_code, :national_number]},
           :last_name,
           :locality,
+          :phone_number,
           :postal_code,
           :region,
           :street_address,
           {:options => [:update_existing]}
-        ]}
-      ]
-    end
-  end
-
-  describe "self.create_from_transparent_redirect" do
-    it "raises an exception if the query string is forged" do
-      expect do
-        Braintree::CreditCard.create_from_transparent_redirect("http_status=200&forged=query_string")
-      end.to raise_error(Braintree::ForgedQueryString)
-    end
-  end
-
-  describe "self.create_credit_card_url" do
-    it "returns the url" do
-      config = Braintree::Configuration.instantiate
-      Braintree::CreditCard.create_credit_card_url.should == "http#{config.ssl? ? 's' : ''}://#{config.server}:#{config.port}/merchants/integration_merchant_id/payment_methods/all/create_via_transparent_redirect_request"
+        ]},
+        {:three_d_secure_pass_thru => [
+          :eci_flag,
+          :cavv,
+          :xid,
+          :three_d_secure_version,
+          :authentication_response,
+          :directory_response,
+          :cavv_algorithm,
+          :ds_transaction_id,
+        ]},
+      ])
     end
   end
 
@@ -101,31 +110,31 @@ describe Braintree::CreditCard do
       first = Braintree::CreditCard._new(:gateway, :token => 123)
       second = Braintree::CreditCard._new(:gateway, :token => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false if given a credit card with a different token" do
       first = Braintree::CreditCard._new(:gateway, :token => 123)
       second = Braintree::CreditCard._new(:gateway, :token => 124)
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false if not given a credit card" do
       credit_card = Braintree::CreditCard._new(:gateway, :token => 123)
-      credit_card.should_not == "not a credit card"
+      expect(credit_card).not_to eq("not a credit card")
     end
   end
 
   describe "default?" do
     it "is true if the credit card is the default credit card for the customer" do
-      Braintree::CreditCard._new(:gateway, :default => true).default?.should == true
+      expect(Braintree::CreditCard._new(:gateway, :default => true).default?).to eq(true)
     end
 
     it "is false if the credit card is not the default credit card for the customer" do
-      Braintree::CreditCard._new(:gateway, :default => false).default?.should == false
+      expect(Braintree::CreditCard._new(:gateway, :default => false).default?).to eq(false)
     end
   end
 
@@ -149,7 +158,7 @@ describe Braintree::CreditCard do
     end
 
     it "does not raise an error if address_id does not respond to strip" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::CreditCard.find(8675309)
       end.to_not raise_error
@@ -159,7 +168,7 @@ describe Braintree::CreditCard do
   describe "inspect" do
     it "includes the token first" do
       output = Braintree::CreditCard._new(:gateway, :token => "cc123").inspect
-      output.should include("#<Braintree::CreditCard token: \"cc123\",")
+      expect(output).to include("#<Braintree::CreditCard token: \"cc123\",")
     end
 
     it "includes all customer attributes" do
@@ -174,20 +183,22 @@ describe Braintree::CreditCard do
         :expiration_year => "2020",
         :last_4 => "1111",
         :token => "tok1",
-        :updated_at => Time.now
+        :updated_at => Time.now,
+        :is_network_tokenized => false,
       )
       output = credit_card.inspect
-      output.should include(%q(bin: "411111"))
-      output.should include(%q(card_type: "Visa"))
-      output.should include(%q(cardholder_name: "John Miller"))
-
-      output.should include(%q(customer_id: "cid1"))
-      output.should include(%q(expiration_month: "01"))
-      output.should include(%q(expiration_year: "2020"))
-      output.should include(%q(last_4: "1111"))
-      output.should include(%q(token: "tok1"))
-      output.should include(%Q(updated_at: #{credit_card.updated_at.inspect}))
-      output.should include(%Q(created_at: #{credit_card.created_at.inspect}))
+      expect(output).to include(%q(bin: "411111"))
+      expect(output).to include(%q(card_type: "Visa"))
+      expect(output).to include(%q(cardholder_name: "John Miller"))
+
+      expect(output).to include(%q(customer_id: "cid1"))
+      expect(output).to include(%q(expiration_month: "01"))
+      expect(output).to include(%q(expiration_year: "2020"))
+      expect(output).to include(%q(last_4: "1111"))
+      expect(output).to include(%q(token: "tok1"))
+      expect(output).to include(%Q(updated_at: #{credit_card.updated_at.inspect}))
+      expect(output).to include(%Q(created_at: #{credit_card.created_at.inspect}))
+      expect(output).to include(%q(is_network_tokenized?: false))
     end
   end
 
@@ -196,16 +207,38 @@ describe Braintree::CreditCard do
       credit_card = Braintree::CreditCard._new(
         :gateway,
         :bin => "510510",
-        :last_4 => "5100"
+        :last_4 => "5100",
+      )
+      expect(credit_card.masked_number).to eq("510510******5100")
+    end
+  end
+
+  describe "is_network_tokenized?" do
+    it "returns true" do
+      credit_card = Braintree::CreditCard._new(
+        :gateway,
+        :bin => "510510",
+        :last_4 => "5100",
+        :is_network_tokenized => true,
+      )
+      expect(credit_card.is_network_tokenized?).to eq(true)
+    end
+
+    it "returns false" do
+      credit_card = Braintree::CreditCard._new(
+        :gateway,
+        :bin => "510510",
+        :last_4 => "5100",
+        :is_network_tokenized => false,
       )
-      credit_card.masked_number.should == "510510******5100"
+      expect(credit_card.is_network_tokenized?).to eq(false)
     end
   end
 
   describe "self.update" do
     it "raises an exception if attributes contain an invalid key" do
       expect do
-        Braintree::CreditCard._new(Braintree::Configuration.gateway, {}).update(:invalid_key => 'val')
+        Braintree::CreditCard.update(:gateway, :invalid_key => "val")
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end
@@ -221,15 +254,15 @@ describe Braintree::CreditCard do
   describe "self._new" do
     describe "initializing verification" do
       it "picks the youngest verification" do
-        verification1 = { :created_at => Time.now, :id => 123 }
-        verification2 = { :created_at => Time.now - 3600, :id => 456 }
+        verification1 = {:created_at => Time.now, :id => 123}
+        verification2 = {:created_at => Time.now - 3600, :id => 456}
         credit_card = Braintree::CreditCard._new(Braintree::Configuration.gateway, {:verifications => [verification1, verification2]})
-        credit_card.verification.id.should == 123
+        expect(credit_card.verification.id).to eq(123)
       end
 
       it "picks nil if verifications are empty" do
         credit_card = Braintree::CreditCard._new(Braintree::Configuration.gateway, {})
-        credit_card.verification.should be_nil
+        expect(credit_card.verification).to be_nil
       end
     end
   end

data/spec/unit/braintree/credit_card_verification_gateway_spec.rb

@@ -0,0 +1,56 @@
+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)
+
+      expect(result.inspect).to include("merchant_id")
+      expect(result.inspect).to include("public_key")
+      expect(result.inspect).to include("private_key")
+    end
+
+    it "creates a credit card verification gateway signature" do
+      result = Braintree::CreditCardVerificationGateway._create_signature
+      expect(result.inspect).to include("credit_card")
+      expect(result.inspect).to include("billing_address")
+      expect(result.inspect).to include("cardholder_name")
+      expect(result.inspect).to include("cvv")
+      expect(result.inspect).to include("expiration_date")
+      expect(result.inspect).to include("expiration_month")
+      expect(result.inspect).to include("expiration_year")
+      expect(result.inspect).to include("number")
+      expect(result.inspect).to include("external_vault")
+      expect(result.inspect).to include("previous_network_transaction_id")
+      expect(result.inspect).to include("status")
+      expect(result.inspect).to include("intended_transaction_source")
+      expect(result.inspect).to include("options")
+      expect(result.inspect).to include("account_type")
+      expect(result.inspect).to include("amount")
+      expect(result.inspect).to include("merchant_account_id")
+      expect(result.inspect).to include("payment_method_nonce")
+      expect(result.inspect).to include("risk_data")
+      expect(result.inspect).to include("customer_browser")
+      expect(result.inspect).to include("customer_ip")
+      expect(result.inspect).to include("three_d_secure_authentication_id")
+      expect(result.inspect).to include("three_d_secure_pass_thru")
+      expect(result.inspect).to include("authentication_response")
+      expect(result.inspect).to include("cavv")
+      expect(result.inspect).to include("cavv_algorithm")
+      expect(result.inspect).to include("directory_response")
+      expect(result.inspect).to include("ds_transaction_id")
+      expect(result.inspect).to include("eci_flag")
+      expect(result.inspect).to include("three_d_secure_version")
+      expect(result.inspect).to include("xid")
+    end
+  end
+end

data/spec/unit/braintree/credit_card_verification_search_spec.rb

@@ -7,11 +7,11 @@ module Braintree
       it "allows All card types" do
         search = CreditCardVerificationSearch.new
 
-        lambda do
+        expect do
           search.credit_card_card_type.in(
-            *Braintree::CreditCard::CardType::All
+            *Braintree::CreditCard::CardType::All,
           )
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
@@ -20,7 +20,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.id.is "v_id"
 
-        search.to_hash.should == {:id => {:is => "v_id"}}
+        expect(search.to_hash).to eq({:id => {:is => "v_id"}})
       end
     end
 
@@ -29,7 +29,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.ids.in("id1","id2")
 
-        search.to_hash.should == {:ids => ["id1", "id2"]}
+        expect(search.to_hash).to eq({:ids => ["id1", "id2"]})
       end
     end
 
@@ -38,7 +38,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.credit_card_cardholder_name.is "v_cardholder_name"
 
-        search.to_hash.should == {:credit_card_cardholder_name => {:is => "v_cardholder_name"}}
+        expect(search.to_hash).to eq({:credit_card_cardholder_name => {:is => "v_cardholder_name"}})
       end
     end
 
@@ -47,7 +47,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.credit_card_expiration_date.is_not "v_credit_card_expiration_date"
 
-        search.to_hash.should == {:credit_card_expiration_date => {:is_not => "v_credit_card_expiration_date"}}
+        expect(search.to_hash).to eq({:credit_card_expiration_date => {:is_not => "v_credit_card_expiration_date"}})
       end
     end
 
@@ -57,7 +57,7 @@ module Braintree
 
         search.credit_card_number.starts_with "v_credit_card_bin"
 
-        search.to_hash.should == {:credit_card_number => {:starts_with => "v_credit_card_bin"}}
+        expect(search.to_hash).to eq({:credit_card_number => {:starts_with => "v_credit_card_bin"}})
       end
 
       it "ends with" do
@@ -65,14 +65,14 @@ module Braintree
 
         search.credit_card_number.ends_with "v_credit_card_last_4"
 
-        search.to_hash.should == {:credit_card_number => {:ends_with => "v_credit_card_last_4"}}
+        expect(search.to_hash).to eq({:credit_card_number => {:ends_with => "v_credit_card_last_4"}})
       end
     end
 
     context "created_at" do
       it "is a range node" do
         search = CreditCardVerificationSearch.new
-        search.created_at.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
   end

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -6,6 +6,8 @@ describe Braintree::CreditCardVerification do
       verification = Braintree::CreditCardVerification._new(
         :status => "verified",
         :amount => "12.45",
+        :ani_first_name_response_code => "I",
+        :ani_last_name_response_code => "I",
         :currency_iso_code => "USD",
         :avs_error_response_code => "I",
         :avs_postal_code_response_code => "I",
@@ -17,8 +19,7 @@ describe Braintree::CreditCardVerification do
         :network_response_code => "05",
         :network_response_text => "Do not Honor",
       )
-
-      verification.inspect.should == %(#<Braintree::CreditCardVerification status: "verified", processor_response_code: "2000", processor_response_text: "Do Not Honor", amount: "12.45", currency_iso_code: "USD", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", network_response_code: "05", network_response_text: "Do not Honor", merchant_account_id: "some_id", gateway_rejection_reason: nil, id: nil, credit_card: nil, billing: nil, created_at: nil>)
+      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification amount: "12.45", ani_first_name_response_code: "I", ani_last_name_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", billing: nil, created_at: nil, credit_card: nil, currency_iso_code: "USD", cvv_response_code: "I", gateway_rejection_reason: nil, id: nil, merchant_account_id: "some_id", network_response_code: "05", network_response_text: "Do not Honor", processor_response_code: "2000", processor_response_text: "Do Not Honor", status: "verified">))
     end
 
     it "has a status" do
@@ -30,16 +31,33 @@ describe Braintree::CreditCardVerification do
         :cvv_response_code => "I",
         :processor_response_code => "2000",
         :processor_response_text => "Do Not Honor",
-        :merchant_account_id => "some_id"
+        :merchant_account_id => "some_id",
       )
 
-      verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      expect(verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
     end
   end
 
+  it "accepts ani name reponse codes" do
+    verification = Braintree::CreditCardVerification._new(
+      :ani_first_name_response_code => "M",
+      :ani_last_name_response_code => "M",
+    )
+
+    expect(verification.ani_first_name_response_code).to eq("M")
+    expect(verification.ani_last_name_response_code).to eq("M")
+  end
+
   it "accepts amount as either a String or BigDecimal" do
-    Braintree::CreditCardVerification._new(:amount => "12.34").amount.should == BigDecimal("12.34")
-    Braintree::CreditCardVerification._new(:amount => BigDecimal("12.34")).amount.should == BigDecimal("12.34")
+    expect(Braintree::CreditCardVerification._new(:amount => "12.34").amount).to eq(BigDecimal("12.34"))
+    expect(Braintree::CreditCardVerification._new(:amount => BigDecimal("12.34")).amount).to eq(BigDecimal("12.34"))
+  end
+
+  it "accepts network_transaction_id" do
+    verification = Braintree::CreditCardVerification._new(
+      :network_transaction_id => "123456789012345",
+    )
+    expect(verification.network_transaction_id).to eq "123456789012345"
   end
 
   describe "self.create" do
@@ -81,27 +99,27 @@ describe Braintree::CreditCardVerification do
       first = Braintree::CreditCardVerification._new(:id => 123)
       second = Braintree::CreditCardVerification._new(:id => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false for verifications with different ids" do
       first = Braintree::CreditCardVerification._new(:id => 123)
       second = Braintree::CreditCardVerification._new(:id => 124)
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false when comparing to nil" do
-      Braintree::CreditCardVerification._new({}).should_not == nil
+      expect(Braintree::CreditCardVerification._new({})).not_to eq(nil)
     end
 
     it "returns false when comparing to non-verifications" do
       same_id_different_object = Object.new
       def same_id_different_object.id; 123; end
       verification = Braintree::CreditCardVerification._new(:id => 123)
-      verification.should_not == same_id_different_object
+      expect(verification).not_to eq(same_id_different_object)
     end
   end
 
@@ -110,19 +128,23 @@ describe Braintree::CreditCardVerification do
       verification = Braintree::CreditCardVerification._new(:risk_data => {
         :id => "123",
         :decision => "WOO YOU WON $1000 dollars",
+        :decision_reasons => ["reason"],
         :device_data_captured => true,
-        :fraud_service_provider => "kount"
+        :fraud_service_provider => "paypal_fraud_protection",
+        :transaction_risk_score => "12",
       })
 
-      verification.risk_data.id.should == "123"
-      verification.risk_data.decision.should == "WOO YOU WON $1000 dollars"
-      verification.risk_data.device_data_captured.should == true
-      verification.risk_data.fraud_service_provider.should == "kount"
+      expect(verification.risk_data.id).to eq("123")
+      expect(verification.risk_data.decision).to eq("WOO YOU WON $1000 dollars")
+      expect(verification.risk_data.decision_reasons).to eq(["reason"])
+      expect(verification.risk_data.device_data_captured).to eq(true)
+      expect(verification.risk_data.fraud_service_provider).to eq("paypal_fraud_protection")
+      expect(verification.risk_data.transaction_risk_score).to eq("12")
     end
 
     it "handles a nil risk_data" do
       verification = Braintree::CreditCardVerification._new(:risk_data => nil)
-      verification.risk_data.should be_nil
+      expect(verification.risk_data).to be_nil
     end
   end