braintree 1.0.1 → 1.1.0

data/spec/integration/braintree/customer_spec.rb

@@ -6,7 +6,7 @@ describe Braintree::Customer do
       first_page = Braintree::Customer.all
       first_page.current_page_number.should == 1
     end
-    
+
     it "can get the next_page" do
       first_page = Braintree::Customer.all
       first_page.current_page_number.should == 1
@@ -55,12 +55,12 @@ describe Braintree::Customer do
       result.customer.created_at.between?(Time.now - 10, Time.now).should == true
       result.customer.updated_at.between?(Time.now - 10, Time.now).should == true
     end
-    
+
     it "can create without any attributes" do
       result = Braintree::Customer.create
       result.success?.should == true
     end
-    
+
     it "returns an error response if invalid" do
       result = Braintree::Customer.create(
         :email => "@invalid.com"
@@ -100,7 +100,7 @@ describe Braintree::Customer do
       result.success?.should == false
       result.credit_card_verification.status.should == "processor_declined"
     end
-    
+
     it "can create a customer, payment method, and billing address at the same time" do
       result = Braintree::Customer.create(
         :first_name => "Mike",
@@ -133,7 +133,7 @@ describe Braintree::Customer do
       result.customer.addresses[0].postal_code.should == "60622"
       result.customer.addresses[0].country_name.should == "United States of America"
     end
-    
+
     it "stores custom fields when valid" do
       result = Braintree::Customer.create(
         :first_name => "Bill",
@@ -174,7 +174,7 @@ describe Braintree::Customer do
       result.errors.for(:customer).on(:custom_fields)[0].message.should == "Custom field is invalid: spouse_name."
     end
   end
-  
+
   describe "self.create!" do
     it "returns the customer if successful" do
       customer = Braintree::Customer.create!(
@@ -185,19 +185,19 @@ describe Braintree::Customer do
       customer.first_name.should == "Jim"
       customer.last_name.should == "Smith"
     end
-    
+
     it "can create without any attributes" do
       customer = Braintree::Customer.create!
       customer.id.should =~ /\d+/
     end
-    
+
     it "raises an exception if not successful" do
       expect do
         Braintree::Customer.create!(:email => "@foo.com")
       end.to raise_error(Braintree::ValidationsFailed)
     end
   end
-  
+
   describe "self.credit" do
     it "creates a credit transaction for given customer id, returning a result object" do
       customer = Braintree::Customer.create!(
@@ -208,7 +208,7 @@ describe Braintree::Customer do
       )
       result = Braintree::Customer.credit(customer.id, :amount => "100.00")
       result.success?.should == true
-      result.transaction.amount.should == "100.00"
+      result.transaction.amount.should == BigDecimal.new("100.00")
       result.transaction.type.should == "credit"
       result.transaction.customer_details.id.should == customer.id
       result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -227,7 +227,7 @@ describe Braintree::Customer do
         }
       )
       transaction = Braintree::Customer.credit!(customer.id, :amount => "100.00")
-      transaction.amount.should == "100.00"
+      transaction.amount.should == BigDecimal.new("100.00")
       transaction.type.should == "credit"
       transaction.customer_details.id.should == customer.id
       transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -236,7 +236,7 @@ describe Braintree::Customer do
       transaction.credit_card_details.expiration_date.should == "05/2010"
     end
   end
-  
+
   describe "self.sale" do
     it "creates a sale transaction for given customer id, returning a result object" do
       customer = Braintree::Customer.create!(
@@ -247,7 +247,7 @@ describe Braintree::Customer do
       )
       result = Braintree::Customer.sale(customer.id, :amount => "100.00")
       result.success?.should == true
-      result.transaction.amount.should == "100.00"
+      result.transaction.amount.should == BigDecimal.new("100.00")
       result.transaction.type.should == "sale"
       result.transaction.customer_details.id.should == customer.id
       result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -266,7 +266,7 @@ describe Braintree::Customer do
         }
       )
       transaction = Braintree::Customer.sale!(customer.id, :amount => "100.00")
