braintree 2.4.0 → 2.5.1

data/spec/integration/braintree/credit_card_spec.rb

@@ -807,13 +807,7 @@ describe Braintree::CreditCard do
   end
 
   describe "self.expired" do
-    it "finds expired payment methods, paginated" do
-      collection = Braintree::CreditCard.expired
-      collection.maximum_size.should > 0
-      collection.all? { |pm| pm.expired?.should == true }
-    end
-
-    it "can iterate over all items" do
+    it "can iterate over all items, and make sure they are all expired" do
       customer = Braintree::Customer.all.first
 
       (110 - Braintree::CreditCard.expired.maximum_size).times do
@@ -827,7 +821,10 @@ describe Braintree::CreditCard do
       collection = Braintree::CreditCard.expired
       collection.maximum_size.should > 100
 
-      credit_card_ids = collection.map {|c| c.token }.uniq.compact
+      credit_card_ids = collection.map do |c|
+        c.expired?.should == true
+        c.token
+      end.uniq.compact
       credit_card_ids.size.should == collection.maximum_size
     end
   end

data/spec/integration/braintree/http_spec.rb

@@ -7,7 +7,7 @@ describe Braintree::Http do
         original_key = Braintree::Configuration.public_key
         Braintree::Configuration.public_key = "invalid_public_key"
         expect do
-          Braintree::Http.get "/customers"
+          Braintree::Configuration.instantiate.http.get "/customers"
         end.to raise_error(Braintree::AuthenticationError)
       ensure
         Braintree::Configuration.public_key = original_key
@@ -16,7 +16,7 @@ describe Braintree::Http do
 
     it "raises an AuthorizationError if authorization fails" do
       expect do
-        Braintree::Http.get "/users"
+        Braintree::Configuration.instantiate.http.get "/users"
       end.to raise_error(Braintree::AuthorizationError)
     end
   end
@@ -73,47 +73,43 @@ describe Braintree::Http do
       end
 
       it "sets the User-Agent header using the default user agent" do
-        response = Braintree::Http.get("/test/headers")
+        response = Braintree::Configuration.instantiate.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 = Braintree::Configuration.instantiate.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
-          use_ssl = Braintree::Configuration.ssl?
-          Braintree::Configuration.stub(:ssl?).and_return(true)
-          Braintree::Configuration.stub(:port).and_return(8443)
-
-          start_ssl_server do
-            expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
-          end
-        ensure
-          Braintree::Configuration.stub(:ssl?).and_return(use_ssl)
+        config = Braintree::Configuration.instantiate
+        config.stub(:ssl?).and_return(true)
+        config.stub(:port).and_return(8443)
+
+        start_ssl_server do
+          expect do
+            config.http._http_do(Net::HTTP::Get, "/login")
+          end.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
         end
       end
 
       it "rejets when the certificate is signed by a different (but valid) root CA" do
         # Random CA root file from a different certificate authority
-        begin
-          original_ca_file = Braintree::Configuration.ca_file
-          Braintree::Configuration.stub(:ca_file).and_return(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "ssl", "geotrust_global.crt")))
-          use_ssl = Braintree::Configuration.ssl?
-          Braintree::Configuration.stub(:ssl?).and_return(true)
-          Braintree::Configuration.stub(:port).and_return(8443)
-
-          start_ssl_server do
-            expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
-          end
-        ensure
-          Braintree::Configuration.stub(:ssl?).and_return(use_ssl)
-          Braintree::Configuration.stub(:ca_file).and_return(original_ca_file)
+        config = Braintree::Configuration.instantiate
+        config.stub(:ca_file).and_return(
+          File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "ssl", "geotrust_global.crt"))
+        )
+        config.stub(:ssl?).and_return(true)
+        config.stub(:port).and_return(8443)
+
+        start_ssl_server do
+          expect do
+            config.http._http_do(Net::HTTP::Get, "/login")
+          end.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
         end
       end
 
@@ -123,7 +119,9 @@ describe Braintree::Http do
           Braintree::Configuration.environment = :qa
           Braintree::Configuration.stub(:base_merchant_path).and_return("/")
 
-          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to_not raise_error
+          expect do
+            Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
+          end.to_not raise_error
         ensure
           Braintree::Configuration.environment = original_env
         end
@@ -135,7 +133,9 @@ describe Braintree::Http do
           Braintree::Configuration.environment = :sandbox
           Braintree::Configuration.stub(:base_merchant_path).and_return("/")
 
-          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to_not raise_error
+          expect do
+            Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
+          end.to_not raise_error
         ensure
           Braintree::Configuration.environment = original_env
         end
@@ -147,7 +147,9 @@ describe Braintree::Http do
           Braintree::Configuration.environment = :production
           Braintree::Configuration.stub(:base_merchant_path).and_return("/")
 
