braintree-rails 1.2.3 → 1.3.0

data/{test/unit/braintree_rails/credit_cards_test.rb → spec/unit/braintree_rails/credit_cards_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::CreditCards do
   before do
@@ -11,12 +11,15 @@ describe BraintreeRails::CreditCards do
       braintree_credit_cards = braintree_customer.credit_cards
       credit_cards = BraintreeRails::CreditCards.new(BraintreeRails::Customer.find('customer_id'))
 
-      credit_cards.size.must_equal braintree_credit_cards.size
+      credit_cards.size.should == braintree_credit_cards.size
 
       braintree_credit_cards.each do |braintree_credit_card|
         credit_card = credit_cards.find(braintree_credit_card.token)
         BraintreeRails::CreditCard.attributes.each do |attribute|
-          credit_card.send(attribute).must_equal braintree_credit_card.send(attribute) if braintree_credit_card.respond_to?(attribute)
+          next if BraintreeRails::CreditCard.associations.include?(attribute)
+          if braintree_credit_card.respond_to?(attribute)
+            credit_card.send(attribute).should == braintree_credit_card.send(attribute)
+          end
         end
       end
     end
@@ -30,9 +33,9 @@ describe BraintreeRails::CreditCards do
       credit_cards = BraintreeRails::CreditCards.new(BraintreeRails::Customer.find('customer_id'))
       credit_card = credit_cards.build(:cardholder_name => 'foo bar')
 
-      credit_card.persisted?.must_equal false
-      credit_card.customer_id.must_equal braintree_customer.id
-      credit_card.cardholder_name.must_equal 'foo bar'
+      credit_card.should_not be_persisted
+      credit_card.customer_id.should == braintree_customer.id
+      credit_card.cardholder_name.should == 'foo bar'
     end
   end
 
@@ -42,17 +45,19 @@ describe BraintreeRails::CreditCards do
 
       customer = BraintreeRails::Customer.find('customer_id')
       credit_card = customer.credit_cards.create(credit_card_hash)
-      credit_card.persisted?.must_equal true
-      customer.credit_cards.must_include credit_card
+      credit_card.should be_persisted
+      customer.credit_cards.should include(credit_card)
     end
 
     it 'should not add credit card to collection if creation failed' do
       stub_braintree_request(:post, '/payment_methods', :body => fixture('credit_card_validation_error.xml'))
 
       customer = BraintreeRails::Customer.find('customer_id')
+      customer.credit_cards.size.should == 2
+
       credit_card = customer.credit_cards.create(credit_card_hash)
-      credit_card.persisted?.must_equal false
-      customer.credit_cards.wont_include credit_card
+      credit_card.should_not be_persisted
+      customer.credit_cards.size.should == 2
     end
   end
 end

data/{test/unit/braintree_rails/customer_test.rb → spec/unit/braintree_rails/customer_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::Customer do
   before do
@@ -10,9 +10,9 @@ describe BraintreeRails::Customer do
       customer = BraintreeRails::Customer.new('customer_id')
       braintree_customer = Braintree::Customer.find('customer_id')
 
-      customer.persisted?.must_equal true
+      customer.should be_persisted
       BraintreeRails::Customer.attributes.each do |attribute|
-        customer.send(attribute).must_equal braintree_customer.send(attribute) if braintree_customer.respond_to?(attribute)
+        customer.send(attribute).should == braintree_customer.send(attribute) if braintree_customer.respond_to?(attribute)
       end
     end
 
@@ -20,29 +20,29 @@ describe BraintreeRails::Customer do
       braintree_customer = Braintree::Customer.find('customer_id')
       customer = BraintreeRails::Customer.new(braintree_customer)
 
-      customer.persisted?.must_equal true
+      customer.should be_persisted
       BraintreeRails::Customer.attributes.each do |attribute|
-        customer.send(attribute).must_equal braintree_customer.send(attribute) if braintree_customer.respond_to?(attribute)
+        customer.send(attribute).should == braintree_customer.send(attribute) if braintree_customer.respond_to?(attribute)
       end
     end
 
     it 'should extract values from hash' do
       customer = BraintreeRails::Customer.new(:id => 'new_id')
 
-      customer.persisted?.must_equal false
-      customer.id.must_equal 'new_id'
+      customer.should_not be_persisted
+      customer.id.should == 'new_id'
     end
 
     it 'should try to extract value from other types' do
       customer = BraintreeRails::Customer.new(OpenStruct.new(:id => 'foobar', :first_name => 'Foo', :last_name => 'Bar', :persisted? => true))
 
-      customer.persisted?.must_equal true
-      customer.id.must_equal 'foobar'
-      customer.first_name.must_equal 'Foo'
-      customer.last_name.must_equal 'Bar'
+      customer.should be_persisted
+      customer.id.should == 'foobar'
+      customer.first_name.should == 'Foo'
+      customer.last_name.should == 'Bar'
 
       customer = BraintreeRails::Customer.new(OpenStruct.new)
-      customer.persisted?.must_equal false
+      customer.should_not be_persisted
     end
   end
 
@@ -51,8 +51,8 @@ describe BraintreeRails::Customer do
       braintree_customer = Braintree::Customer.find('customer_id')
       customer = BraintreeRails::Customer.new(braintree_customer)
 
-      customer.addresses.must_be_kind_of(Enumerable)
-      customer.addresses.size.must_equal braintree_customer.addresses.size
+      customer.addresses.should respond_to(:each)
+      customer.addresses.size.should == braintree_customer.addresses.size
     end
   end
 
@@ -61,19 +61,19 @@ describe BraintreeRails::Customer do
       braintree_customer = Braintree::Customer.find('customer_id')
       customer = BraintreeRails::Customer.new(braintree_customer)
 
-      customer.credit_cards.must_be_kind_of(Enumerable)
-      customer.credit_cards.size.must_equal braintree_customer.credit_cards.size
+      customer.credit_cards.should respond_to(:each)
+      customer.credit_cards.size.should == braintree_customer.credit_cards.size
     end
   end
 
   describe '#full_name' do
     it 'should combine first_name and last_name to form full_name' do
-      BraintreeRails::Customer.new(:first_name => "Foo", :last_name => 'Bar').full_name.must_equal "Foo Bar"
+      BraintreeRails::Customer.new(:first_name => "Foo", :last_name => 'Bar').full_name.should == "Foo Bar"
     end
 
     it 'should not have extra spaces when first_name or last_name is missing' do
-      BraintreeRails::Customer.new(:first_name => "Foo").full_name.must_equal 'Foo'
-      BraintreeRails::Customer.new(:last_name => 'Bar').full_name.must_equal 'Bar'
+      BraintreeRails::Customer.new(:first_name => "Foo").full_name.should == 'Foo'
+      BraintreeRails::Customer.new(:last_name => 'Bar').full_name.should == 'Bar'
     end
   end
 
@@ -81,58 +81,58 @@ describe BraintreeRails::Customer do
     it 'should validate id' do
       customer = BraintreeRails::Customer.new(:id => '%')
       customer.valid?
-      customer.errors[:id].wont_be :blank?
+      customer.errors[:id].should_not be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'all')
       customer.valid?
-      customer.errors[:id].wont_be :blank?
+      customer.errors[:id].should_not be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'new')
       customer.valid?
