braintree 1.1.3 → 1.2.0

data/spec/integration/braintree/credit_card_spec.rb

@@ -207,7 +207,8 @@ describe Braintree::CreditCard do
           :customer_id => customer.id
         }
       }
-      query_string_response = create_credit_card_via_tr(params, tr_data_params)
+      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::CreditCard.create_credit_card_url, tr_data, params)
       result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
       result.success?.should == true
       credit_card = result.credit_card
@@ -234,7 +235,8 @@ describe Braintree::CreditCard do
           :customer_id => customer.id
         }
       }
-      query_string_response = create_credit_card_via_tr(params, tr_data_params)
+      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::CreditCard.create_credit_card_url, tr_data, params)
       result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
       result.success?.should == false
       result.params[:customer_id] == customer.id
@@ -439,7 +441,8 @@ describe Braintree::CreditCard do
           :token => new_token
         }
       }
-      query_string_response = update_credit_card_via_tr(params, tr_data_params)
+      tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::CreditCard.update_credit_card_url, tr_data, params)
       result = Braintree::CreditCard.update_from_transparent_redirect(query_string_response)
       result.success?.should == true
       credit_card = result.credit_card
@@ -578,6 +581,27 @@ describe Braintree::CreditCard do
       credit_card.expiration_date.should == "05/2012"
     end
 
+    it "returns associated subscriptions with the credit card" do
+      customer = Braintree::Customer.create.customer
+      credit_card = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2012"
+      ).credit_card
+
+      subscription = Braintree::Subscription.create(
+        :payment_method_token => credit_card.token,
+        :plan_id => "integration_trialless_plan",
+        :price => "1.00"
+      ).subscription
+
+      found_card = Braintree::CreditCard.find(credit_card.token)
+      found_card.subscriptions.first.id.should == subscription.id
+      found_card.subscriptions.first.plan_id.should == "integration_trialless_plan"
+      found_card.subscriptions.first.payment_method_token.should == credit_card.token
+      found_card.subscriptions.first.price.should == BigDecimal.new("1.00")
+    end
+
     it "raises a NotFoundError exception if payment method cannot be found" do
       expect do
         Braintree::CreditCard.find("invalid-token")
@@ -827,36 +851,4 @@ describe Braintree::CreditCard do
       end.to raise_error(Braintree::ValidationsFailed)
     end
   end
-
-  def create_credit_card_via_tr(regular_params, tr_params = {})
-    response = nil
-    Net::HTTP.start("localhost", Braintree::Configuration.port) do |http|
-      request = Net::HTTP::Post.new("/" + Braintree::CreditCard.create_credit_card_url.split("/", 4)[3])
-      request.add_field "Content-Type", "application/x-www-form-urlencoded"
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_params))
-      request.body = Braintree::Util.hash_to_query_string({:tr_data => tr_data}.merge(regular_params))
-      response = http.request(request)
-    end
-    if response.code.to_i == 303
-      query_string = response["Location"].split("?", 2).last
-    else
-      raise "did not receive a valid tr response: #{response.body[0,1000].inspect}"
-    end
-  end
-
-  def update_credit_card_via_tr(regular_params, tr_params = {})
-    response = nil
-    Net::HTTP.start("localhost", Braintree::Configuration.port) do |http|
-      request = Net::HTTP::Post.new("/" + Braintree::CreditCard.update_credit_card_url.split("/", 4)[3])
-      request.add_field "Content-Type", "application/x-www-form-urlencoded"
-      tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_params))
-      request.body = Braintree::Util.hash_to_query_string({:tr_data => tr_data}.merge(regular_params))
-      response = http.request(request)
-    end
-    if response.code.to_i == 303
-      query_string = response["Location"].split("?", 2).last
-    else
-      raise "did not receive a valid tr response: #{response.body[0,1000].inspect}"
-    end
-  end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -416,8 +416,11 @@ describe Braintree::Customer do
           :website => "www.johndoe.com"
         }
       }
-      query_string_response = create_customer_via_tr(params)
+
+      tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Customer.create_customer_url, tr_data, params)
       result = Braintree::Customer.create_from_transparent_redirect(query_string_response)
