braintree-rails 1.2.3 → 1.3.0

data/spec/unit/braintree_rails/merchant_account_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
+
+describe BraintreeRails::MerchantAccount do
+  describe 'validations' do
+    [:tos_accepted, :master_merchant_account_id, :individual, :funding].each do |attribute|
+      it "requires #{attribute}" do
+        merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(attribute => nil))
+        merchant_account.should be_invalid
+        merchant_account.errors[attribute].should == ["can't be blank"]
+      end
+    end
+
+    it "validates id format" do
+      [nil, "", "a", "_", "-", "0", "a"*32].each do |valid_value|
+        merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(:id => valid_value))
+        merchant_account.should be_valid
+      end
+
+      ["%", "/"].each do |invalid_value|
+        merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(:id => invalid_value))
+        merchant_account.should be_invalid
+        merchant_account.errors[:id].should == ["is invalid"]
+      end
+    end
+
+    it "validates id length" do
+      merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(:id => "a"*33))
+      merchant_account.should be_invalid
+      merchant_account.errors[:id].should == ["is too long (maximum is 32 characters)"]
+    end
+
+    it "validates individual" do
+      merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(:individual => {}))
+      merchant_account.should be_invalid
+      merchant_account.errors[:individual].should_not be_empty
+    end
+
+    it "validates funding" do
+      merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(:funding => {}))
+      merchant_account.should be_invalid
+      merchant_account.errors[:funding].should_not be_empty
+    end
+
+    it "validates business if present" do
+      merchant_account = BraintreeRails::MerchantAccount.new(merchant_account_hash.merge(:business => {:legal_name => "foo"}))
+      merchant_account.should be_invalid
+      merchant_account.errors[:business].should_not be_empty
+    end
+  end
+end

data/{test/unit/braintree_rails/plan_test.rb → spec/unit/braintree_rails/plan_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../unit_test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
 
 describe BraintreeRails::Plan do
   before do
@@ -10,9 +10,9 @@ describe BraintreeRails::Plan do
       braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
       plan = BraintreeRails::Plan.new(braintree_plan)
 
-      plan.persisted?.must_equal true
+      plan.should be_persisted
       BraintreeRails::Plan.attributes.each do |attribute|
-        plan.send(attribute).must_equal braintree_plan.send(attribute)
+        plan.send(attribute).should == braintree_plan.send(attribute)
       end
     end
 
@@ -20,9 +20,9 @@ describe BraintreeRails::Plan do
       braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
       plan = BraintreeRails::Plan.find('plan_id')
 
-      plan.persisted?.must_equal true
+      plan.should be_persisted
       BraintreeRails::Plan.attributes.each do |attribute|
-        plan.send(attribute).must_equal braintree_plan.send(attribute)
+        plan.send(attribute).should == braintree_plan.send(attribute)
       end
     end
   end
@@ -32,8 +32,8 @@ describe BraintreeRails::Plan do
       braintree_plans = Braintree::Plan.all
       plans = BraintreeRails::Plan.all
 
-      plans.must_be_kind_of(Enumerable)
-      plans.size.must_equal braintree_plans.size
+      plans.should respond_to(:each)
+      plans.size.should == braintree_plans.size
     end
   end
 
@@ -43,8 +43,8 @@ describe BraintreeRails::Plan do
         braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
         plan = BraintreeRails::Plan.new(braintree_plan)
 
-        plan.send(association).must_be_kind_of(Enumerable)
-        plan.send(association).size.must_equal braintree_plan.send(association).size
+        plan.send(association).should respond_to(:each)
+        plan.send(association).size.should == braintree_plan.send(association).size
       end
     end
   end
@@ -62,14 +62,14 @@ describe BraintreeRails::Plan do
         search.plan_id.is 'plan_id'
       end.to_a
 
-      plan.subscriptions.must_be_kind_of(Enumerable)
-      plan.subscriptions.size.must_equal braintree_subscriptions.size
+      plan.subscriptions.should respond_to(:each)
+      plan.subscriptions.size.should == braintree_subscriptions.size
     end
 
     it 'can build new subscription' do
       plan = BraintreeRails::Plan.new('plan_id')
       subscription = plan.subscriptions.build
-      subscription.plan_id.must_equal plan.id
+      subscription.plan_id.should == plan.id
     end
   end
 end

data/{test/unit/braintree_rails/subscription_test.rb → spec/unit/braintree_rails/subscription_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../unit_test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
 
 describe BraintreeRails::Subscription do
   before do
@@ -10,10 +10,10 @@ describe BraintreeRails::Subscription do
       subscription = BraintreeRails::Subscription.new('subscription_id')
       braintree_subscription = Braintree::Subscription.find('subscription_id')
 
-      subscription.persisted?.must_equal true
-      subscription.never_expires?.must_equal braintree_subscription.never_expires?
+      subscription.should be_persisted
+      subscription.never_expires?.should == braintree_subscription.never_expires?
       BraintreeRails::Subscription.attributes.each do |attribute|
-        subscription.send(attribute).must_equal braintree_subscription.send(attribute) if braintree_subscription.respond_to?(attribute)
+        subscription.send(attribute).should == braintree_subscription.send(attribute) if braintree_subscription.respond_to?(attribute)
       end
     end
 
@@ -21,27 +21,27 @@ describe BraintreeRails::Subscription do
       braintree_subscription = Braintree::Subscription.find('subscription_id')
       subscription = BraintreeRails::Subscription.new(braintree_subscription)
 
-      subscription.persisted?.must_equal true
+      subscription.should be_persisted
       BraintreeRails::Subscription.attributes.each do |attribute|
-        subscription.send(attribute).must_equal braintree_subscription.send(attribute) if braintree_subscription.respond_to?(attribute)
+        subscription.send(attribute).should == braintree_subscription.send(attribute) if braintree_subscription.respond_to?(attribute)
       end
     end
 
     it 'should extract values from hash' do
       subscription = BraintreeRails::Subscription.new(:id => 'new_id')
 
-      subscription.persisted?.must_equal false
-      subscription.id.must_equal 'new_id'
+      subscription.should_not be_persisted
+      subscription.id.should == 'new_id'
     end
 
     it 'should try to extract value from other types' do
       subscription = BraintreeRails::Subscription.new(OpenStruct.new(:id => 'foobar', :persisted? => true))
 
-      subscription.persisted?.must_equal true
-      subscription.id.must_equal 'foobar'
+      subscription.should be_persisted
+      subscription.id.should == 'foobar'
 
       subscription = BraintreeRails::Subscription.new(OpenStruct.new)
-      subscription.persisted?.must_equal false
+      subscription.should_not be_persisted
     end
   end
 
@@ -49,136 +49,136 @@ describe BraintreeRails::Subscription do
     it 'should validate id' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:id].must_be :blank?
+      subscription.errors[:id].should be_blank
 
       subscription = BraintreeRails::Subscription.new(:id => '@#$%')
       subscription.valid?
-      subscription.errors[:id].wont_be :blank?
+      subscription.errors[:id].should_not be_blank
     end
 
     it 'should billing_day_of_month' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:billing_day_of_month].must_be :blank?