-      transaction.amount.should == "100.00"
+      transaction.amount.should == BigDecimal.new("100.00")
       transaction.type.should == "sale"
       transaction.customer_details.id.should == customer.id
       transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -305,7 +305,7 @@ describe Braintree::Customer do
         :amount => "100.00"
       )
       result.success?.should == true
-      result.transaction.amount.should == "100.00"
+      result.transaction.amount.should == BigDecimal.new("100.00")
       result.transaction.type.should == "sale"
       result.transaction.customer_details.id.should == customer.id
       result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -314,7 +314,7 @@ describe Braintree::Customer do
       result.transaction.credit_card_details.expiration_date.should == "05/2010"
     end
   end
-  
+
   describe "sale!" do
     it "returns the created sale tranaction if valid" do
       customer = Braintree::Customer.create!(
@@ -324,7 +324,7 @@ describe Braintree::Customer do
         }
       )
       transaction = customer.sale!(:amount => "100.00")
-      transaction.amount.should == "100.00"
+      transaction.amount.should == BigDecimal.new("100.00")
       transaction.type.should == "sale"
       transaction.customer_details.id.should == customer.id
       transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -349,7 +349,7 @@ describe Braintree::Customer do
       collection[0].should == transaction
     end
   end
-  
+
   describe "credit" do
     it "creates a credit transaction using the customer, returning a result object" do
       customer = Braintree::Customer.create!(
@@ -362,7 +362,7 @@ describe Braintree::Customer do
         :amount => "100.00"
       )
       result.success?.should == true
-      result.transaction.amount.should == "100.00"
+      result.transaction.amount.should == BigDecimal.new("100.00")
       result.transaction.type.should == "credit"
       result.transaction.customer_details.id.should == customer.id
       result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -371,7 +371,7 @@ describe Braintree::Customer do
       result.transaction.credit_card_details.expiration_date.should == "05/2010"
     end
   end
-  
+
   describe "credit!" do
     it "returns the created credit tranaction if valid" do
       customer = Braintree::Customer.create!(
@@ -381,7 +381,7 @@ describe Braintree::Customer do
         }
       )
       transaction = customer.credit!(:amount => "100.00")
-      transaction.amount.should == "100.00"
+      transaction.amount.should == BigDecimal.new("100.00")
       transaction.type.should == "credit"
       transaction.customer_details.id.should == customer.id
       transaction.credit_card_details.token.should == customer.credit_cards[0].token
@@ -416,7 +416,7 @@ describe Braintree::Customer do
       customer.fax.should == "614.555.5656"
       customer.website.should == "www.johndoe.com"
     end
