braintree 2.98.0 → 4.23.0

data/spec/unit/braintree/resource_collection_spec.rb

@@ -5,28 +5,57 @@ describe "Braintree::ResourceCollection" do
     it "iterates over the elements, yielding to the block in pages" do
       values = %w(a b c d e)
       collection = Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2}) do |ids|
-        ids.map {|id| values[id] }
+        ids.map { |id| values[id] }
       end
 
       count = 0
       collection.each_with_index do |item, index|
-        item.should == values[index]
+        expect(item).to eq(values[index])
         count += 1
       end
 
-      count.should == 5
+      expect(count).to eq(5)
+    end
+  end
+
+  describe "#first" do
+    it "returns nil with no results" do
+      values = %w(a b c d e)
+      collection = Braintree::ResourceCollection.new(:search_results => {:ids => [], :page_size => 2}) do |ids|
+        ids.map { |id| values[id] }
+      end
+
+      expect(collection.first).to eq(nil)
+    end
+
+    context "with results" do
+      let(:collection) do
+        values = %w(a b c d e)
+
+        Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2}) do |ids|
+          ids.map { |id| values[id] }
+        end
+      end
+
+      it "returns the first occourence" do
+        expect(collection.first).to eq("a")
+      end
+
+      it "returns the first N occourences" do
+        expect(collection.first(4)).to eq(["a","b","c","d"])
+      end
     end
   end
 
   describe "#ids" do
     it "returns a list of the resource collection ids" do
       collection = Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2})
-      collection.ids.should == [0,1,2,3,4]
+      expect(collection.ids).to eq([0,1,2,3,4])
     end
   end
 
   it "returns an empty array when the collection is empty" do
     collection = Braintree::ResourceCollection.new(:search_results => {:page_size => 2})
-    collection.ids.should == []
+    expect(collection.ids).to eq([])
   end
 end

