braintree 2.10.0 → 4.26.0

data/spec/unit/braintree/paypal_payment_resource_spec.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::PayPalPaymentResource do
+
+  describe "#update" do
+    it "successfully updates a paypal payment request" do
+        paypal_payment_resource_request = {
+                :amount => 55.00,
+                :amount_breakdown => {
+                    :discount => 15_00,
+                    :handling => 0,
+                    :insurance => 5_00,
+                    :item_total => 45_00,
+                    :shipping => 10_00,
+                    :shipping_discount => 0,
+                    :tax_total => 10_00
+                },
+                :currency_iso_code => "USD",
+                :description => "This is a test",
+                :custom_field => "0437",
+                :line_items => [{
+                    :description => "Shoes",
+                    :image_url => "https://example.com/products/23434/pic.png",
+                    :kind => "debit",
+                    :name => "Name #1",
+                    :product_code => "23434",
+                    :quantity => 1_00,
+                    :total_amount => 45_00,
+                    :unit_amount => 45_00,
+                    :unit_tax_amount => 10_00,
+                    :url =>  "https://example.com/products/23434",
+                    }],
+                :order_id => "order-123456789",
+                :payee_email => "bt_buyer_us@paypal.com",
+                :payment_method_nonce => "1234",
+                :shipping => {
+                    :country_name => "United States",
+                    :country_code_alpha2 => "US",
+                    :country_code_alpha3 => "USA",
+                    :country_code_numeric => "484",
+                    :extended_address => "Apt. #1",
+                    :first_name => "John",
+                    :international_phone => {
+                        :country_code => "1",
+                        :national_number => "4081111111",
+                    },
+                    :last_name => "Doe",
+                    :locality => "Chicago",
+                    :postal_code => "60618",
+                    :region => "IL",
+                    :street_address => "123 Division Street",
+                },
+                :shipping_options => [{
+                    :amount => "10.00",
+                    :id => "option1",
+                    :label => "fast",
+                    :selected => true,
+                    :type =>  "SHIPPING"
+                }]
+    }
+
+        unknown_response = {:payment_method_nonce => {}}
+        http_instance = double(:put => unknown_response)
+        allow(Braintree::Http).to receive(:new).and_return(http_instance)
+        result = Braintree::PayPalPaymentResource.update(paypal_payment_resource_request)
+        expect(result).to be_success
+    end
+    it "should match the update signature" do
+        expect(Braintree::PayPalPaymentResourceGateway._update_signature).to match([
+            :amount,
+            {:amount_breakdown => [
+                :discount,
+                :handling,
+                :insurance,
+                :item_total,
+                :shipping,
+                :shipping_discount,
+                :tax_total
+            ]},
+            :currency_iso_code,
+            :custom_field,
+            :description,
+            {:line_items => [
+                :description,
+                :image_url,
+                :kind,
+                :name,
+                :product_code,
+                :quantity,
+                :total_amount,
+                :unit_amount,
+                :unit_tax_amount,
+                :url,
+                ]},
+            :order_id,
+            :payee_email,
+            :payment_method_nonce,
+            {:shipping => [
+                :country_name,
+                :country_code_alpha2,
+                :country_code_alpha3,
+                :country_code_numeric,
+                :extended_address,
+                :first_name,
+                {:international_phone => [
+                    :country_code,
+                    :national_number]},
+                :last_name,
+                :locality,
+                :postal_code,
+                :region,
+                :street_address,
+            ]},
+            {:shipping_options => [
+                :amount,
+                :id,
+                :label,
+                :selected,
+                :type
+            ]},
+        ],
+        )
+    end
+  end
+end

data/spec/unit/braintree/resource_collection_spec.rb

@@ -5,16 +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})
+      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})
+    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

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::RiskData do
+  describe "#initialize" do
+    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
+
+  describe "inspect" do
+    it "prints the attributes" do
+      details = Braintree::RiskData.new(
+        :id => "123",
+        :decision => "YOU WON $1000 DOLLARS",
+        :decision_reasons => ["reason"],
+        :device_data_captured => true,
+        :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"]},
+      )
+      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

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::SHA256Digest do
+  describe "self.hexdigest" do
+    it "returns the sha256 hmac of the input string (test case 6 from RFC 2202)" do
+      key = "secret-key"
+      message = "secret-message"
+      expect(Braintree::SHA256Digest.hexdigest(key, message)).to eq("68e7f2ecab71db67b1aca2a638f5122810315c3013f27c2196cd53e88709eecc")
+    end
+  end
+end

data/spec/unit/braintree/signature_service_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+class FakeDigest
+  def self.hexdigest(key, string)
+    "#{string}_signed_with_#{key}"
+  end
+end
+
+describe Braintree::SignatureService do
+  describe "sign" do
+    it "signs the data with its key" do
+      service = Braintree::SignatureService.new("my_key", FakeDigest)
+
+      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
+      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

@@ -3,17 +3,17 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 module Braintree
   describe SubscriptionSearch do
     context "status" do
-      it "allows Active, Canceled and PastDue" do
+      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,56 +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
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
@@ -121,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.new("12.34")
-      Braintree::Subscription._new(:gateway, default_params.merge(:price => BigDecimal.new("12.34"))).price.should == BigDecimal.new("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
@@ -22,13 +22,40 @@ describe Braintree::Subscription do
     end
   end
 
+  describe "self.find" do
+    it "raises error if passed empty string" do
+      expect do
+        Braintree::Subscription.find("")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises error if passed empty string wth space" do
+      expect do
+        Braintree::Subscription.find(" ")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "raises error if passed nil" do
+      expect do
+        Braintree::Subscription.find(nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not raise an error if subscription id does not respond to strip" do
+      allow(Braintree::Http).to receive(:new).and_return double(:get => {:subscription => default_params})
+      expect do
+        Braintree::Subscription.find(8675309)
+      end.to_not raise_error
+    end
+  end
+
   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
 
@@ -36,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

@@ -2,26 +2,26 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::SuccessfulResult do
   describe "initialize" do
-    it "creates attr readers the values in the hash" do
+    it "sets instance variables from the values in the hash" do
       result = Braintree::SuccessfulResult.new(
-        :foo => "foo_value",
-        :bar => "bar_value"
+        :transaction => "transaction_value",
+        :credit_card => "credit_card_value",
       )
-      result.success?.should == true
-      result.foo.should == "foo_value"
-      result.bar.should == "bar_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(:foo => "foo_value")
-      result.inspect.should == "#<Braintree::SuccessfulResult foo:\"foo_value\">"
+      result = Braintree::SuccessfulResult.new(:transaction => "transaction_value")
+      expect(result.inspect).to eq("#<Braintree::SuccessfulResult transaction:\"transaction_value\">")
     end
   end
 end