-    
+
     it "can pass any attribute through tr_data" do
       customer_id = "customer_#{rand(1_000_000)}"
       tr_data_params = {
@@ -445,7 +445,7 @@ describe Braintree::Customer do
       customer.website.should == "www.johndoe.com"
     end
   end
-  
+
   describe "delete" do
     it "deletes the customer" do
      result = Braintree::Customer.create(
@@ -461,7 +461,7 @@ describe Braintree::Customer do
       end.to raise_error(Braintree::NotFoundError)
     end
   end
-  
+
 
   describe "self.find" do
     it "finds the customer with the given id" do
@@ -483,7 +483,7 @@ describe Braintree::Customer do
       end.to raise_error(Braintree::NotFoundError, 'customer with id "invalid-id" not found')
     end
   end
-  
+
   describe "self.update" do
     it "updates the customer with the given id if successful" do
       customer = Braintree::Customer.create!(
@@ -515,8 +515,8 @@ describe Braintree::Customer do
       result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
     end
   end
-  
-  describe "self.update!" do 
+
+  describe "self.update!" do
     it "returns the updated customer if successful" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",
@@ -531,7 +531,7 @@ describe Braintree::Customer do
       updated_customer.last_name.should == "Super Cool"
       updated_customer.updated_at.between?(Time.now - 5, Time.now).should == true
     end
-    
+
     it "raises an error if unsuccessful" do
       customer = Braintree::Customer.create!(:email => "valid@email.com")
       expect do
@@ -539,7 +539,7 @@ describe Braintree::Customer do
       end.to raise_error(Braintree::ValidationsFailed)
     end
   end
-    
+
   describe "update" do
     it "updates the customer" do
       customer = Braintree::Customer.create!(
@@ -556,7 +556,7 @@ describe Braintree::Customer do
       updated_customer.first_name.should == "Mr. Joe"
       updated_customer.last_name.should == "Super Cool"
     end
-    
+
     it "returns an error response if invalid" do
       customer = Braintree::Customer.create!(
         :email => "valid@email.com"
@@ -568,8 +568,8 @@ describe Braintree::Customer do
       result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
     end
   end
-  
-  describe "update!" do 
+
+  describe "update!" do
     it "returns the customer and updates the customer if successful" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",
@@ -583,7 +583,7 @@ describe Braintree::Customer do
       customer.last_name.should == "Super Cool"
       customer.updated_at.between?(Time.now - 5, Time.now).should == true
     end
-    
+
     it "raises an error if unsuccessful" do
       customer = Braintree::Customer.create!(
         :email => "valid@email.com"
@@ -687,7 +687,7 @@ describe Braintree::Customer do
       request.body = Braintree::Util.hash_to_query_string(params)
       response = http.request(request)
     end
-    query_string = response["Location"].split("?", 2).last  
+    query_string = response["Location"].split("?", 2).last
     query_string
   end
 
@@ -703,6 +703,6 @@ describe Braintree::Customer do
       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  
+    query_string = response["Location"].split("?", 2).last
   end
 end

data/spec/integration/braintree/http_spec.rb

@@ -20,7 +20,7 @@ describe Braintree::Http do
       end.to raise_error(Braintree::AuthorizationError)
     end
   end
-  
+
   describe "self._http_do" do
     it "logs one line of info to the logger" do
       begin
@@ -124,7 +124,7 @@ describe Braintree::Http do
         end
       end
 
-      xit "Patrick: waiting on a production box - accepts the certificate on the production server" do
+      it "accepts the certificate on the production server" do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :production
@@ -143,7 +143,7 @@ describe Braintree::Http do
           Braintree::Configuration.stub(:base_merchant_path).and_return("/")
           original_ca_file = Braintree::Configuration.ca_file
           Braintree::Configuration.stub(:ca_file).and_return(nil)
-          
+
           expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError)
         ensure
           Braintree::Configuration.environment = original_env

data/spec/integration/braintree/subscription_spec.rb

@@ -0,0 +1,362 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Subscription do
+  before(:each) do
+    @credit_card = Braintree::Customer.create!(
+      :credit_card => {
+      :number => Braintree::Test::CreditCardNumbers::Visa,
+      :expiration_date => "05/2010"
+    }
+    ).credit_cards[0]
+  end
+
+  describe "self.create" do
+    it "is successful with a miniumum of params" do
+      result = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :plan_id => Braintree::Test::Plans::TriallessPlan[:id]
+      )
+
+      date_format = /^\d{4}\D\d{1,2}\D\d{1,2}$/
+      result.success?.should == true
+      result.subscription.id.should =~ /^\w{6}$/
+      result.subscription.status.should == Braintree::Subscription::Status::Active
+      result.subscription.plan_id.should == "integration_trialless_plan"
+
+      result.subscription.first_billing_date.should match(date_format)
+      result.subscription.next_billing_date.should match(date_format)
+      result.subscription.billing_period_start_date.should match(date_format)
+      result.subscription.billing_period_end_date.should match(date_format)
+
+      result.subscription.failure_count.should == 0
+      result.subscription.payment_method_token.should == @credit_card.token
+    end
+
+    it "can set the id" do
+      new_id = rand(36**9).to_s(36)
+      result = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :plan_id => Braintree::Test::Plans::TriallessPlan[:id],
+        :id => new_id
+      )
+
+      date_format = /^\d{4}\D\d{1,2}\D\d{1,2}$/
+      result.success?.should == true
+      result.subscription.id.should == new_id
+    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 => Braintree::Test::Plans::TriallessPlan[:id]
+          )
+
+          result.subscription.trial_period.should == false
+          result.subscription.trial_duration.should == nil
+          result.subscription.trial_duration_unit.should == nil
+        end
+
+        it "with a trial" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => Braintree::Test::Plans::TrialPlan[:id]
+          )
+
+          result.subscription.trial_period.should == true
+          result.subscription.trial_duration.should == 2
+          result.subscription.trial_duration_unit.should == Braintree::Subscription::TrialDurationUnit::Day
+        end
+
+        it "can alter the trial period params" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+            :trial_duration => 5,
+            :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Month
+          )
+
+          result.subscription.trial_period.should == true
+          result.subscription.trial_duration.should == 5
+          result.subscription.trial_duration_unit.should == Braintree::Subscription::TrialDurationUnit::Month
+        end
+
+        it "can override the trial_period param" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+            :trial_period => false
+          )
+
+          result.subscription.trial_period.should == false
+        end
+
+        it "creates a transaction if no trial period" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => Braintree::Test::Plans::TriallessPlan[:id]
+          )
+
+          result.subscription.transactions.size.should == 1
+          result.subscription.transactions.first.should be_a(Braintree::Transaction)
+          result.subscription.transactions.first.amount.should == BigDecimal.new("12.34")
+          result.subscription.transactions.first.type.should == Braintree::Transaction::Type::Sale
+        end
+
+        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 => Braintree::Test::Plans::TrialPlan[:id]
+          )
+
+          result.subscription.transactions.size.should == 0
+        end
+      end
+
+      context "price" do
+        it "defaults to the plan's price" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => Braintree::Test::Plans::TrialPlan[:id]
+          )
+
+          result.subscription.price.should == BigDecimal.new("43.21")
+        end
+
+        it "can be overridden" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+            :price => 98.76
+          )
+
+          result.subscription.price.should == BigDecimal.new("98.76")
+        end
+      end
+    end
+
+    context "validation errors" do
+      it "has validation errors on id" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+          :id => "invalid token"
+        )
+        result.success?.should == false
+        result.errors.for(:subscription).on(:id)[0].message.should == "ID is invalid (use only letters, numbers, '-', and '_')."
+      end
+
+      it "has validation errors on duplicate id" do
+        duplicate_token = "duplicate_token_#{rand(36**8).to_s(36)}"
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+          :id => duplicate_token
+        )
+        result.success?.should == true
+
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+          :id => duplicate_token
+        )
+        result.success?.should == false
+        result.errors.for(:subscription).on(:id)[0].message.should == "ID has already been taken."
+      end
+
+      it "trial duration required" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+          :trial_period => true,
+          :trial_duration => nil
+        )
+        result.success?.should == false
+        result.errors.for(:subscription)[0].message.should == "Trial Duration is required."
+      end
+
+      it "trial duration unit required" do
+        result = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+          :trial_period => true,
+          :trial_duration_unit => nil
+        )
+        result.success?.should == false
+        result.errors.for(:subscription)[0].message.should == "Trial Duration Unit is invalid."
+      end
+
+    end
+  end
+
+  describe "self.find" do
+    it "finds a subscription" do
+      result = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :plan_id => Braintree::Test::Plans::TriallessPlan[:id]
+      )
+      result.success?.should == true
+
+      Braintree::Subscription.find(result.subscription.id).should == result.subscription
+    end
+
+    it "raises Braintree::NotFoundError if it cannot find" do
+      expect {
+        Braintree::Subscription.find('noSuchSubscription')
+      }.to raise_error(Braintree::NotFoundError, 'subscription with id "noSuchSubscription" not found')
+    end
+  end
+
+  describe "self.update" do
+    before(:each) do
+      @subscription = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :price => 54.32,
+        :plan_id => Braintree::Test::Plans::TriallessPlan[:id]
+      ).subscription
+    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)
+        result = Braintree::Subscription.update(@subscription.id,
+          :id => new_id,
+          :price => 9999.88,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id]
+        )
+
+        result.success?.should == true
+        result.subscription.id.should =~ /#{new_id}/
+        result.subscription.plan_id.should == Braintree::Test::Plans::TrialPlan[:id]
+        result.subscription.price.should == BigDecimal.new("9999.88")
+      end
+
+      it "prorates if there is a charge (because merchant has proration option enabled in control panel)" do
+        result = Braintree::Subscription.update(@subscription.id,
+          :price => @subscription.price.to_f + 1
+        )
+
+        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 "doesn't prorate if price decreases" do
+        result = Braintree::Subscription.update(@subscription.id,
+          :price => @subscription.price.to_f - 1
+        )
+
+        result.success?.should == true
+        result.subscription.price.to_f.should == @subscription.price.to_f - 1
+        result.subscription.transactions.size.should == 
+          @subscription.transactions.size
+      end
+    end
+
+    context "when unsuccessful" do
+      before(:each) do
+        @subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id]
+        ).subscription
+      end
+
+      it "raises NotFoundError if the subscription can't be found" do
+        expect {
+          Braintree::Subscription.update(rand(36**9).to_s(36),
+            :price => 58.20
+          )
+        }.to raise_error(Braintree::NotFoundError)
+      end
+
+      it "has validation errors on id" do
+        result = Braintree::Subscription.update(@subscription.id, :id => "invalid token")
+        result.success?.should == false
+        result.errors.for(:subscription).on(:id)[0].code.should == Braintree::ErrorCodes::Subscription::TokenFormatIsInvalid
+      end
+
+      it "has a price" do
+        result = Braintree::Subscription.update(@subscription.id, :price => "")
+        result.success?.should == false
+        result.errors.for(:subscription).on(:price)[0].code.should == Braintree::ErrorCodes::Subscription::PriceCannotBeBlank
+      end
+
+      it "has a properly formatted price" do
+        result = Braintree::Subscription.update(@subscription.id, :price => "9.2.1 apples")
+        result.success?.should == false
+        result.errors.for(:subscription).on(:price)[0].code.should == Braintree::ErrorCodes::Subscription::PriceFormatIsInvalid
+      end
+
+      it "has validation errors on duplicate id" do
+        duplicate_id = "new_id_#{rand(36**6).to_s(36)}"
+        duplicate = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :plan_id => Braintree::Test::Plans::TrialPlan[:id],
+          :id => duplicate_id
+        )
+        result = Braintree::Subscription.update(
+          @subscription.id,
+          :id => duplicate_id
+        )
+        result.success?.should == false
+        result.errors.for(:subscription).on(:id)[0].code.should == Braintree::ErrorCodes::Subscription::IdIsInUse
+      end
+
+      it "cannot update a canceled subscription" do
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => @credit_card.token,
+          :price => 54.32,
+          :plan_id => Braintree::Test::Plans::TriallessPlan[:id]
+        ).subscription
+
+        result = Braintree::Subscription.cancel(subscription.id)
+        result.success?.should == true
+
+        result = Braintree::Subscription.update(subscription.id,
+          :price => 123.45
+        )
+        result.success?.should == false
+        result.errors.for(:subscription)[0].code.should == Braintree::ErrorCodes::Subscription::CannotEditCanceledSubscription
+      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 => Braintree::Test::Plans::TriallessPlan[:id]
+      ).subscription
+
+      result = Braintree::Subscription.cancel(subscription.id)
+      result.success?.should == true
+      result.subscription.status.should == Braintree::Subscription::Status::Canceled
+    end
+
+    it "returns a validation error if record not found" do
+      expect {
+        r = Braintree::Subscription.cancel('noSuchSubscription')
+      }.to raise_error(Braintree::NotFoundError, 'subscription with id "noSuchSubscription" not found')
+    end
+
+    it "cannot be canceled if already canceld" do
+      subscription = Braintree::Subscription.create(
+        :payment_method_token => @credit_card.token,
+        :price => 54.32,
+        :plan_id => Braintree::Test::Plans::TriallessPlan[:id]
+      ).subscription
+
+      result = Braintree::Subscription.cancel(subscription.id)
+      result.success?.should == true
+      result.subscription.status.should == Braintree::Subscription::Status::Canceled
+
+      result = Braintree::Subscription.cancel(subscription.id)
+      result.success?.should == false
+      result.errors.for(:subscription)[0].code.should == "81905"
+    end
+  end
+end