-      customer.errors[:id].wont_be :blank?
+      customer.errors[:id].should_not be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'f' * 37)
       customer.valid?
-      customer.errors[:id].wont_be :blank?
+      customer.errors[:id].should_not be_blank
 
       customer = BraintreeRails::Customer.new
       customer.valid?
-      customer.errors[:id].must_be :blank?
+      customer.errors[:id].should be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'f')
       customer.valid?
-      customer.errors[:id].must_be :blank?
+      customer.errors[:id].should be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'f' * 36)
       customer.valid?
-      customer.errors[:id].must_be :blank?
+      customer.errors[:id].should be_blank
     end
 
     [:first_name, :last_name, :company, :website, :phone, :fax].each do |attribute|
       it "should validate length of #{attribute}" do
         customer = BraintreeRails::Customer.new(attribute => 'f')
         customer.valid?
-        customer.errors[attribute].must_be :blank?
+        customer.errors[attribute].should be_blank
 
         customer = BraintreeRails::Customer.new(attribute => 'f' * 255)
         customer.valid?
-        customer.errors[attribute].must_be :blank?
+        customer.errors[attribute].should be_blank
 
         customer = BraintreeRails::Customer.new(attribute => 'foo' * 256)
         customer.valid?
-        customer.errors[attribute].wont_be :blank?
+        customer.errors[attribute].should_not be_blank
       end
     end
 
     describe 'credit_card' do
       it 'is valid if new credit card is valid' do
         customer = BraintreeRails::Customer.new(:credit_card => credit_card_hash)
