braintree 2.4.0 → 2.5.1

data/spec/unit/braintree/customer_spec.rb

@@ -3,12 +3,13 @@ require File.dirname(__FILE__) + "/../spec_helper"
 describe Braintree::Customer do
   describe "inspect" do
     it "includes the id first" do
-      output = Braintree::Customer._new({:first_name => 'Dan', :id => '1234'}).inspect
+      output = Braintree::Customer._new(:gateway, {:first_name => 'Dan', :id => '1234'}).inspect
       output.should include("#<Braintree::Customer id: \"1234\",")
     end
 
     it "includes all customer attributes" do
       customer = Braintree::Customer._new(
+        :gateway,
         :company => "Company",
         :email => "e@mail.com",
         :fax => "483-438-5821",
@@ -50,7 +51,7 @@ describe Braintree::Customer do
 
   describe "self.create_signature" do
     it "should be what we expect" do
-      Braintree::Customer._create_signature.should == [
+      Braintree::CustomerGateway._create_signature.should == [
         :company,
         :email,
         :fax,
@@ -90,7 +91,7 @@ describe Braintree::Customer do
 
   describe "self.update_signature" do
     it "should be what we expect" do
-      Braintree::Customer._update_signature.should == [
+      Braintree::CustomerGateway._update_signature.should == [
         :company,
         :email,
         :fax,
@@ -144,23 +145,23 @@ describe Braintree::Customer do
 
   describe "==" do
     it "returns true when given a customer with the same id" do
-      first = Braintree::Customer._new(:id => 123)
-      second = Braintree::Customer._new(:id => 123)
+      first = Braintree::Customer._new(:gateway, :id => 123)
+      second = Braintree::Customer._new(:gateway, :id => 123)
 
       first.should == second
       second.should == first
     end
 
     it "returns false when given a customer with a different id" do
-      first = Braintree::Customer._new(:id => 123)
-      second = Braintree::Customer._new(:id => 124)
+      first = Braintree::Customer._new(:gateway, :id => 123)
+      second = Braintree::Customer._new(:gateway, :id => 124)
 
       first.should_not == second
       second.should_not == first
     end
 
     it "returns false when not given a customer" do
-      customer = Braintree::Customer._new(:id => 123)
+      customer = Braintree::Customer._new(:gateway, :id => 123)
       customer.should_not == "not a customer"
     end
   end
@@ -168,6 +169,7 @@ describe Braintree::Customer do
   describe "initialize" do
     it "converts payment method hashes into payment method objects" do
       customer = Braintree::Customer._new(
+        :gateway,
         :credit_cards => [
           {:token => "pm1"},
           {:token => "pm2"}

data/spec/unit/braintree/digest_spec.rb

@@ -3,29 +3,20 @@ require File.dirname(__FILE__) + "/../spec_helper"
 describe Braintree::Digest do
   describe "self.hexdigest" do
     it "returns the sha1 hmac of the input string (test case 6 from RFC 2202)" do
-      begin
-        original_key = Braintree::Configuration.private_key
-        Braintree::Configuration.private_key = "\xaa" * 80
-        data = "Test Using Larger Than Block-Size Key - Hash Key First"
-        Braintree::Digest.hexdigest(data).should == "aa4ae5e15272d00e95705637ce8a3b55ed402112"
-      ensure
-        Braintree::Configuration.private_key = original_key
-      end
+      original_key = Braintree::Configuration.private_key
+      private_key = "\xaa" * 80
+      data = "Test Using Larger Than Block-Size Key - Hash Key First"
+      Braintree::Digest.hexdigest(private_key, data).should == "aa4ae5e15272d00e95705637ce8a3b55ed402112"
     end
 
     it "returns the sha1 hmac of the input string (test case 7 from RFC 2202)" do
-      begin
-        original_key = Braintree::Configuration.private_key
-        Braintree::Configuration.private_key = "\xaa" * 80
-        data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
-        Braintree::Digest.hexdigest(data).should == "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
-      ensure
-        Braintree::Configuration.private_key = original_key
-      end
+      private_key = "\xaa" * 80
+      data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
+      Braintree::Digest.hexdigest(private_key, data).should == "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
     end
 
     it "doesn't blow up if message is nil" do
-      expect { Braintree::Digest.hexdigest(nil) }.to_not raise_error
+      expect { Braintree::Digest.hexdigest("key", nil) }.to_not raise_error
     end
   end
 end

data/spec/unit/braintree/error_result_spec.rb

@@ -5,7 +5,13 @@ describe Braintree::ErrorResult do
     it "ignores data other than params, errors, and message" do
       # so that we can add more data into the response in the future without breaking the client lib
       expect do
-        result = Braintree::ErrorResult.new(:params => "params", :errors => {:errors => []}, :extra => "is ignored", :message => "foo bar")
+        result = Braintree::ErrorResult.new(
+          :gateway,
+          :params => "params",
+          :errors => {:errors => []},
+          :extra => "is ignored",
+          :message => "foo bar"
+        )
       end.to_not raise_error
     end
   end
@@ -20,12 +26,13 @@ describe Braintree::ErrorResult do
           }
         }
       }
-      result = Braintree::ErrorResult.new(:params => "params", :errors => errors)
+      result = Braintree::ErrorResult.new(:gateway, :params => "params", :errors => errors)
       result.inspect.should == "#<Braintree::ErrorResult params:{...} errors:<level1:[(code1) message], level1/level2:[(code2) message2]>>"
     end
 
     it "includes the credit_card_verification if there is one" do
       result = Braintree::ErrorResult.new(
+        :gateway,
         :params => "params",
         :errors => {},
         :verification => {},
@@ -36,6 +43,7 @@ describe Braintree::ErrorResult do
 
     it "does not include the credit_card_verification if there isn't one" do
       result = Braintree::ErrorResult.new(
+        :gateway,
         :params => "params",
         :errors => {},
         :verification => nil,
@@ -46,6 +54,7 @@ describe Braintree::ErrorResult do
 
     it "includes the transaction if there is one" do
       result = Braintree::ErrorResult.new(
+        :gateway,
         :params => "params",
         :errors => {},
         :verification => nil,
@@ -56,6 +65,7 @@ describe Braintree::ErrorResult do
 
     it "does not include the transaction if there isn't one" do
       result = Braintree::ErrorResult.new(
+        :gateway,
         :params => "params",
         :errors => {},
         :verification => nil,

data/spec/unit/braintree/http_spec.rb

@@ -15,7 +15,7 @@ END
 [Braintree]   <last-name>Doe</last-name>
 [Braintree] </customer>
 END
-      Braintree::Http._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
     end
 
     it "sanitizes credit card number and cvv" do
@@ -36,7 +36,7 @@ END
 [Braintree]   <cvv>***</cvv>
 [Braintree] </customer>
 END
-      Braintree::Http._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
     end
   end
 end

data/spec/unit/braintree/subscription_search_spec.rb

@@ -10,6 +10,7 @@ module Braintree
           search.status.in(
             Subscription::Status::Active,
             Subscription::Status::Canceled,
+            Subscription::Status::Expired,
             Subscription::Status::PastDue
           )
         end.should_not raise_error
@@ -31,5 +32,81 @@ module Braintree
         search.to_hash.should == {:days_past_due => {:is => "30"}}
       end
     end
+
+    context "merchant_account_id" do
+      it "builds a hash using the in operator" do
+        search = SubscriptionSearch.new
+        search.merchant_account_id.in "ma_id1", "ma_id2"
+
+        search.to_hash.should == {:merchant_account_id => ["ma_id1", "ma_id2"]}
+      end
+    end
+
+    context "plan_id" do
+      it "starts_with" do
+        search = SubscriptionSearch.new
+        search.plan_id.starts_with "plan_"
+
+        search.to_hash.should == {: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"}}
+      end
+
+      it "is" do
+        search = SubscriptionSearch.new
+        search.plan_id.is "p_id"
+
+        search.to_hash.should == {: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"}}
+      end
+
+      it "contains" do
+        search = SubscriptionSearch.new
+        search.plan_id.contains "p_id"
+
+        search.to_hash.should == {: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"]}
+      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)
+      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)
+      end
+    end
+
+    context "id" do
+      it "is" do
+        search = SubscriptionSearch.new
+        search.id.is "s_id"
+
+        search.to_hash.should == {:id => {:is => "s_id"}}
+      end
+    end
   end
 end

data/spec/unit/braintree/subscription_spec.rb

@@ -1,15 +1,23 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
 describe Braintree::Subscription do
+  def default_params
+    {
+      :add_ons => [],
+      :discounts => [],
+      :transactions => []
+    }
+  end
+
   context "price" do
     it "accepts price as either a String or a BigDecimal" do
-      Braintree::Subscription._new(:price => "12.34", :transactions => []).price.should == BigDecimal.new("12.34")
-      Braintree::Subscription._new(:price => BigDecimal.new("12.34"), :transactions => []).price.should == BigDecimal.new("12.34")
+      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")
     end
 
     it "blows up if price is not a string or BigDecimal" do
       expect {
-        Braintree::Subscription._new(:price => 12.34, :transactions => [])
+        Braintree::Subscription._new(:gateway, default_params.merge(:price => 12.34))
       }.to raise_error(/Argument must be a String or BigDecimal/)
     end
   end
@@ -26,19 +34,19 @@ describe Braintree::Subscription do
 
   describe "==" do
     it "returns true for subscriptions with the same id" do
-      subscription1 = Braintree::Subscription._new(:id => "123", :transactions => [])
-      subscription2 = Braintree::Subscription._new(:id => "123", :transactions => [])
+      subscription1 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
+      subscription2 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
       subscription1.should == subscription2
     end
 
     it "returns false for subscriptions with different ids" do
-      subscription1 = Braintree::Subscription._new(:id => "123", :transactions => [])
-      subscription2 = Braintree::Subscription._new(:id => "not_123", :transactions => [])
+      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
     end
 
     it "returns false if not comparing to a subscription" do
-      subscription = Braintree::Subscription._new(:id => "123", :transactions => [])
+      subscription = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
       subscription.should_not == "not a subscription"
     end
   end

data/spec/unit/braintree/transaction_spec.rb

@@ -19,7 +19,7 @@ describe Braintree::Transaction do
 
   describe "self.create_transaction_url" do
     it "returns the url" do
-      port = Braintree::Configuration.port
+      port = Braintree::Configuration.instantiate.port
       Braintree::Transaction.create_transaction_url.should == "http://localhost:#{port}/merchants/integration_merchant_id/transactions/all/create_via_transparent_redirect_request"
     end
   end
@@ -35,6 +35,7 @@ describe Braintree::Transaction do
   describe "initialize" do
     it "sets up customer attributes in customer_details" do
       transaction = Braintree::Transaction._new(
+        :gateway,
         :customer => {
           :id => "123",
           :first_name => "Adam",
@@ -58,6 +59,7 @@ describe Braintree::Transaction do
 
     it "sets up credit card attributes in credit_card_details" do
       transaction = Braintree::Transaction._new(
+        :gateway,
         :credit_card => {
           :token => "mzg2",
           :bin => "411111",
@@ -80,6 +82,7 @@ describe Braintree::Transaction do
     it "sets up history attributes in status_history" do
       time = Time.utc(2010,1,14)
       transaction = Braintree::Transaction._new(
+        :gateway,
         :status_history => [
           { :timestamp => time, :amount => "12.00", :transaction_source => "API",
             :user => "larry", :status => Braintree::Transaction::Status::Authorized },
@@ -97,18 +100,19 @@ describe Braintree::Transaction do
 
     it "handles receiving custom as an empty string" do
       transaction = Braintree::Transaction._new(
+        :gateway,
         :custom => "\n    "
       )
     end
 
     it "accepts amount as either a String or a BigDecimal" do
-      Braintree::Transaction._new(:amount => "12.34").amount.should == BigDecimal.new("12.34")
-      Braintree::Transaction._new(:amount => BigDecimal.new("12.34")).amount.should == BigDecimal.new("12.34")
+      Braintree::Transaction._new(:gateway, :amount => "12.34").amount.should == BigDecimal.new("12.34")
+      Braintree::Transaction._new(:gateway, :amount => BigDecimal.new("12.34")).amount.should == BigDecimal.new("12.34")
     end
 
     it "blows up if amount is not a string or BigDecimal" do
       expect {
-        Braintree::Transaction._new(:amount => 12.34)
+        Braintree::Transaction._new(:gateway, :amount => 12.34)
       }.to raise_error(/Argument must be a String or BigDecimal/)
     end
   end
@@ -116,6 +120,7 @@ describe Braintree::Transaction do
   describe "inspect" do
     it "includes the id, type, amount, and status first" do
       transaction = Braintree::Transaction._new(
+        :gateway,
         :id => "1234",
         :type => "sale",
         :amount => "100.00",
@@ -128,29 +133,29 @@ describe Braintree::Transaction do
 
   describe "==" do
     it "returns true for transactions with the same id" do
-      first = Braintree::Transaction._new(:id => 123)
-      second = Braintree::Transaction._new(:id => 123)
+      first = Braintree::Transaction._new(:gateway, :id => 123)
+      second = Braintree::Transaction._new(:gateway, :id => 123)
 
       first.should == second
       second.should == first
     end
 
     it "returns false for transactions with different ids" do
-      first = Braintree::Transaction._new(:id => 123)
-      second = Braintree::Transaction._new(:id => 124)
+      first = Braintree::Transaction._new(:gateway, :id => 123)
+      second = Braintree::Transaction._new(:gateway, :id => 124)
 
       first.should_not == second
       second.should_not == first
     end
 
     it "returns false when comparing to nil" do
-      Braintree::Transaction._new({}).should_not == nil
+      Braintree::Transaction._new(:gateway, {}).should_not == nil
     end
 
     it "returns false when comparing to non-transactions" do
       same_id_different_object = Object.new
       def same_id_different_object.id; 123; end
-      transaction = Braintree::Transaction._new(:id => 123)
+      transaction = Braintree::Transaction._new(:gateway, :id => 123)
       transaction.should_not == same_id_different_object
     end
   end
@@ -165,12 +170,12 @@ describe Braintree::Transaction do
 
   describe "refunded?" do
     it "is true if the transaciton has been refunded" do
-      transaction = Braintree::Transaction._new(:refund_id => "123")
+      transaction = Braintree::Transaction._new(:gateway, :refund_id => "123")
       transaction.refunded?.should == true
     end
 
     it "is false if the transaciton has not been refunded" do
-      transaction = Braintree::Transaction._new(:refund_id => nil)
+      transaction = Braintree::Transaction._new(:gateway, :refund_id => nil)
       transaction.refunded?.should == false
     end
   end

data/spec/unit/braintree/transparent_redirect_spec.rb

@@ -24,10 +24,10 @@ describe Braintree::TransparentRedirect do
   describe "self.parse_and_validate_query_string" do
     it "returns the parsed query string params if the hash is valid" do
       query_string_without_hash = "one=1&two=2&http_status=200"
-      hash = Braintree::Digest.hexdigest(query_string_without_hash)
+      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, query_string_without_hash)
 
       query_string_with_hash = "#{query_string_without_hash}&hash=#{hash}"
-      result = Braintree::TransparentRedirect.parse_and_validate_query_string query_string_with_hash
+      result = Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string query_string_with_hash
       result.should == {:one => "1", :two => "2", :http_status => "200", :hash => hash}
     end
 
@@ -37,49 +37,49 @@ describe Braintree::TransparentRedirect do
 
       query_string_with_hash = "#{query_string_without_hash}&hash=#{hash}"
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string query_string_with_hash
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string query_string_with_hash
       end.to raise_error(Braintree::ForgedQueryString)
     end
 
     it "raises Braintree::ForgedQueryString if hash is missing from the query string" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string "http_status=200&query_string=without_a_hash"
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string "http_status=200&query_string=without_a_hash"
       end.to raise_error(Braintree::ForgedQueryString)
     end
 
     it "raises an AuthenticationError if authentication fails" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=401")
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=401")
       end.to raise_error(Braintree::AuthenticationError)
     end
 
     it "raises an AuthorizationError if authorization fails" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=403")
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=403")
       end.to raise_error(Braintree::AuthorizationError)
     end
 
     it "raises an UnexpectedError if http_status is not in query string" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("no_http_status=x")
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("no_http_status=x")
       end.to raise_error(Braintree::UnexpectedError, "expected query string to have an http_status param")
     end
 
     it "raises a ServerError if the server 500's" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=500")
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=500")
       end.to raise_error(Braintree::ServerError)
     end
 
     it "raises a DownForMaintenanceError if the server is down for maintenance" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=503")
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=503")
       end.to raise_error(Braintree::DownForMaintenanceError)
     end
 
     it "raises an UnexpectedError if some other code is returned" do
       expect do
-        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=600")
+        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=600")
       end.to raise_error(Braintree::UnexpectedError, "Unexpected HTTP_RESPONSE 600")
     end
   end
@@ -147,13 +147,13 @@ describe Braintree::TransparentRedirect do
   describe "self._data" do
     it "raises an exception if :redirect_url isn't given" do
       expect do
-        Braintree::TransparentRedirect._data(:redirect_url => nil)
+        Braintree::TransparentRedirect.create_customer_data(:redirect_url => nil)
       end.to raise_error(ArgumentError, "expected params to contain :redirect_url")
     end
   end
 
   def add_hash_to_query_string(query_string_without_hash)
-    hash = Braintree::TransparentRedirect._hash(query_string_without_hash)
+    hash = Braintree::Configuration.gateway.transparent_redirect._hash(query_string_without_hash)
     query_string_without_hash + "&hash=" + hash
   end
 end