+
       result.success?.should == true
       customer = result.customer
       customer.first_name.should == "John"
@@ -443,8 +446,11 @@ describe Braintree::Customer do
           :website => "www.johndoe.com"
         }
       }
-      query_string_response = create_customer_via_tr({}, tr_data_params)
+
+      tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Customer.create_customer_url, tr_data, {})
       result = Braintree::Customer.create_from_transparent_redirect(query_string_response)
+
       result.success?.should == true
       customer = result.customer
       customer.id.should == customer_id
@@ -489,6 +495,27 @@ describe Braintree::Customer do
       customer.last_name.should == "Cool"
     end
 
+    it "returns associated subscriptions" do
+      customer = Braintree::Customer.create.customer
+      credit_card = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2012"
+      ).credit_card
+
+      subscription = Braintree::Subscription.create(
+        :payment_method_token => credit_card.token,
+        :plan_id => "integration_trialless_plan",
+        :price => "1.00"
+      ).subscription
+
+      found_customer = Braintree::Customer.find(customer.id)
+      found_customer.credit_cards.first.subscriptions.first.id.should == subscription.id
+      found_customer.credit_cards.first.subscriptions.first.plan_id.should == "integration_trialless_plan"
+      found_customer.credit_cards.first.subscriptions.first.payment_method_token.should == credit_card.token
+      found_customer.credit_cards.first.subscriptions.first.price.should == BigDecimal.new("1.00")
+    end
+
     it "works for a blank customer" do
       created_customer = Braintree::Customer.create!
       found_customer = Braintree::Customer.find(created_customer.id)
@@ -651,8 +678,11 @@ describe Braintree::Customer do
       tr_data_params = {
         :customer_id => original_customer.id
       }
-      query_string_response = update_customer_via_tr(params, tr_data_params)
+
+      tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Customer.update_customer_url, tr_data, params)
       result = Braintree::Customer.update_from_transparent_redirect(query_string_response)
+
       result.success?.should == true
       customer = result.customer
       customer.id.should == original_customer.id
@@ -689,8 +719,11 @@ describe Braintree::Customer do
           :website => "new.website.com"
         }
       }
-      query_string_response = update_customer_via_tr({}, tr_data_params)
+
+      tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Customer.update_customer_url, tr_data, {})
       result = Braintree::Customer.update_from_transparent_redirect(query_string_response)
+
       result.success?.should == true
       customer = result.customer
       customer.id.should == new_customer_id
@@ -703,36 +736,4 @@ describe Braintree::Customer do
       customer.website.should == "new.website.com"
     end
   end
-
-  def create_customer_via_tr(regular_params, tr_data_params = {})
-    response = nil
-    Net::HTTP.start(Braintree::Configuration.server, Braintree::Configuration.port) do |http|
-      request = Net::HTTP::Post.new("/" + Braintree::Customer.create_customer_url.split("/", 4)[3])
-      request.add_field "Content-Type", "application/x-www-form-urlencoded"
-      params = {
-        :tr_data => Braintree::TransparentRedirect.create_customer_data(
-          {:redirect_url => "http://testing.com"}.merge(tr_data_params)
-        )
-      }.merge(regular_params)
-      request.body = Braintree::Util.hash_to_query_string(params)
-      response = http.request(request)
-    end
-    query_string = response["Location"].split("?", 2).last
-    query_string
-  end
-
-  def update_customer_via_tr(regular_params, tr_data_params = {})
-    raise "need a customer_id (of the customer to update) in tr_data_params" unless tr_data_params[:customer_id]
-    response = nil
-    Net::HTTP.start(Braintree::Configuration.server, Braintree::Configuration.port) do |http|
-      request = Net::HTTP::Post.new("/" + Braintree::Customer.update_customer_url.split("/", 4)[3])
-      request.add_field "Content-Type", "application/x-www-form-urlencoded"
-      tr_data = Braintree::TransparentRedirect.update_customer_data(
-        {:redirect_url => "http://testing.com"}.merge(tr_data_params)
-      )
-      request.body = Braintree::Util.hash_to_query_string({ :tr_data => tr_data }.merge(regular_params))
-      response = http.request(request)
-    end
-    query_string = response["Location"].split("?", 2).last
-  end
 end