-          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to_not raise_error
+          expect do
+            Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
+          end.to_not raise_error
         ensure
           Braintree::Configuration.environment = original_env
         end
@@ -157,11 +159,13 @@ describe Braintree::Http do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :qa
-          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
-          original_ca_file = Braintree::Configuration.ca_file
-          Braintree::Configuration.stub(:ca_file).and_return(nil)
+          config = Braintree::Configuration.instantiate
+          config.stub(:base_merchant_path).and_return("/")
+          config.stub(:ca_file).and_return(nil)
 
-          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError)
+          expect do
+            config.http._http_do(Net::HTTP::Get, "/login")
+          end.to raise_error(Braintree::SSLCertificateError)
         ensure
           Braintree::Configuration.environment = original_env
         end
@@ -172,18 +176,24 @@ describe Braintree::Http do
   describe "self._verify_ssl_certificate" do
     it "raises if preverify is false" do
       context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
-      expect { Braintree::Http._verify_ssl_certificate(false, context) }.to raise_error(Braintree::SSLCertificateError)
+      expect do
+        Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)
+      end.to raise_error(Braintree::SSLCertificateError)
     end
 
     it "raise if ssl_context doesn't have an error code of 0" do
       context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
       context.error = 19 # ca_file incorrect, self-signed
-      expect { Braintree::Http._verify_ssl_certificate(true, context) }.to raise_error(Braintree::SSLCertificateError)
+      expect do
+        Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)
+      end.to raise_error(Braintree::SSLCertificateError)
     end
 
     it "doesn't raise if there is no error" do
       context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
-      expect { Braintree::Http._verify_ssl_certificate(true, context) }.to_not raise_error
+      expect do
+        Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)
+      end.to_not raise_error
     end
 
     it "logs when there is an error" do
@@ -194,7 +204,9 @@ describe Braintree::Http do
         utc_or_gmt = Time.now.utc.strftime("%Z")
         context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
         context.error = 19
-        expect { Braintree::Http._verify_ssl_certificate(false, context) }.to raise_error(Braintree::SSLCertificateError)
+        expect do
+          Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)
+        end.to raise_error(Braintree::SSLCertificateError)
         output.string.should include("SSL Verification failed -- Preverify: false, Error: self signed certificate in certificate chain (19)")
       ensure
         Braintree::Configuration.logger = old_logger
@@ -208,7 +220,9 @@ describe Braintree::Http do
         Braintree::Configuration.logger = Logger.new(output)
         utc_or_gmt = Time.now.utc.strftime("%Z")
         context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
-        expect { Braintree::Http._verify_ssl_certificate(true, context) }.to_not raise_error(Braintree::SSLCertificateError)
+        expect do
+          Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)
+        end.to_not raise_error(Braintree::SSLCertificateError)
         output.string.should == ""
       ensure
         Braintree::Configuration.logger = old_logger

data/spec/integration/braintree/subscription_spec.rb

@@ -1,21 +1,6 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
 describe Braintree::Subscription do
-  TrialPlan = {
-    :description => "Plan for integration tests -- with trial",
-    :id => "integration_trial_plan",
-    :price => BigDecimal.new("43.21"),
-    :trial_period => true,
-    :trial_duration => 2,
-    :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
-  }
-
-  TriallessPlan = {
-    :description => "Plan for integration tests -- without a trial",
-    :id => "integration_trialless_plan",
-    :price => BigDecimal.new("12.34"),
-    :trial_period => false
-  }
 
   before(:each) do
     @credit_card = Braintree::Customer.create!(
@@ -30,7 +15,7 @@ describe Braintree::Subscription do
     it "is successful with a miniumum of params" do
       result = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
-        :plan_id => TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id]
       )
 
       date_format = /^\d{4}\D\d{1,2}\D\d{1,2}$/
@@ -45,6 +30,7 @@ describe Braintree::Subscription do
       result.subscription.billing_period_end_date.should match(date_format)
 
       result.subscription.failure_count.should == 0
+      result.subscription.next_bill_amount.should == "12.34"
       result.subscription.payment_method_token.should == @credit_card.token
     end
 
@@ -52,7 +38,7 @@ describe Braintree::Subscription do
       new_id = rand(36**9).to_s(36)
       result = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
-        :plan_id => TriallessPlan[:id],
+        :plan_id => SpecHelper::TrialPlan[:id],
         :id => new_id
       )
 
@@ -61,11 +47,72 @@ describe Braintree::Subscription do
       result.subscription.id.should == new_id
     end
 