+      subscription.errors[:billing_day_of_month].should be_blank
 
       [*(1..28), 31].each do |valid_day|
         subscription = BraintreeRails::Subscription.new(:billing_day_of_month => valid_day)
         subscription.valid?
-        subscription.errors[:billing_day_of_month].must_be :blank?
+        subscription.errors[:billing_day_of_month].should be_blank
       end
 
       [29, 30, 'foo'].each do |invalid_day|
         subscription = BraintreeRails::Subscription.new(:billing_day_of_month => invalid_day)
         subscription.valid?
-        subscription.errors[:billing_day_of_month].wont_be :blank?
+        subscription.errors[:billing_day_of_month].should_not be_blank
       end
     end
 
     it 'should validate numericality of number_of_billing_cycles' do
       subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => 'foobar')
       subscription.valid?
-      subscription.errors[:number_of_billing_cycles].wont_be :blank?
+      subscription.errors[:number_of_billing_cycles].should_not be_blank
 
       [123, '123', nil].each do |valid_number|
         subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => valid_number)
         subscription.valid?
-        subscription.errors[:number_of_billing_cycles].must_be :blank?
+        subscription.errors[:number_of_billing_cycles].should be_blank
       end
 
       [123.45, '123.45', 'foo'].each do |invalid_number|
         subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => 'foo')
         subscription.valid?
-        subscription.errors[:number_of_billing_cycles].wont_be :blank?
+        subscription.errors[:number_of_billing_cycles].should_not be_blank
       end
     end
 
     it 'should validate number_of_billing_cycles is greater than current_billing_cycle' do
       subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => '2', :current_billing_cycle => '1')
       subscription.valid?
-      subscription.errors[:number_of_billing_cycles].must_be :blank?
+      subscription.errors[:number_of_billing_cycles].should be_blank
 
       subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => '2', :current_billing_cycle => '3')
       subscription.valid?
-      subscription.errors[:number_of_billing_cycles].wont_be :blank?
+      subscription.errors[:number_of_billing_cycles].should_not be_blank
     end
 
     it 'should validate precence of payment_method_token if new_record?' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:payment_method_token].wont_be :blank?
+      subscription.errors[:payment_method_token].should_not be_blank
 
       subscription = BraintreeRails::Subscription.new(:payment_method_token => 'token')
       subscription.valid?
