braintree 2.10.0 → 4.26.0

data/spec/unit/braintree/credit_card_spec.rb

@@ -4,14 +4,14 @@ 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,
@@ -20,7 +20,12 @@ describe Braintree::CreditCard do
         :expiration_year,
         :number,
         :token,
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
+        :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
+        :device_data,
+        :payment_method_nonce,
+        {: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,
@@ -29,20 +34,32 @@ 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,
@@ -51,7 +68,12 @@ describe Braintree::CreditCard do
         :expiration_year,
         :number,
         :token,
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
+        :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
+        :device_data,
+        :payment_method_nonce,
+        {: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,
@@ -60,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
-      port = Braintree::Configuration.instantiate.port
-      Braintree::CreditCard.create_credit_card_url.should == "http://localhost:#{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
 
@@ -91,38 +110,65 @@ 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
+
+  describe "self.find" do
+    it "raises error if passed empty string" do
+      expect do
+        Braintree::CreditCard.find("")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises error if passed invalid string" do
+      expect do
+        Braintree::CreditCard.find("\t")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises error if passed nil" do
+      expect do
+        Braintree::CreditCard.find(nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not raise an error if address_id does not respond to strip" do
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
+      expect do
+        Braintree::CreditCard.find(8675309)
+      end.to_not raise_error
     end
   end
 
   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
@@ -137,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
 
@@ -159,16 +207,38 @@ describe Braintree::CreditCard do
       credit_card = Braintree::CreditCard._new(
         :gateway,
         :bin => "510510",
-        :last_4 => "5100"
+        :last_4 => "5100",
       )
-      credit_card.masked_number.should == "510510******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,
+      )
+      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
@@ -180,4 +250,25 @@ describe Braintree::CreditCard do
       end.to raise_error(NoMethodError, /protected method .new/)
     end
   end
+
+  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}
+        credit_card = Braintree::CreditCard._new(Braintree::Configuration.gateway, {:verifications => [verification1, verification2]})
+        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, {})
+        expect(credit_card.verification).to be_nil
+      end
+    end
+  end
+
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  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

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Braintree
+  describe CreditCardVerificationSearch do
+
+    context "card_type" do
+      it "allows All card types" do
+        search = CreditCardVerificationSearch.new
+
+        expect do
+          search.credit_card_card_type.in(
+            *Braintree::CreditCard::CardType::All,
+          )
+        end.not_to raise_error
+      end
+    end
+
+    context "id" do
+      it "is" do
+        search = CreditCardVerificationSearch.new
+        search.id.is "v_id"
+
+        expect(search.to_hash).to eq({:id => {:is => "v_id"}})
+      end
+    end
+
+    context "ids" do
+      it "correctly builds a hash with ids" do
+        search = CreditCardVerificationSearch.new
+        search.ids.in("id1","id2")
+
+        expect(search.to_hash).to eq({:ids => ["id1", "id2"]})
+      end
+    end
+
+    context "credit_card_cardholder_name" do
+      it "is" do
+        search = CreditCardVerificationSearch.new
+        search.credit_card_cardholder_name.is "v_cardholder_name"
+
+        expect(search.to_hash).to eq({:credit_card_cardholder_name => {:is => "v_cardholder_name"}})
+      end
+    end
+
+    context "credit_card_expiration_date" do
+      it "is_not" do
+        search = CreditCardVerificationSearch.new
+        search.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
+
+    context "credit_card_number" do
+      it "starts with" do
+        search = CreditCardVerificationSearch.new
+
+        search.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
+        search = CreditCardVerificationSearch.new
+
+        search.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
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
+      end
+    end
+  end
+end

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -5,16 +5,21 @@ describe Braintree::CreditCardVerification do
     it "is better than the default inspect" 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",
         :avs_street_address_response_code => "I",
         :cvv_response_code => "I",
         :processor_response_code => "2000",
         :processor_response_text => "Do Not Honor",
-        :merchant_account_id => "some_id"
+        :merchant_account_id => "some_id",
+        :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", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", merchant_account_id: "some_id", gateway_rejection_reason: 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
@@ -26,11 +31,132 @@ 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
-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
+    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
+    it "rejects invalid parameters" do
+      expect do
+        Braintree::CreditCardVerification.create(:invalid_key => 4, :credit_card => {:number => "number"})
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+
+    it "rejects parameters that are only valid for 'payment methods create'" do
+      expect do
+        Braintree::CreditCardVerification.create(:credit_card => {:options => {:verify_card => true}})
+      end.to raise_error(ArgumentError, "invalid keys: credit_card[options][verify_card]")
+    end
+  end
+
+  describe "self.find" do
+    it "raises error if passed empty string" do
+      expect do
+        Braintree::CreditCardVerification.find("")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises error if passed empty string wth space" do
+      expect do
+        Braintree::CreditCardVerification.find(" ")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises error if passed nil" do
+      expect do
+        Braintree::CreditCardVerification.find(nil)
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "==" do
+    it "returns true for verifications with the same id" do
+      first = Braintree::CreditCardVerification._new(:id => 123)
+      second = Braintree::CreditCardVerification._new(:id => 123)
+
+      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)
+
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
+    end
+
+    it "returns false when comparing to nil" do
+      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)
+      expect(verification).not_to eq(same_id_different_object)
+    end
+  end
+
+  describe "risk_data" do
+    it "initializes a RiskData object" 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 => "paypal_fraud_protection",
+        :transaction_risk_score => "12",
+      })
+
+      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)
+      expect(verification.risk_data).to be_nil
+    end
+  end
+
+  describe "network responses" do
+    it "accepts network_response_code and network_response_text" do
+      verification = Braintree::CreditCardVerification._new(
+        :network_response_code => "00",
+        :network_response_text => "Successful approval/completion or V.I.P. PIN verification is successful",
+      )
+
+      expect(verification.network_response_code).to eq("00")
+      expect(verification.network_response_text).to eq("Successful approval/completion or V.I.P. PIN verification is successful")
+    end
+  end
+end