+    context "billing_day_of_month" do
+      it "inherits from the plan if not provided" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::BillingDayOfMonthPlan[:id]
+        )
+
+        result.success?.should == true
+        result.subscription.billing_day_of_month.should == 5
+      end
+
+      it "allows overriding" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::BillingDayOfMonthPlan[:id],
+          :billing_day_of_month => 25
+        )
+
+        result.success?.should == true
+        result.subscription.billing_day_of_month.should == 25
+      end
+
+      it "allows overriding with start_immediately" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::BillingDayOfMonthPlan[:id],
+          :options => {
+            :start_immediately => true
+          }
+        )
+
+        result.success?.should == true
+        result.subscription.transactions.size.should == 1
+      end
+    end
+
+    context "first_billing_date" do
+      it "allows specifying" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::BillingDayOfMonthPlan[:id],
+          :first_billing_date => Date.today + 3
+        )
+
+        result.success?.should == true
+        result.subscription.first_billing_date.should == (Date.today + 3).to_s
+        result.subscription.status.should == Braintree::Subscription::Status::Pending
+      end
+
+      it "returns an error if the date is in the past" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::BillingDayOfMonthPlan[:id],
+          :first_billing_date => Date.today - 3
+        )
+
+        result.success?.should == false
+        result.errors.for(:subscription).on(:first_billing_date).first.code.should == Braintree::ErrorCodes::Subscription::FirstBillingDateCannotBeInThePast
+      end
+    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]
+          :plan_id => SpecHelper::TrialPlan[:id]
         )
 
         result.success?.should == true
@@ -75,7 +122,7 @@ describe Braintree::Subscription do
       it "allows setting the merchant_account_id" do
         result = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TriallessPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
         )
 
@@ -84,12 +131,36 @@ describe Braintree::Subscription do
       end
     end
 
+    context "number_of_billing_cycles" do
+      it "sets the number of billing cycles on the subscription when provided" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :number_of_billing_cycles => 10
+        )
+
+        result.success?.should == true
+        result.subscription.number_of_billing_cycles.should == 10
+      end
+
+      it "sets the number of billing cycles to nil if :never_expires => true" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :never_expires => true
+        )
+
+        result.success?.should == true
+        result.subscription.number_of_billing_cycles.should == nil
+      end
+    end
+
     context "trial period" do
       context "defaults to the plan's trial period settings" do
         it "with no trial" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id]
+            :plan_id => SpecHelper::TriallessPlan[:id]
           )
 
           result.subscription.trial_period.should == false
@@ -100,7 +171,7 @@ describe Braintree::Subscription do
         it "with a trial" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id]
+            :plan_id => SpecHelper::TrialPlan[:id]
           )
 
           result.subscription.trial_period.should == true
@@ -111,7 +182,7 @@ describe Braintree::Subscription do
         it "can alter the trial period params" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id],
+            :plan_id => SpecHelper::TrialPlan[:id],
             :trial_duration => 5,
             :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Month
           )
@@ -124,7 +195,7 @@ describe Braintree::Subscription do
         it "can override the trial_period param" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id],
+            :plan_id => SpecHelper::TrialPlan[:id],
             :trial_period => false
           )
 
@@ -134,7 +205,7 @@ describe Braintree::Subscription do
         it "doesn't create a transaction if there's a trial period" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id]
+            :plan_id => SpecHelper::TrialPlan[:id]
           )
 
           result.subscription.transactions.size.should == 0
@@ -145,12 +216,12 @@ describe Braintree::Subscription do
         it "creates a transaction if no trial period" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id]
+            :plan_id => SpecHelper::TriallessPlan[:id]
           )
 
           result.subscription.transactions.size.should == 1
           result.subscription.transactions.first.should be_a(Braintree::Transaction)
-          result.subscription.transactions.first.amount.should == TriallessPlan[:price]
+          result.subscription.transactions.first.amount.should == SpecHelper::TriallessPlan[:price]
           result.subscription.transactions.first.type.should == Braintree::Transaction::Type::Sale
           result.subscription.transactions.first.subscription_id.should == result.subscription.id
         end
@@ -158,7 +229,7 @@ describe Braintree::Subscription do
         it "does not create the subscription and returns the transaction if the transaction is not successful" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id],
+            :plan_id => SpecHelper::TriallessPlan[:id],
             :price => Braintree::Test::TransactionAmounts::Decline
           )
 
@@ -172,16 +243,16 @@ describe Braintree::Subscription do
         it "defaults to the plan's price" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id]
+            :plan_id => SpecHelper::TrialPlan[:id]
           )
 
-          result.subscription.price.should == TrialPlan[:price]
+          result.subscription.price.should == SpecHelper::TrialPlan[:price]
         end
 
         it "can be overridden" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id],
+            :plan_id => SpecHelper::TrialPlan[:id],
             :price => 98.76
           )
 
@@ -194,7 +265,7 @@ describe Braintree::Subscription do
       it "has validation errors on id" do
         result = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :id => "invalid token"
         )
         result.success?.should == false
@@ -205,14 +276,14 @@ describe Braintree::Subscription do
         duplicate_token = "duplicate_token_#{rand(36**8).to_s(36)}"
         result = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :id => duplicate_token
         )
         result.success?.should == true
 
         result = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :id => duplicate_token
         )
         result.success?.should == false