data/spec/integration/braintree/http_spec.rb

@@ -67,6 +67,23 @@ describe Braintree::Http do
       end
     end
 
+    describe "user_agent" do
+      after do
+        Braintree::Configuration.custom_user_agent = nil
+      end
+
+      it "sets the User-Agent header using the default user agent" do
+        response = Braintree::Http.get("/test/headers")
+        response[:headers][:HTTP_USER_AGENT].should == "Braintree Ruby Gem #{Braintree::Version::String}"
+      end
+
+      it "sets the User-Agent header using a customer user agent" do
+        Braintree::Configuration.custom_user_agent = "ActiveMerchant 1.2.3"
+        response = Braintree::Http.get("/test/headers")
+        response[:headers][:HTTP_USER_AGENT].should == "Braintree Ruby Gem #{Braintree::Version::String} (ActiveMerchant 1.2.3)"
+      end
+    end
+
     describe "ssl verification" do
       it "rejects when the certificate isn't verified by our certificate authority (self-signed)" do
         begin

data/spec/integration/braintree/subscription_spec.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
 describe Braintree::Subscription do
-
   TrialPlan = {
     :description => "Plan for integration tests -- with trial",
     :id => "integration_trial_plan",
@@ -18,6 +17,9 @@ describe Braintree::Subscription do
     :trial_period => false
   }
 
+  DefaultMerchantAccountId = "sandbox_credit_card"
+  NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
+
   before(:each) do
     @credit_card = Braintree::Customer.create!(
       :credit_card => {
@@ -62,6 +64,29 @@ describe Braintree::Subscription do
       result.subscription.id.should == new_id
     end
 
+    context "merchant_account_id" do
+      it "defaults to the default merchant account if no merchant_account_id is provided" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => TriallessPlan[:id]
+        )
+
+        result.success?.should == true
+        result.subscription.merchant_account_id.should == DefaultMerchantAccountId
+      end
+
+      it "allows setting the merchant_account_id" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => TriallessPlan[:id],
+          :merchant_account_id => NonDefaultMerchantAccountId
+        )
+
+        result.success?.should == true
+        result.subscription.merchant_account_id.should == NonDefaultMerchantAccountId
+      end
+    end
+
     context "trial period" do
       context "defaults to the plan's trial period settings" do
         it "with no trial" do
@@ -190,7 +215,7 @@ describe Braintree::Subscription do
           :trial_duration => nil
         )
         result.success?.should == false
-        result.errors.for(:subscription)[0].message.should == "Trial Duration is required."
+        result.errors.for(:subscription).on(:trial_duration)[0].message.should == "Trial Duration is required."
       end
 
       it "trial duration unit required" do
@@ -235,6 +260,17 @@ describe Braintree::Subscription do
       ).subscription
     end
 
+    context "merchant_account_id" do
+      it "allows changing the merchant_account_id" do
+        result = Braintree::Subscription.update(@subscription.id,
+          :merchant_account_id => NonDefaultMerchantAccountId
+        )
+
+        result.success?.should == true
+        result.subscription.merchant_account_id.should == NonDefaultMerchantAccountId
+      end
+    end
+
     context "when successful" do
       it "returns a success response with the updated subscription if valid" do
         new_id = rand(36**9).to_s(36)
@@ -359,7 +395,7 @@ describe Braintree::Subscription do
       }.to raise_error(Braintree::NotFoundError, 'subscription with id "noSuchSubscription" not found')
     end
 
-    it "cannot be canceled if already canceld" do
+    it "cannot be canceled if already canceled" do
       subscription = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :price => 54.32,
@@ -375,4 +411,209 @@ describe Braintree::Subscription do
       result.errors.for(:subscription)[0].code.should == "81905"
     end
   end