-      subscription.errors[:payment_method_token].must_be :blank?
+      subscription.errors[:payment_method_token].should be_blank
     end
 
     it 'should validate precence of plan_id if new_record?' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:plan_id].wont_be :blank?
+      subscription.errors[:plan_id].should_not be_blank
 
       subscription = BraintreeRails::Subscription.new(:plan_id => 'plan_id')
       subscription.valid?
-      subscription.errors[:plan_id].must_be :blank?
+      subscription.errors[:plan_id].should be_blank
     end
 
     it 'should validate numericality of price' do
       subscription = BraintreeRails::Subscription.new(:price => 'foobar')
       subscription.valid?
-      subscription.errors[:price].wont_be :blank?
+      subscription.errors[:price].should_not be_blank
 
       [123, 123.45, '123', '123.45', nil].each do |valid_price|
         subscription = BraintreeRails::Subscription.new(:price => valid_price)
         subscription.valid?
-        subscription.errors[:price].must_be :blank?
+        subscription.errors[:price].should be_blank
       end
 
       subscription = BraintreeRails::Subscription.new(:price => 'foo')
       subscription.valid?
-      subscription.errors[:price].wont_be :blank?
+      subscription.errors[:price].should_not be_blank
     end
 
     it 'should validate numericality of trial_duration if trial_period' do
       subscription = BraintreeRails::Subscription.new(:trial_duration => 'foobar')
       subscription.valid?
-      subscription.errors[:trial_duration].must_be :blank?
+      subscription.errors[:trial_duration].should be_blank
 
       subscription = BraintreeRails::Subscription.new(:trial_duration => 'foobar', :trial_period => true)
       subscription.valid?
-      subscription.errors[:trial_duration].wont_be :blank?
+      subscription.errors[:trial_duration].should_not be_blank
 
       [1, 9999, '123'].each do |valid_duration|
         subscription = BraintreeRails::Subscription.new(:trial_duration => valid_duration, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration].must_be :blank?
+        subscription.errors[:trial_duration].should be_blank
       end
 
       [0, 10000, 1.23, nil].each do |invalid_duration|
         subscription = BraintreeRails::Subscription.new(:trial_duration => invalid_duration, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration].wont_be :blank?
+        subscription.errors[:trial_duration].should_not be_blank
       end
     end
 
     it 'should validate trial_duration_unit if trial_period' do
       subscription = BraintreeRails::Subscription.new(:trial_duration_unit => 'foobar')
       subscription.valid?
-      subscription.errors[:trial_duration_unit].must_be :blank?
+      subscription.errors[:trial_duration_unit].should be_blank
 
       subscription = BraintreeRails::Subscription.new(:trial_duration_unit => 'foobar', :trial_period => true)
       subscription.valid?
-      subscription.errors[:trial_duration_unit].wont_be :blank?
+      subscription.errors[:trial_duration_unit].should_not be_blank
 
       ['day', 'month'].each do |valid_unit|
         subscription = BraintreeRails::Subscription.new(:trial_duration_unit => valid_unit, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration_unit].must_be :blank?
+        subscription.errors[:trial_duration_unit].should be_blank
       end
 
       ["", "foo", nil].each do |invalid_duration|
         subscription = BraintreeRails::Subscription.new(:trial_duration_unit => invalid_duration, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration_unit].wont_be :blank?
+        subscription.errors[:trial_duration_unit].should_not be_blank
       end
     end
 
@@ -186,13 +186,13 @@ describe BraintreeRails::Subscription do
       [Date.today, Date.tomorrow, Date.tomorrow.to_s, nil].each do |valid_date|
         subscription = BraintreeRails::Subscription.new(:first_billing_date => valid_date)
         subscription.valid?
-        subscription.errors[:first_billing_date].must_be :blank?
+        subscription.errors[:first_billing_date].should be_blank
       end
 
       [Date.yesterday, "invalid date"].each do |invalid_date|
         subscription = BraintreeRails::Subscription.new(:first_billing_date => invalid_date)
         subscription.valid?
-        subscription.errors[:first_billing_date].wont_be :blank?
+        subscription.errors[:first_billing_date].should_not be_blank
       end
     end
   end
@@ -202,7 +202,7 @@ describe BraintreeRails::Subscription do
       subscription = BraintreeRails::Subscription.new('subscription_id')
       braintree_subscription = Braintree::Subscription.find('subscription_id')
       stub_braintree_request(:get, '/plans', :body => fixture('plans.xml'))
-      subscription.plan.id.must_equal braintree_subscription.plan_id
+      subscription.plan.id.should == braintree_subscription.plan_id
     end
   end
 