@@ -222,7 +293,7 @@ describe Braintree::Subscription do
       it "trial duration required" do
         result = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :trial_period => true,
           :trial_duration => nil
         )
@@ -233,7 +304,7 @@ describe Braintree::Subscription do
       it "trial duration unit required" do
         result = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :trial_period => true,
           :trial_duration => 2,
           :trial_duration_unit => nil
@@ -242,13 +313,218 @@ describe Braintree::Subscription do
         result.errors.for(:subscription).on(:trial_duration_unit)[0].message.should == "Trial Duration Unit is invalid."
       end
     end
+
+    context "add_ons and discounts" do
+      it "does not inherit the add_ons and discounts from the plan when do_not_inherit_add_ons_or_discounts is set" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id],
+          :options => {:do_not_inherit_add_ons_or_discounts => true}
+        )
+        result.success?.should == true
+
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 0
+        subscription.discounts.size.should == 0
+      end
+
+      it "inherits the add_ons and discounts from the plan when not specified" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id]
+        )
+        result.success?.should == true
+
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 2
+        add_ons = subscription.add_ons.sort_by { |add_on| add_on.id }
+
+        add_ons.first.id.should == "increase_10"
+        add_ons.first.amount.should == BigDecimal.new("10.00")
+        add_ons.first.quantity.should == 1
+        add_ons.first.number_of_billing_cycles.should be_nil
+        add_ons.first.never_expires?.should be_true
+
+        add_ons.last.id.should == "increase_20"
+        add_ons.last.amount.should == BigDecimal.new("20.00")
+        add_ons.last.quantity.should == 1
+        add_ons.last.number_of_billing_cycles.should be_nil
+        add_ons.last.never_expires?.should be_true
+
+        subscription.discounts.size.should == 2
+        discounts = subscription.discounts.sort_by { |discount| discount.id }
+
+        discounts.first.id.should == "discount_11"
+        discounts.first.amount.should == BigDecimal.new("11.00")
+        discounts.first.quantity.should == 1
+        discounts.first.number_of_billing_cycles.should be_nil
+        discounts.first.never_expires?.should be_true
+
+        discounts.last.id.should == "discount_7"
+        discounts.last.amount.should == BigDecimal.new("7.00")
+        discounts.last.quantity.should == 1
+        discounts.last.number_of_billing_cycles.should be_nil
+        discounts.last.never_expires?.should be_true
+      end
+
+      it "allows overriding of inherited add_ons and discounts" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id],
+          :add_ons => {
+            :update => [
+              {
+                :amount => BigDecimal.new("50.00"),
+                :existing_id => SpecHelper::AddOnIncrease10,
+                :quantity => 2,
+                :number_of_billing_cycles => 5
+              }
+            ]
+          },
+          :discounts => {
+            :update => [
+              {
+                :amount => BigDecimal.new("15.00"),
+                :existing_id => SpecHelper::Discount7,
+                :quantity => 3,
+                :never_expires => true
+              }
+            ]
+          }
+        )
+        result.success?.should == true
+
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 2
+        add_ons = subscription.add_ons.sort_by { |add_on| add_on.id }
+
+        add_ons.first.id.should == "increase_10"
+        add_ons.first.amount.should == BigDecimal.new("50.00")
+        add_ons.first.quantity.should == 2
+        add_ons.first.number_of_billing_cycles.should == 5
+        add_ons.first.never_expires?.should be_false
+
+        add_ons.last.id.should == "increase_20"
+        add_ons.last.amount.should == BigDecimal.new("20.00")
+        add_ons.last.quantity.should == 1
+
+        subscription.discounts.size.should == 2
+        discounts = subscription.discounts.sort_by { |discount| discount.id }
+
+        discounts.first.id.should == "discount_11"
+        discounts.first.amount.should == BigDecimal.new("11.00")
+        discounts.first.quantity.should == 1
+
+        discounts.last.id.should == "discount_7"
+        discounts.last.amount.should == BigDecimal.new("15.00")
+        discounts.last.quantity.should == 3
+        discounts.last.number_of_billing_cycles.should be_nil
+        discounts.last.never_expires?.should be_true
+      end
+
+      it "allows deleting of inherited add_ons and discounts" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id],
+          :add_ons => {
+            :remove => [SpecHelper::AddOnIncrease10]
+          },
+          :discounts => {
+            :remove => [SpecHelper::Discount7]
+          }
+        )
+        result.success?.should == true
+
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 1
+        subscription.add_ons.first.id.should == "increase_20"
+        subscription.add_ons.first.amount.should == BigDecimal.new("20.00")
+        subscription.add_ons.first.quantity.should == 1
+
+        subscription.discounts.size.should == 1
+        subscription.discounts.last.id.should == "discount_11"
+        subscription.discounts.last.amount.should == BigDecimal.new("11.00")
+        subscription.discounts.last.quantity.should == 1
+      end
+
+      it "allows adding new add_ons and discounts" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id],
+          :add_ons => {
+            :add => [{:inherited_from_id => SpecHelper::AddOnIncrease30}]
+          },
+          :discounts => {
+            :add => [{:inherited_from_id => SpecHelper::Discount15}]
+          }
+        )
+        result.success?.should == true
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 3
+        add_ons = subscription.add_ons.sort_by { |add_on| add_on.id }
+
+        add_ons[0].id.should == "increase_10"
+        add_ons[0].amount.should == BigDecimal.new("10.00")
+        add_ons[0].quantity.should == 1
+
+        add_ons[1].id.should == "increase_20"
+        add_ons[1].amount.should == BigDecimal.new("20.00")
+        add_ons[1].quantity.should == 1
+
+        add_ons[2].id.should == "increase_30"
+        add_ons[2].amount.should == BigDecimal.new("30.00")
+        add_ons[2].quantity.should == 1
+
+        subscription.discounts.size.should == 3
+        discounts = subscription.discounts.sort_by { |discount| discount.id }
+
+        discounts[0].id.should == "discount_11"
+        discounts[0].amount.should == BigDecimal.new("11.00")
+        discounts[0].quantity.should == 1
+
+        discounts[1].id.should == "discount_15"
+        discounts[1].amount.should == BigDecimal.new("15.00")
+        discounts[1].quantity.should == 1
+
+        discounts[2].id.should == "discount_7"
+        discounts[2].amount.should == BigDecimal.new("7.00")
+        discounts[2].quantity.should == 1
+      end
+
+      it "properly parses validation errors for arrays" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id],
+          :add_ons => {
+            :update => [
+              {
+                :existing_id => SpecHelper::AddOnIncrease10,
+                :amount => "invalid"
+              },
+              {
+                :existing_id => SpecHelper::AddOnIncrease20,
+                :quantity => -10,
+              }
+            ]
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:subscription).for(:add_ons).for(:update).for_index(0).on(:amount)[0].code.should == Braintree::ErrorCodes::Subscription::Modification::AmountIsInvalid
+        result.errors.for(:subscription).for(:add_ons).for(:update).for_index(1).on(:quantity)[0].code.should == Braintree::ErrorCodes::Subscription::Modification::QuantityIsInvalid
+      end
+    end
   end
 
   describe "self.find" do
     it "finds a subscription" do
       result = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