+
+  describe "self.search" do
+    context "search_fields" do
+      it "correctly returns a result with no matches" do
+        collection = Braintree::Subscription.search do |search|
+          search.plan_id.is "not_a_real_plan_id"
+        end
+
+        collection.items.size.should == 0
+      end
+
+      context "is statement" do
+        it "returns paged collection with matching results" do
+          trialless_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          trial_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TrialPlan[:id]
+          ).subscription
+
+          collection = Braintree::Subscription.search do |search|
+            search.plan_id.is TriallessPlan[:id]
+          end
+
+          collection.should include_on_any_page(trialless_subscription)
+          collection.should_not include_on_any_page(trial_subscription)
+        end
+      end
+
+      context "is_not statement" do
+        it "returns paged collection without matching results" do
+          trialless_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          trial_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TrialPlan[:id]
+          ).subscription
+
+          collection = Braintree::Subscription.search do |search|
+            search.plan_id.is_not TriallessPlan[:id]
+          end
+
+          collection.should_not include_on_any_page(trialless_subscription)
+          collection.should include_on_any_page(trial_subscription)
+        end
+      end
+
+      context "ends_with statement" do
+        it "returns paged collection with matching results" do
+          trialless_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          trial_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TrialPlan[:id]
+          ).subscription
+
+          collection = Braintree::Subscription.search do |search|
+            search.plan_id.ends_with "trial_plan"
+          end
+
+          collection.should include_on_any_page(trial_subscription)
+          collection.should_not include_on_any_page(trialless_subscription)
+        end
+      end
+
+      context "starts_with statement" do
+        it "returns paged collection with matching results" do
+          trialless_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          trial_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TrialPlan[:id]
+          ).subscription
+
+          collection = Braintree::Subscription.search do |search|
+            search.plan_id.starts_with "integration_trial_p"
+          end
+
+          collection.should include_on_any_page(trial_subscription)
+          collection.should_not include_on_any_page(trialless_subscription)
+        end
+      end
+
+      context "contains statement" do
+        it "returns paged collection with matching results" do
+          trialless_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          trial_subscription = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TrialPlan[:id]
+          ).subscription
+
+          collection = Braintree::Subscription.search do |search|
+            search.plan_id.contains "trial_p"
+          end
+
+          collection.should include_on_any_page(trial_subscription)
+          collection.should_not include_on_any_page(trialless_subscription)
+        end
+      end
+    end
+
+    context "multiple_value_fields" do
+      context "in" do
+        it "matches all values if none are specified" do
+          subscription1 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          subscription2 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          Braintree::Subscription.cancel(subscription2.id)
+
+          collection = Braintree::Subscription.search do |search|
+            search.plan_id.is TriallessPlan[:id]
+          end
+
+          collection.should include_on_any_page(subscription1)
+          collection.should include_on_any_page(subscription2)
+        end
+
+        it "returns only matching results" do
+          subscription1 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          subscription2 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          Braintree::Subscription.cancel(subscription2.id)
+
+          collection = Braintree::Subscription.search do |search|
+            search.status.in Braintree::Subscription::Status::Active
+          end
+
+          collection.should include_on_any_page(subscription1)
+          collection.should_not include_on_any_page(subscription2)
+        end
+
+        it "returns only matching results given an argument list" do
+          subscription1 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          subscription2 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          Braintree::Subscription.cancel(subscription2.id)
+
+          collection = Braintree::Subscription.search do |search|
+            search.status.in Braintree::Subscription::Status::Active, Braintree::Subscription::Status::Canceled
+          end
+
+          collection.should include_on_any_page(subscription1)
+          collection.should include_on_any_page(subscription2)
+        end
+
+        it "returns only matching results given an array" do
+          subscription1 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          subscription2 = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TriallessPlan[:id]
+          ).subscription
+
+          Braintree::Subscription.cancel(subscription2.id)
+
+          collection = Braintree::Subscription.search do |search|
+            search.status.in [Braintree::Subscription::Status::Active, Braintree::Subscription::Status::Canceled]
+          end
+
+          collection.should include_on_any_page(subscription1)
+          collection.should include_on_any_page(subscription2)
+        end
+      end
+    end
+  end
 end