@@ -211,7 +211,7 @@ describe BraintreeRails::Subscription do
       subscription = BraintreeRails::Subscription.new('subscription_id')
       braintree_subscription = Braintree::Subscription.find('subscription_id')
       stub_braintree_request(:get, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
-      subscription.credit_card.token.must_equal braintree_subscription.payment_method_token
+      subscription.credit_card.token.should == braintree_subscription.payment_method_token
     end
   end
 
@@ -221,13 +221,13 @@ describe BraintreeRails::Subscription do
         braintree_subscription = Braintree::Subscription.find('subscription_id')
         subscription = BraintreeRails::Subscription.new(braintree_subscription)
 
-        subscription.send(association).must_be_kind_of(Enumerable)
-        subscription.send(association).size.must_equal braintree_subscription.send(association).size
+        subscription.send(association).should respond_to(:each)
+        subscription.send(association).size.should == braintree_subscription.send(association).size
       end
 
       it 'does not support create' do
         subscription = BraintreeRails::Subscription.new('subscription_id')
-        lambda{subscription.send(association).create}.must_raise BraintreeRails::NotSupportedApiException
+        expect {subscription.send(association).create}.to raise_error(BraintreeRails::NotSupportedApiException)
       end
     end
   end
@@ -241,48 +241,48 @@ describe BraintreeRails::Subscription do
     describe 'save, save!' do
       it 'should return true when saved' do
         subscription = BraintreeRails::Subscription.new(subscription_hash)
-        subscription.save.must_equal true
-        subscription.persisted?.must_equal true
+        subscription.save.should be_true
+        subscription.should be_persisted
       end
 
       it 'should not throw error when not valid' do
         subscription = BraintreeRails::Subscription.new
-        subscription.save.must_equal false
-        subscription.persisted?.must_equal false
+        subscription.save.should be_false
+        subscription.should_not be_persisted
       end
 
       it 'should return true when saved with bang' do
         subscription = BraintreeRails::Subscription.new(subscription_hash)
-        subscription.save!.must_equal true
-        subscription.persisted?.must_equal true
+        subscription.save!.should be_true
+        subscription.should be_persisted
       end
 
       it 'should throw error when save invalid record with bang' do
         subscription = BraintreeRails::Subscription.new(:first_name => 'f' * 256)
-        lambda{ subscription.save! }.must_raise(BraintreeRails::RecordInvalid)
-        subscription.persisted?.must_equal false
+        expect { subscription.save! }.to raise_error(BraintreeRails::RecordInvalid)
+        subscription.should_not be_persisted
       end
     end
 
     describe 'update_attributes, update_attributes!' do
       it 'should return true when update_attributes' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        subscription.update_attributes(:price => '10').must_equal true
+        subscription.update_attributes(:price => '10').should be_true
       end
 
       it 'should not throw error when not valid' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        subscription.update_attributes(:price => 'f' * 256).must_equal false
+        subscription.update_attributes(:price => 'f' * 256).should be_false
       end
 
       it 'should return true when update_attributesd with bang' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        subscription.update_attributes!(:price => '10').must_equal true
+        subscription.update_attributes!(:price => '10').should be_true
       end
 
       it 'should throw error when update_attributes invalid record with bang' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        lambda{ subscription.update_attributes!(:price => 'f' * 256) }.must_raise(BraintreeRails::RecordInvalid)
+        expect { subscription.update_attributes!(:price => 'f' * 256) }.to raise_error(BraintreeRails::RecordInvalid)
       end
     end
 

data/{test/unit/braintree_rails/subscriptions_test.rb → spec/unit/braintree_rails/subscriptions_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../unit_test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
 
 describe BraintreeRails::Subscriptions do
 
@@ -16,7 +16,7 @@ describe BraintreeRails::Subscriptions do
 
       subscriptions = BraintreeRails::Subscriptions.new(BraintreeRails::Plan.new('plan_id'))
 
-      subscriptions.map(&:id).sort.must_equal braintree_subscriptions.map(&:id).sort
+      subscriptions.map(&:id).sort.should == braintree_subscriptions.map(&:id).sort
     end
 
     it 'should load all subscriptions' do
@@ -25,7 +25,7 @@ describe BraintreeRails::Subscriptions do
 
       braintree_subscriptions = Braintree::Subscription.search
       subscriptions = BraintreeRails::Subscriptions.new(nil)
-      subscriptions.map(&:id).sort.must_equal braintree_subscriptions.map(&:id).sort
+      subscriptions.map(&:id).sort.should == braintree_subscriptions.map(&:id).sort
     end
   end
 
@@ -33,7 +33,7 @@ describe BraintreeRails::Subscriptions do
     it 'has no default options when loading all' do
       subscriptions = BraintreeRails::Subscriptions.new(nil)
       subscription = subscriptions.build
-      subscription.attributes.values.compact.must_be :empty?
+      subscription.attributes.values.compact.should be_empty
     end
   end
 end