-        :plan_id => TriallessPlan[:id]
+        :plan_id => SpecHelper::TrialPlan[:id]
       )
       result.success?.should == true
 
@@ -267,7 +543,7 @@ describe Braintree::Subscription do
       @subscription = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :price => 54.32,
-        :plan_id => TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id]
       ).subscription
     end
 
@@ -300,12 +576,12 @@ describe Braintree::Subscription do
         result = Braintree::Subscription.update(@subscription.id,
           :id => new_id,
           :price => 9999.88,
-          :plan_id => TrialPlan[:id]
+          :plan_id => SpecHelper::TrialPlan[:id]
         )
 
         result.success?.should == true
         result.subscription.id.should =~ /#{new_id}/
-        result.subscription.plan_id.should == TrialPlan[:id]
+        result.subscription.plan_id.should == SpecHelper::TrialPlan[:id]
         result.subscription.price.should == BigDecimal.new("9999.88")
       end
 
@@ -319,6 +595,28 @@ describe Braintree::Subscription do
         result.subscription.transactions.size.should == @subscription.transactions.size + 1
       end
 
+      it "allows the user to force proration if there is a charge" do
+        result = Braintree::Subscription.update(@subscription.id,
+          :price => @subscription.price.to_f + 1,
+          :options => { :prorate_charges => true }
+        )
+
+        result.success?.should == true
+        result.subscription.price.to_f.should == @subscription.price.to_f + 1
+        result.subscription.transactions.size.should == @subscription.transactions.size + 1
+      end
+
+      it "allows the user to prevent proration if there is a charge" do
+        result = Braintree::Subscription.update(@subscription.id,
+          :price => @subscription.price.to_f + 1,
+          :options => { :prorate_charges => false }
+        )
+
+        result.success?.should == true
+        result.subscription.price.to_f.should == @subscription.price.to_f + 1
+        result.subscription.transactions.size.should == @subscription.transactions.size
+      end
+
       it "doesn't prorate if price decreases" do
         result = Braintree::Subscription.update(@subscription.id,
           :price => @subscription.price.to_f - 1
@@ -334,7 +632,7 @@ describe Braintree::Subscription do
       before(:each) do
         @subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id]
+          :plan_id => SpecHelper::TrialPlan[:id]
         ).subscription
       end
 
@@ -368,7 +666,7 @@ describe Braintree::Subscription do
         duplicate_id = "new_id_#{rand(36**6).to_s(36)}"
         duplicate = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