data/spec/unit/braintree/risk_data/liability_shift.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::Transaction::LiabilityShift do
+  describe "#initialize" do
+    it "sets responsible party and conditions" do
+      liability_shift = Braintree::Transaction::LiabilityShift.new(
+        :responsible_party => "paypal",
+        :conditions => ["unauthorized","item_not_received"],
+      )
+
+      expect(liability_shift.responsible_party).to eql "paypal"
+      expect(liability_shift.conditions.first).to eql "unauthorized"
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      details = Braintree::Transaction::LiabilityShift.new(
+        :responsible_party => "paypal",
+        :conditions => ["unauthorized","item_not_received"],
+      )
+
+      expect(details.inspect).to eql %(#<LiabilityShift responsible_party: "paypal", conditions: ["unauthorized", "item_not_received"]>)
+    end
+  end
+end

data/spec/unit/braintree/risk_data_spec.rb

@@ -2,12 +2,31 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::RiskData do
   describe "#initialize" do
-    it "sets id, decision and device_data_captured" do
-      risk_data = Braintree::RiskData.new(:id => "123", :decision => "YOU WON $1000 DOLLARS", :device_data_captured => true, :fraud_service_provider => "kount")
-      risk_data.id.should == "123"
-      risk_data.decision.should == "YOU WON $1000 DOLLARS"
-      risk_data.device_data_captured.should be_truthy
-      risk_data.fraud_service_provider.should == "kount"
+    it "sets id, decision, device_data_captured, decision_reasons and transaction_risk_score" do
+      risk_data = Braintree::RiskData.new(:id => "123", :decision => "YOU WON $1000 DOLLARS", :device_data_captured => true, :fraud_service_provider => "fraud_protection", :decision_reasons => ["reason"], :transaction_risk_score => "12")
+      expect(risk_data.id).to eql "123"
+      expect(risk_data.decision).to eql "YOU WON $1000 DOLLARS"
+      expect(risk_data.device_data_captured).to be_truthy
+      expect(risk_data.fraud_service_provider).to eql "fraud_protection"
+      expect(risk_data.decision_reasons).to eql ["reason"]
+      expect(risk_data.transaction_risk_score).to eql "12"
+      expect(risk_data.liability_shift).to be_nil
+    end
+
+    it "sets liability shift info" do
+      risk_data = Braintree::RiskData.new(
+        :id => "123",
+        :decision => "YOU WON $1000 DOLLARS",
+        :device_data_captured => true,
+        :fraud_service_provider => "fraud_protection",
+        :decision_reasons => ["reason"],
+        :transaction_risk_score => "12",
+        :liability_shift => {
+          :responsible_party => "paypal",
+          :conditions => ["unauthorized"]},
+      )
+      expect(risk_data.liability_shift.responsible_party).to eql "paypal"
+      expect(risk_data.liability_shift.conditions).to eql ["unauthorized"]
     end
   end
 
@@ -16,10 +35,21 @@ describe Braintree::RiskData do
       details = Braintree::RiskData.new(
         :id => "123",
         :decision => "YOU WON $1000 DOLLARS",
+        :decision_reasons => ["reason"],
         :device_data_captured => true,
-        :fraud_service_provider => "kount",
+        :fraud_service_provider => "fraud_protection",
+        :transaction_risk_score => "12",
+      )
+      expect(details.inspect).to eql %(#<RiskData id: "123", decision: "YOU WON $1000 DOLLARS", decision_reasons: ["reason"], device_data_captured: true, fraud_service_provider: "fraud_protection", liability_shift: nil, transaction_risk_score: "12">)
+    end
+
+    it "prints liability shift attributes, too" do
+      details = Braintree::RiskData.new(
+        :liability_shift => {
+          :responsible_party => "paypal",
+          :conditions => ["unauthorized"]},
       )
-      details.inspect.should == %(#<RiskData id: "123", decision: "YOU WON $1000 DOLLARS", device_data_captured: true, fraud_service_provider: "kount">)
+      expect(details.inspect).to eql %(#<RiskData id: nil, decision: nil, decision_reasons: nil, device_data_captured: nil, fraud_service_provider: nil, liability_shift: #<LiabilityShift responsible_party: "paypal", conditions: ["unauthorized"]>, transaction_risk_score: nil>)
     end
   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
+      expect(subject.inspect).to eq(%(#<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

data/spec/unit/braintree/sepa_debit_account_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::SepaDirectDebitAccount do
+  describe "self.new" do
+    subject do
+      -> { described_class.new }
+    end
+
+    it "is protected" do
+      is_expected.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    let(:params) do
+      {
+        bank_reference_token: "a-reference-token",
+        created_at: Time.now,
+        customer_global_id: "a-customer-global-id",
+        customer_id: "a-customer-id",
+        default: true,
+        global_id: "a-global-id",
+        image_url: "a-image-url",
+        last_4: "4321",
+        mandate_type: "ONE_OFF",
+        merchant_or_partner_customer_id: "a-mp-customer-id",
+        subscriptions: [{price: "10.00"}],
+        token: "a-token",
+        updated_at: Time.now,
+        view_mandate_url: "a-view-mandate-url",
+      }
+    end
+
+    subject do
+      described_class._new(:gateway, params)
+    end
+
+    it "initializes the object with the appropriate attributes set" do
+      is_expected.to have_attributes(**params)
+    end
+  end
+
+  describe "self.find" do
+    let(:token) { "token" }
+
+    subject do
+      described_class.find(token)
+    end
+
+    it "calls gateway find" do
+      expect_any_instance_of(Braintree::SepaDirectDebitAccountGateway).to receive(:find).with(token)
+      subject
+    end
+  end
+
+  describe "self.delete" do
+    let(:token) { "token" }
+
+    subject do
+      described_class.delete(token)
+    end
+
+    it "calls gateway delete" do
+      expect_any_instance_of(Braintree::SepaDirectDebitAccountGateway).to receive(:delete).with(token)
+      subject
+    end
+  end
+
+  describe "default?" do
+    subject do
+      described_class._new(:gateway, :default => default).default?
+    end
+
+    context "when sepa debit account is the default payment method for the customer" do
+      let(:default) { true }
+
+      it { is_expected.to be true }
+    end
+
+    context "when sepa debit account is not the default payment method for the customer" do
+      let(:default) { false }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/unit/braintree/sha256_digest_spec.rb

@@ -5,7 +5,7 @@ describe Braintree::SHA256Digest do
     it "returns the sha256 hmac of the input string (test case 6 from RFC 2202)" do
       key = "secret-key"
       message = "secret-message"
-      Braintree::SHA256Digest.hexdigest(key, message).should == "68e7f2ecab71db67b1aca2a638f5122810315c3013f27c2196cd53e88709eecc"
+      expect(Braintree::SHA256Digest.hexdigest(key, message)).to eq("68e7f2ecab71db67b1aca2a638f5122810315c3013f27c2196cd53e88709eecc")
     end
   end
 end

data/spec/unit/braintree/signature_service_spec.rb

@@ -11,13 +11,13 @@ describe Braintree::SignatureService do
     it "signs the data with its key" do
       service = Braintree::SignatureService.new("my_key", FakeDigest)
 
-      service.sign(:foo => "foo bar").should == "foo=foo+bar_signed_with_my_key|foo=foo+bar"
+      expect(service.sign(:foo => "foo bar")).to eq("foo=foo+bar_signed_with_my_key|foo=foo+bar")
     end
   end
 
   describe "hash" do
     it "hashes the string with its key" do
-      Braintree::SignatureService.new("my_key", FakeDigest).hash("foo").should == "foo_signed_with_my_key"
+      expect(Braintree::SignatureService.new("my_key", FakeDigest).hash("foo")).to eq("foo_signed_with_my_key")
     end
   end
 end

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
+            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

@@ -5,23 +5,23 @@ describe Braintree::SuccessfulResult do
     it "sets instance variables from the values in the hash" do
       result = Braintree::SuccessfulResult.new(
         :transaction => "transaction_value",
-        :credit_card => "credit_card_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

@@ -3,47 +3,67 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 describe Braintree::ThreeDSecureInfo do
   let(:three_d_secure_info) {
     Braintree::ThreeDSecureInfo.new(
+      :acs_transaction_id => "acs_id",
+      :cavv => "cavvvalue",
+      :ds_transaction_id => "dstrxid",
+      :eci_flag => "06",
       :enrolled => "Y",
-      :liability_shifted => true,
       :liability_shift_possible => true,
-      :cavv => "cavvvalue",
-      :xid => "xidvalue",
+      :liability_shifted => true,
+      :pares_status => "Y",
       :status => "authenticate_successful",
-      :eci_flag => "06",
+      :three_d_secure_authentication_id => "auth_id",
+      :three_d_secure_transaction_id => "trans_id",
       :three_d_secure_version => "1.0.2",
-      :ds_transaction_id => "dstrxid",
+      :xid => "xidvalue",
+      :authentication => {
+        :trans_status => "authstatus",
+        :trans_status_reason => "authstatusreason"
+      },
+      :lookup => {
+        :trans_status => "lookupstatus",
+        :trans_status_reason => "lookupstatusreason"
+      },
     )
   }
 
   describe "#initialize" do
     it "sets attributes" do
-      three_d_secure_info.enrolled.should == "Y"
-      three_d_secure_info.status.should == "authenticate_successful"
-      three_d_secure_info.liability_shifted.should == true
-      three_d_secure_info.liability_shift_possible.should == true
-      three_d_secure_info.cavv.should == "cavvvalue"
-      three_d_secure_info.xid.should == "xidvalue"
-      three_d_secure_info.eci_flag.should == "06"
-      three_d_secure_info.three_d_secure_version.should == "1.0.2"
-      three_d_secure_info.ds_transaction_id.should == "dstrxid"
+      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 enrolled: "Y", liability_shifted: true, liability_shift_possible: true, status: "authenticate_successful", cavv: "cavvvalue", xid: "xidvalue", eci_flag: "06", three_d_secure_version: "1.0.2", ds_transaction_id: "dstrxid">)
+      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