-        customer.valid?.must_equal true
+        customer.should be_valid
       end
 
       it 'is not valid if new credit card is invalid' do
         customer = BraintreeRails::Customer.new(:credit_card => credit_card_hash.except(:number))
-        customer.valid?.must_equal false
+        customer.should_not be_valid
       end
     end
   end
@@ -146,65 +146,65 @@ describe BraintreeRails::Customer do
     describe 'save, save!' do
       it 'should return true when saved' do
         customer = BraintreeRails::Customer.new
-        customer.save.must_equal true
-        customer.persisted?.must_equal true
+        customer.save.should be_true
+        customer.should be_persisted
       end
 
       it 'should not throw error when not valid' do
         customer = BraintreeRails::Customer.new(:first_name => 'f' * 256)
-        customer.save.must_equal false
-        customer.persisted?.must_equal false
+        customer.save.should be_false
+        customer.should_not be_persisted
       end
 
       it 'should return true when saved with bang' do
         customer = BraintreeRails::Customer.new
-        customer.save!.must_equal true
-        customer.persisted?.must_equal true
+        customer.save!.should be_true
+        customer.should be_persisted
       end
 
       it 'should throw error when save invalid record with bang' do
         customer = BraintreeRails::Customer.new(:first_name => 'f' * 256)
-        lambda{ customer.save! }.must_raise(BraintreeRails::RecordInvalid)
-        customer.persisted?.must_equal false
+        expect { customer.save! }.to raise_error(BraintreeRails::RecordInvalid)
+        customer.should_not be_persisted
       end
     end
 
     describe 'update_attributes, update_attributes!' do
       it 'should return true when update_attributes' do
         customer = BraintreeRails::Customer.new(Braintree::Customer.find('customer_id'))
-        customer.update_attributes(:first_name => 'f').must_equal true
+        customer.update_attributes(:first_name => 'f').should be_true
       end
 
       it 'should not throw error when not valid' do
         customer = BraintreeRails::Customer.new(Braintree::Customer.find('customer_id'))
-        customer.update_attributes(:first_name => 'f' * 256).must_equal false
+        customer.update_attributes(:first_name => 'f' * 256).should be_false
       end
 
       it 'should return true when update_attributesd with bang' do
         customer = BraintreeRails::Customer.new(Braintree::Customer.find('customer_id'))
-        customer.update_attributes!(:first_name => 'f').must_equal true
+        customer.update_attributes!(:first_name => 'f').should be_true
       end
 
       it 'should throw error when update_attributes invalid record with bang' do
         customer = BraintreeRails::Customer.new(Braintree::Customer.find('customer_id'))
-        lambda{ customer.update_attributes!(:first_name => 'f' * 256) }.must_raise(BraintreeRails::RecordInvalid)
+        expect { customer.update_attributes!(:first_name => 'f' * 256) }.to raise_error(BraintreeRails::RecordInvalid)
       end
     end
 
     describe 'serialization' do
       it 'can be serializable hash' do
         customer = BraintreeRails::Customer.new('customer_id')