-          :plan_id => TrialPlan[:id],
+          :plan_id => SpecHelper::TrialPlan[:id],
           :id => duplicate_id
         )
         result = Braintree::Subscription.update(
@@ -383,7 +681,7 @@ describe Braintree::Subscription do
         subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :price => 54.32,
-          :plan_id => TriallessPlan[:id]
+          :plan_id => SpecHelper::TriallessPlan[:id]
         ).subscription
 
         result = Braintree::Subscription.cancel(subscription.id)
@@ -396,15 +694,201 @@ describe Braintree::Subscription do
         result.errors.for(:subscription)[0].code.should == Braintree::ErrorCodes::Subscription::CannotEditCanceledSubscription
       end
     end
-  end
 
+    context "number_of_billing_cycles" do
+      it "sets the number of billing cycles on the subscription when provided" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+          :number_of_billing_cycles => 10
+        ).subscription
+
+        result = Braintree::Subscription.update(
+          subscription.id,
+          :number_of_billing_cycles => 5
+        )
+
+        result.subscription.number_of_billing_cycles.should == 5
+      end
+
+      it "sets the number of billing cycles to nil if :never_expires => true" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+          :number_of_billing_cycles => 10
+        ).subscription
+
+        result = Braintree::Subscription.update(
+          subscription.id,
+          :never_expires => true
+        )
+
+        result.success?.should == true
+        result.subscription.number_of_billing_cycles.should == nil
+        result.subscription.never_expires?.should be_true
+      end
+    end
+
+    context "add_ons and discounts" do
+      it "can update add_ons and discounts" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id]
+        )
+        result.success?.should == true
+        subscription = result.subscription
+
+        result = Braintree::Subscription.update(
+          subscription.id,
+          :add_ons => {
+            :update => [
+              {
+                :existing_id => subscription.add_ons.first.id,
+                :amount => BigDecimal.new("99.99"),
+                :quantity => 12
+              }
+            ]
+          },
+          :discounts => {
+            :update => [
+              {
+                :existing_id => subscription.discounts.first.id,
+                :amount => BigDecimal.new("88.88"),
+                :quantity => 9
+              }
+            ]
+          }
+        )
+
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 2
+        add_ons = subscription.add_ons.sort_by { |add_on| add_on.id }
+
+        add_ons.first.amount.should == BigDecimal.new("99.99")
+        add_ons.first.quantity.should == 12
+
+        subscription.discounts.size.should == 2
+        discounts = subscription.discounts.sort_by { |discount| discount.id }
+
+        discounts.last.amount.should == BigDecimal.new("88.88")
+        discounts.last.quantity.should == 9
+      end
+
+      it "allows adding new add_ons and discounts" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id]
+        ).subscription
+
+        result = Braintree::Subscription.update(subscription.id,
+          :add_ons => {
+            :add => [{:inherited_from_id => SpecHelper::AddOnIncrease30}]
+          },
+          :discounts => {
+            :add => [{:inherited_from_id => SpecHelper::Discount15}]
+          }
+        )
+
+        result.success?.should == true
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 3
+        add_ons = subscription.add_ons.sort_by { |add_on| add_on.id }
+
+        add_ons[0].id.should == "increase_10"
+        add_ons[0].amount.should == BigDecimal.new("10.00")
+        add_ons[0].quantity.should == 1
+
+        add_ons[1].id.should == "increase_20"
+        add_ons[1].amount.should == BigDecimal.new("20.00")
+        add_ons[1].quantity.should == 1
+
+        add_ons[2].id.should == "increase_30"
+        add_ons[2].amount.should == BigDecimal.new("30.00")
+        add_ons[2].quantity.should == 1
+
+        subscription.discounts.size.should == 3
+        discounts = subscription.discounts.sort_by { |discount| discount.id }
+
+        discounts[0].id.should == "discount_11"
+        discounts[0].amount.should == BigDecimal.new("11.00")
+        discounts[0].quantity.should == 1
+
+        discounts[1].id.should == "discount_15"
+        discounts[1].amount.should == BigDecimal.new("15.00")
+        discounts[1].quantity.should == 1
+
+        discounts[2].id.should == "discount_7"
+        discounts[2].amount.should == BigDecimal.new("7.00")
+        discounts[2].quantity.should == 1
+      end
+
+      it "allows replacing entire set of add_ons and discounts" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id]
+        ).subscription
+
+        result = Braintree::Subscription.update(subscription.id,
+          :add_ons => {
+            :add => [{:inherited_from_id => SpecHelper::AddOnIncrease30}]
+          },
+          :discounts => {
+            :add => [{:inherited_from_id => SpecHelper::Discount15}]
+          },
+          :options => {:replace_all_add_ons_and_discounts => true}
+        )
+
+        result.success?.should == true
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 1
+
+        subscription.add_ons[0].amount.should == BigDecimal.new("30.00")
+        subscription.add_ons[0].quantity.should == 1
+
+        subscription.discounts.size.should == 1
+
+        subscription.discounts[0].amount.should == BigDecimal.new("15.00")
+        subscription.discounts[0].quantity.should == 1
+      end
+
+      it "allows deleting of add_ons and discounts" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::AddOnDiscountPlan[:id]
+        ).subscription
+
+        result = Braintree::Subscription.update(subscription.id,
+          :add_ons => {
+            :remove => [SpecHelper::AddOnIncrease10]
+          },
+          :discounts => {
+            :remove => [SpecHelper::Discount7]
+          }
+        )
+        result.success?.should == true
+
+        subscription = result.subscription
+
+        subscription.add_ons.size.should == 1
+        subscription.add_ons.first.amount.should == BigDecimal.new("20.00")
+        subscription.add_ons.first.quantity.should == 1
+
+        subscription.discounts.size.should == 1
+        subscription.discounts.last.amount.should == BigDecimal.new("11.00")
+        subscription.discounts.last.quantity.should == 1
+      end
+    end
+  end
 
   describe "self.cancel" do
     it "returns a success response with the updated subscription if valid" do
       subscription = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :price => 54.32,
-        :plan_id => TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id]
       ).subscription
 
       result = Braintree::Subscription.cancel(subscription.id)
@@ -422,7 +906,7 @@ describe Braintree::Subscription do
       subscription = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :price => 54.32,
-        :plan_id => TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id]
       ).subscription
 
       result = Braintree::Subscription.cancel(subscription.id)
@@ -436,212 +920,190 @@ describe Braintree::Subscription do
   end
 
   describe "self.search" do
-    context "search_fields" do
-      it "correctly returns a result with no matches" do
+    describe "id" do
+      it "works using the is operator" do
+        id = rand(36**8).to_s(36)
+        subscription1 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :id => "subscription1_#{id}"
+        ).subscription
+
+        subscription2 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :id => "subscription2_#{id}"
+        ).subscription
+
         collection = Braintree::Subscription.search do |search|
-          search.plan_id.is "not_a_real_plan_id"
+          search.id.is "subscription1_#{id}"
         end
 
-        collection.maximum_size.should == 0
+        collection.should include(subscription1)
+        collection.should_not include(subscription2)
       end
+    end
 
-      context "is statement" do
-        it "returns resource 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
+    describe "merchant_account_id" do
+      it "is searchable using the is or in operator" do
+        subscription1 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :merchant_account_id => SpecHelper::DefaultMerchantAccountId,
+          :price => "1"
+        ).subscription
 
-          collection = Braintree::Subscription.search do |search|
-            search.plan_id.is TriallessPlan[:id]
-          end
+        subscription2 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :price => "1"
+        ).subscription
 
-          collection.should include(trialless_subscription)
-          collection.should_not include(trial_subscription)
+        collection = Braintree::Subscription.search do |search|
+          search.merchant_account_id.is SpecHelper::DefaultMerchantAccountId
+          search.price.is "1"
         end
-      end
 
-      context "is_not statement" do
-        it "returns resource collection without matching results" do
-          trialless_subscription = Braintree::Subscription.create(
-            :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id]
-          ).subscription
+        collection.should include(subscription1)
+        collection.should_not include(subscription2)
 
-          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(trialless_subscription)
-          collection.should include(trial_subscription)
+        collection = Braintree::Subscription.search do |search|
+          search.merchant_account_id.in [SpecHelper::DefaultMerchantAccountId, SpecHelper::NonDefaultMerchantAccountId]
+          search.price.is "1"
         end
-      end
-
-      context "ends_with statement" do
-        it "returns resource 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(trial_subscription)
-          collection.should_not include(trialless_subscription)
-        end
+        collection.should include(subscription1)
+        collection.should include(subscription2)
       end
+    end
 
-      context "starts_with statement" do
-        it "returns resource 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
+    describe "plan_id" do
+      it "works using the is operator" do
+        trialless_subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+          :price => "2"
+        ).subscription
 
-          collection = Braintree::Subscription.search do |search|
-            search.plan_id.starts_with "integration_trial_p"
-          end
+        trial_subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :price => "2"
+        ).subscription
 
-          collection.should include(trial_subscription)
-          collection.should_not include(trialless_subscription)
+        collection = Braintree::Subscription.search do |search|
+          search.plan_id.is SpecHelper::TriallessPlan[:id]
+          search.price.is "2"
         end
-      end
-
-      context "contains statement" do
-        it "returns resource 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(trial_subscription)
-          collection.should_not include(trialless_subscription)
-        end
+        collection.should include(trialless_subscription)
+        collection.should_not include(trial_subscription)
       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)
+    describe "price" do
+      it "works using the is operator" do
+        subscription_500 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :price => "5.00"
+        ).subscription
 