-        customer.serializable_hash.must_be_kind_of Hash
+        customer.serializable_hash.should be_kind_of(Hash)
       end
 
       it 'can be serialized to xml' do
         customer = BraintreeRails::Customer.new('customer_id')
-        customer.to_xml.must_include "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        customer.to_xml.should include "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
       end
 
       it 'can be serialized to json' do
         customer = BraintreeRails::Customer.new('customer_id')
-        customer.as_json.must_be_kind_of Hash
+        customer.as_json.should be_kind_of(Hash)
       end
     end
   end

data/{test/unit/braintree_rails/discount_test.rb → spec/unit/braintree_rails/discount_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::Discount do
   before do
@@ -10,10 +10,10 @@ describe BraintreeRails::Discount do
       braintree_discount = Braintree::Discount.all.find { |d| d.id == 'discount_id' }
       discount = BraintreeRails::Discount.new(braintree_discount)
 
-      discount.persisted?.must_equal true
-      discount.never_expires?.must_equal braintree_discount.never_expires?
+      discount.should be_persisted
+      discount.never_expires?.should == braintree_discount.never_expires?
       BraintreeRails::Discount.attributes.each do |attribute|
-        discount.send(attribute).must_equal braintree_discount.send(attribute)
+        discount.send(attribute).should == braintree_discount.send(attribute)
       end
     end
 
@@ -21,9 +21,9 @@ describe BraintreeRails::Discount do
       braintree_discount = Braintree::Discount.all.find { |d| d.id == 'discount_id' }
       discount = BraintreeRails::Discount.new('discount_id')
 
-      discount.persisted?.must_equal true
+      discount.should be_persisted
       BraintreeRails::Discount.attributes.each do |attribute|
-        discount.send(attribute).must_equal braintree_discount.send(attribute)
+        discount.send(attribute).should == braintree_discount.send(attribute)
       end
     end
 
@@ -31,9 +31,9 @@ describe BraintreeRails::Discount do
       braintree_discount = Braintree::Discount.all.find { |d| d.id == 'discount_id' }
       discount = BraintreeRails::Discount.find('discount_id')
 
-      discount.persisted?.must_equal true
+      discount.should be_persisted
       BraintreeRails::Discount.attributes.each do |attribute|
-        discount.send(attribute).must_equal braintree_discount.send(attribute)
+        discount.send(attribute).should == braintree_discount.send(attribute)
       end
     end
   end
@@ -43,8 +43,8 @@ describe BraintreeRails::Discount do
       braintree_discounts = Braintree::Discount.all
       discounts = BraintreeRails::Discount.all
 
-      discounts.must_be_kind_of(Enumerable)
-      discounts.size.must_equal braintree_discounts.size
+      discounts.should respond_to(:each)
+      discounts.size.should == braintree_discounts.size
     end
   end
 end

data/{test/unit/braintree_rails/discounts_test.rb → spec/unit/braintree_rails/discounts_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::Discounts do
   before do
@@ -11,12 +11,12 @@ describe BraintreeRails::Discounts do
       braintree_discounts = braintree_plan.discounts
       discounts = BraintreeRails::Discounts.new(BraintreeRails::Plan.find('plan_id'))
 
-      discounts.size.must_equal braintree_discounts.size
+      discounts.size.should == braintree_discounts.size
 
       braintree_discounts.each do |braintree_discount|
         discount = discounts.find(braintree_discount.id)
         BraintreeRails::Discount.attributes.each do |attribute|
-          discount.send(attribute).must_equal braintree_discount.send(attribute)
+          discount.send(attribute).should == braintree_discount.send(attribute)
         end
       end
     end
@@ -27,7 +27,7 @@ describe BraintreeRails::Discounts do
       braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
       braintree_discounts = braintree_plan.discounts
       discounts = BraintreeRails::Discounts.new(BraintreeRails::Plan.find('plan_id'))
-      lambda { discounts.create }.must_raise BraintreeRails::NotSupportedApiException
+      expect { discounts.create }.to raise_error(BraintreeRails::NotSupportedApiException)
     end
   end
 end

data/spec/unit/braintree_rails/funding_details_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
+
+describe BraintreeRails::FundingDetails do
+  describe 'validations' do
+    it "requries destination" do
+      funding = BraintreeRails::FundingDetails.new(funding_details_hash.merge(:destination => nil))
+      funding.should be_invalid
+      funding.errors[:destination].should == ["can't be blank", "is not included in the list"]
+    end
+
+    it "cannot be trash destination" do
+      funding = BraintreeRails::FundingDetails.new(funding_details_hash.merge(:destination => "foo"))
+      funding.should be_invalid
+      funding.errors[:destination].should == ["is not included in the list"]
+    end
+
+    it "requries email if destination is Email" do
+      funding = BraintreeRails::FundingDetails.new(funding_details_hash.merge(:destination => Braintree::MerchantAccount::FundingDestination::Email, :email => nil))
+      funding.should be_invalid
+      funding.errors[:email].should == ["can't be blank"]
+    end
+
+    it "requries mobile_phone if destination is MobilePhone" do
+      funding = BraintreeRails::FundingDetails.new(funding_details_hash.merge(:destination => Braintree::MerchantAccount::FundingDestination::MobilePhone, :mobile_phone => nil))
+      funding.should be_invalid
+      funding.errors[:mobile_phone].should == ["can't be blank"]
+    end
+
+    it "requries account_number and routing_number if destination is Bank" do
+      funding = BraintreeRails::FundingDetails.new(funding_details_hash.merge(:destination => Braintree::MerchantAccount::FundingDestination::Bank, :account_number => nil, :routing_number => nil))
+      funding.should be_invalid
+      funding.errors[:account_number].should == ["can't be blank"]
+      funding.errors[:routing_number].should == ["can't be blank"]
+    end
+  end
+end

data/spec/unit/braintree_rails/individual_details_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
+
+describe BraintreeRails::IndividualDetails do
+  describe 'validations' do
+    [:first_name, :last_name, :email, :date_of_birth, :address].each do |attribute|
+      it "requires #{attribute}" do
+        individual = BraintreeRails::IndividualDetails.new(individual_details_hash.merge(attribute => nil))
+        individual.should be_invalid
+        individual.errors[attribute].should == ["can't be blank"]
+      end
+    end
+
+    it "validates assocaited address" do
+      individual = BraintreeRails::IndividualDetails.new(individual_details_hash.merge(:address => {}))
+      individual.should be_invalid
+      individual.errors[:address].should_not be_empty
+    end
+  end
+end

data/{test/unit/braintree_rails/luhn_10_validator_test.rb → spec/unit/braintree_rails/luhn_10_validator_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::Luhn10Validator do
   class Validatable < Struct.new(:number)
@@ -8,16 +8,16 @@ describe BraintreeRails::Luhn10Validator do
 
   describe 'valid numbers' do
     it 'should pass for valid numbers' do
-      Validatable.new(4111111111111111).must_be :valid?
-      Validatable.new('5454545454545454').must_be :valid?
+      Validatable.new(4111111111111111).should be_valid
+      Validatable.new('5454545454545454').should be_valid
     end
   end
 
   describe 'invalid numbers' do
     it 'should fail for invalid numbers' do
       invalid_record = Validatable.new('1234567890123456')
-      invalid_record.wont_be :valid?
-      invalid_record.errors[:number].must_include 'failed Luhn 10 validation'
+      invalid_record.should_not be_valid
+      invalid_record.errors[:number].should include 'failed Luhn 10 validation'
     end
   end
 end