-          collection = Braintree::Subscription.search do |search|
-            search.plan_id.is TriallessPlan[:id]
-          end
+        subscription_501 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :price => "5.01"
+        ).subscription
 
-          collection.should include(subscription1)
-          collection.should include(subscription2)
+        collection = Braintree::Subscription.search do |search|
+          search.price.is "5.00"
         end
 
-        it "returns only matching results" do
-          subscription1 = Braintree::Subscription.create(
-            :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id]
-          ).subscription
+        collection.should include(subscription_500)
+        collection.should_not include(subscription_501)
+      end
+    end
 
-          subscription2 = Braintree::Subscription.create(
-            :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id]
-          ).subscription
+    describe "days_past_due" do
+      it "is backwards-compatible for 'is'" do
+        active_subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :price => "6"
+        ).subscription
 
-          Braintree::Subscription.cancel(subscription2.id)
+        past_due_subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :price => "6"
+        ).subscription
 
-          collection = Braintree::Subscription.search do |search|
-            search.status.in Braintree::Subscription::Status::Active
-          end
+        SpecHelper.make_past_due(past_due_subscription, 5)
 
-          collection.should include(subscription1)
-          collection.should_not include(subscription2)
+        collection = Braintree::Subscription.search do |search|
+          search.price.is "6.00"
+          search.days_past_due.is 5
         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.should include(past_due_subscription)
+        collection.should_not include(active_subscription)
+        collection.each do |s|
+          s.status.should == Braintree::Subscription::Status::PastDue
+        end
+      end
 
-          collection = Braintree::Subscription.search do |search|
-            search.status.in Braintree::Subscription::Status::Active, Braintree::Subscription::Status::Canceled
-          end
+      it "passes a smoke test" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id]
+        ).subscription
 
-          collection.should include(subscription1)
-          collection.should include(subscription2)
+        collection = Braintree::Subscription.search do |search|
+          search.days_past_due.between 1, 20
         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
+        collection.should_not include(subscription)
+        collection.each do |s|
+          s.days_past_due.should >= 1
+          s.days_past_due.should <= 20
+        end
+      end
+    end
 
-          subscription2 = Braintree::Subscription.create(
-            :payment_method_token => @credit_card.token,
-            :plan_id => TriallessPlan[:id]
-          ).subscription
+    describe "billing_cycles_remaining" do
+      it "passes a smoke test" do
+        subscription_5 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TrialPlan[:id],
+          :number_of_billing_cycles => 5
+        ).subscription
 
-          Braintree::Subscription.cancel(subscription2.id)
+        subscription_9 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+          :number_of_billing_cycles => 10
+        ).subscription
 
-          collection = Braintree::Subscription.search do |search|
-            search.status.in [Braintree::Subscription::Status::Active, Braintree::Subscription::Status::Canceled]
-          end
+        subscription_15 = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+          :number_of_billing_cycles => 15
+        ).subscription
 
-          collection.should include(subscription1)
-          collection.should include(subscription2)
+        collection = Braintree::Subscription.search do |search|
+          search.billing_cycles_remaining.between 5, 10
         end
+
+        collection.should include(subscription_5)
+        collection.should include(subscription_9)
+        collection.should_not include(subscription_15)
       end
     end
 
     it "returns multiple results" do
       (110 - Braintree::Subscription.search.maximum_size).times do
-        Braintree::Subscription.create(:payment_method_token => @credit_card.token, :plan_id => TriallessPlan[:id])
+        Braintree::Subscription.create(:payment_method_token => @credit_card.token, :plan_id => SpecHelper::TrialPlan[:id])
       end
 
       collection = Braintree::Subscription.search
@@ -650,14 +1112,15 @@ describe Braintree::Subscription do
       subscriptions_ids = collection.map {|t| t.id }.uniq.compact
       subscriptions_ids.size.should == collection.maximum_size
     end
-
   end
 
   describe "self.retry_charge" do
     it "is successful with only subscription id" do
-      subscription = Braintree::Subscription.search do |search|
-        search.status.in Braintree::Subscription::Status::PastDue
-      end.first
+      subscription = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :plan_id => SpecHelper::TriallessPlan[:id]
+      ).subscription
+      SpecHelper.make_past_due(subscription)
 
       result = Braintree::Subscription.retry_charge(subscription.id)
 
@@ -671,9 +1134,11 @@ describe Braintree::Subscription do
     end
 
     it "is successful with subscription id and amount" do
-      subscription = Braintree::Subscription.search do |search|
-        search.status.in Braintree::Subscription::Status::PastDue
-      end.first
+      subscription = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :plan_id => SpecHelper::TriallessPlan[:id]
+      ).subscription
+      SpecHelper.make_past_due(subscription)
 
       result = Braintree::Subscription.retry_charge(subscription.id, Braintree::Test::TransactionAmounts::Authorize)