braintree-rails 1.2.3 → 1.3.0

data/{test/unit/braintree_rails/addresses_test.rb → spec/unit/braintree_rails/addresses_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::Addresses do
   before do
@@ -11,12 +11,12 @@ describe BraintreeRails::Addresses do
       braintree_addresses = braintree_customer.addresses
       addresses = BraintreeRails::Addresses.new(BraintreeRails::Customer.find('customer_id'))
 
-      addresses.size.must_equal braintree_addresses.size
+      addresses.size.should == braintree_addresses.size
 
       braintree_addresses.each do |braintree_address|
         address = addresses.find(braintree_address.id)
         BraintreeRails::Address.attributes.each do |attribute|
-          address.send(attribute).must_equal braintree_address.send(attribute)
+          address.send(attribute).should == braintree_address.send(attribute)
         end
       end
     end
@@ -29,10 +29,10 @@ describe BraintreeRails::Addresses do
       addresses = BraintreeRails::Addresses.new(BraintreeRails::Customer.find('customer_id'))
       address = addresses.build({:first_name => 'foo', :last_name => 'bar'})
 
-      address.persisted?.must_equal false
-      address.customer_id.must_equal braintree_customer.id
-      address.first_name.must_equal 'foo'
-      address.last_name.must_equal 'bar'
+      address.should_not be_persisted
+      address.customer_id.should == braintree_customer.id
+      address.first_name.should == 'foo'
+      address.last_name.should == 'bar'
     end
   end
 end

data/spec/unit/braintree_rails/business_details_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'))
+
+describe BraintreeRails::BusinessDetails do
+  describe 'validations' do
+    it "requries legal_name if tax_id is present" do
+      business = BraintreeRails::BusinessDetails.new(business_details_hash.merge(:legal_name => nil))
+      business.should be_invalid
+      business.errors[:legal_name].should == ["can't be blank"]
+    end
+
+    it "requries tax_id if legal_name is present" do
+      business = BraintreeRails::BusinessDetails.new(business_details_hash.merge(:tax_id => nil))
+      business.should be_invalid
+      business.errors[:tax_id].should == ["can't be blank"]
+    end
+
+    it "does not requrie either if neither are present" do
+      business = BraintreeRails::BusinessDetails.new({})
+      business.should be_valid
+    end
+
+    it "validates assocaited address" do
+      business = BraintreeRails::BusinessDetails.new(address_details_hash.merge(:address => {}))
+      business.should be_invalid
+      business.errors[:address].should_not be_empty
+    end
+  end
+end

data/{test/unit/braintree_rails/configuration_test.rb → spec/unit/braintree_rails/configuration_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::Configuration do
   [:merchant_id, :public_key, :private_key, :logger].each do |config|
@@ -6,8 +6,8 @@ describe BraintreeRails::Configuration do
       begin
         old_value = Braintree::Configuration.send(config)
         BraintreeRails::Configuration.send("#{config}=", "foo")
-        Braintree::Configuration.send(config).must_equal "foo"
-        BraintreeRails::Configuration.send(config).must_equal "foo"
+        Braintree::Configuration.send(config).should == "foo"
+        BraintreeRails::Configuration.send(config).should == "foo"
       ensure
         BraintreeRails::Configuration.send("#{config}=", old_value)
       end
@@ -16,11 +16,11 @@ describe BraintreeRails::Configuration do
 
   it "should delegate environment to Braintree::Configuration" do
     BraintreeRails::Configuration.environment = :sandbox
-    Braintree::Configuration.environment.must_equal :sandbox
-    BraintreeRails::Configuration.environment.must_equal :sandbox
+    Braintree::Configuration.environment.should == :sandbox
+    BraintreeRails::Configuration.environment.should == :sandbox
   end
 
   it "should set custom_user_agent to braintree-rails-#{BraintreeRails::Version}" do
-    Braintree::Configuration.instantiate.user_agent.must_include "braintree-rails-#{BraintreeRails::Version}"
+    Braintree::Configuration.instantiate.user_agent.should include "braintree-rails-#{BraintreeRails::Version}"
   end
 end

data/{test/unit/braintree_rails/credit_card_test.rb → spec/unit/braintree_rails/credit_card_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::CreditCard do
   before do
@@ -10,12 +10,15 @@ describe BraintreeRails::CreditCard do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
 
-      credit_card.persisted?.must_equal true
-      credit_card.default?.must_equal braintree_credit_card.default?
-      credit_card.expired?.must_equal braintree_credit_card.expired?
-      credit_card.masked_number.must_equal braintree_credit_card.masked_number
+      credit_card.should be_persisted
+      credit_card.default?.should == braintree_credit_card.default?
+      credit_card.expired?.should == braintree_credit_card.expired?
+      credit_card.masked_number.should == braintree_credit_card.masked_number
       BraintreeRails::CreditCard.attributes.each do |attribute|
-        braintree_credit_card.send(attribute).must_equal(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)
+          braintree_credit_card.send(attribute).should eq(credit_card.send(attribute))
+        end
       end
     end
 
@@ -23,28 +26,31 @@ describe BraintreeRails::CreditCard do
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
       credit_card = BraintreeRails::CreditCard.new(braintree_credit_card)
 
-      credit_card.persisted?.must_equal true
+      credit_card.should be_persisted
       BraintreeRails::CreditCard.attributes.each do |attribute|
-        braintree_credit_card.send(attribute).must_equal(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)
+          braintree_credit_card.send(attribute).should eq(credit_card.send(attribute))
+        end
       end
     end
 
     it 'should extract values from hash' do
       credit_card = BraintreeRails::CreditCard.new(:token => 'new_id')
 
-      credit_card.persisted?.must_equal false
-      credit_card.token.must_equal 'new_id'
+      credit_card.should_not be_persisted
+      credit_card.token.should == 'new_id'
     end
 
     it 'should try to extract value from other types' do
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new(:token => 'foobar', :cardholder_name => 'Foo Bar', :persisted? => true))
 
-      credit_card.persisted?.must_equal true
-      credit_card.token.must_equal 'foobar'
-      credit_card.cardholder_name.must_equal 'Foo Bar'
+      credit_card.should be_persisted
+      credit_card.token.should == 'foobar'
+      credit_card.cardholder_name.should == 'Foo Bar'
 
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new)
-      credit_card.persisted?.must_equal false
+      credit_card.should_not be_persisted
     end
   end
 
@@ -52,8 +58,8 @@ describe BraintreeRails::CreditCard do
     it 'should load customer for persisted credit_card' do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       stub_braintree_request(:get, '/customers/customer_id', :body => fixture('customer.xml'))
-      credit_card.customer.persisted?.must_equal true
-      credit_card.customer.id.must_equal 'customer_id'
+      credit_card.customer.should be_persisted
+      credit_card.customer.id.should == 'customer_id'
     end
   end
 
@@ -62,29 +68,29 @@ describe BraintreeRails::CreditCard do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
 
-      credit_card.subscriptions.must_be_kind_of(Enumerable)
-      credit_card.subscriptions.size.must_equal braintree_credit_card.subscriptions.size
+      credit_card.subscriptions.should respond_to(:each)
+      credit_card.subscriptions.size.should == braintree_credit_card.subscriptions.size
     end
 
     it 'can build new subscription' do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       subscription = credit_card.subscriptions.build
-      subscription.payment_method_token.must_equal credit_card.token
+      subscription.payment_method_token.should == credit_card.token
     end
   end
 
   describe '#billing_address' do
     it 'should wrap billing_address with Address object' do
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new(:billing_address => {}))
-      credit_card.billing_address.class.ancestors.must_include BraintreeRails::Address
+      credit_card.billing_address.class.ancestors.should include BraintreeRails::Address
 
       credit_card.billing_address = BraintreeRails::Address.new
-      credit_card.billing_address.class.ancestors.must_include BraintreeRails::Address
+      credit_card.billing_address.class.ancestors.should include(BraintreeRails::Address)
     end
 
     it 'should keep billing_address nil if assigned nil value' do
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new(:billing_address => nil))
-      credit_card.billing_address.class.must_equal NilClass
+      credit_card.billing_address.should be_nil
     end
 
   end
@@ -93,48 +99,48 @@ describe BraintreeRails::CreditCard do
     it 'should validate precence of customer_id on create' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].wont_be :blank?
+      credit_card.errors[:customer_id].should_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo')
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].must_be :blank?
+      credit_card.errors[:customer_id].should be_blank
     end
 
     it 'should validate length of customer_id' do
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo' * 13)
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].wont_be :blank?
+      credit_card.errors[:customer_id].should_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo')
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].must_be :blank?
+      credit_card.errors[:customer_id].should be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo' * 12)
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].must_be :blank?
+      credit_card.errors[:customer_id].should be_blank
     end
 
     it 'should validate precence of number if new_record?' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:number].wont_be :blank?
+      credit_card.errors[:number].should_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:number => '4111111111111111')
       credit_card.valid?
-      credit_card.errors[:number].must_be :blank?
+      credit_card.errors[:number].should be_blank
 
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
-      credit_card.valid?.must_equal true
+      credit_card.should be_valid
     end
 
     it 'should validate precence of cvv' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:cvv].wont_be :blank?
+      credit_card.errors[:cvv].should_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:cvv => '111')
       credit_card.valid?
-      credit_card.errors[:cvv].must_be :blank?
+      credit_card.errors[:cvv].should be_blank
     end
 
     describe 'S2S mode' do
@@ -149,101 +155,101 @@ describe BraintreeRails::CreditCard do
       it 'should validate numericality of number' do
         credit_card = BraintreeRails::CreditCard.new(:number => 'foobar')
         credit_card.valid?
-        credit_card.errors[:number].wont_be :blank?
+        credit_card.errors[:number].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '4111111111111111')
         credit_card.valid?
-        credit_card.errors[:number].must_be :blank?
+        credit_card.errors[:number].should be_blank
       end
 
       it 'should validate length of number' do
         credit_card = BraintreeRails::CreditCard.new(:number => '1')
         credit_card.valid?
-        credit_card.errors[:number].wont_be :blank?
+        credit_card.errors[:number].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '1' * 20)
         credit_card.valid?
-        credit_card.errors[:number].wont_be :blank?
+        credit_card.errors[:number].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '4111111111111111')
         credit_card.valid?
-        credit_card.errors[:number].must_be :blank?
+        credit_card.errors[:number].should be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '6208645006512478950')
         credit_card.valid?
-        credit_card.errors[:number].must_be :blank?
+        credit_card.errors[:number].should be_blank
       end
 
       it 'should validate numericality of cvv' do
         credit_card = BraintreeRails::CreditCard.new(:cvv => 'foo')
         credit_card.valid?
-        credit_card.errors[:cvv].wont_be :blank?
+        credit_card.errors[:cvv].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '111')
         credit_card.valid?
-        credit_card.errors[:cvv].must_be :blank?
+        credit_card.errors[:cvv].should be_blank
       end
 
       it 'should validate length of cvv' do
         credit_card = BraintreeRails::CreditCard.new(:cvv => '1')
         credit_card.valid?
-        credit_card.errors[:cvv].wont_be :blank?
+        credit_card.errors[:cvv].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '1' * 5)
         credit_card.valid?
-        credit_card.errors[:cvv].wont_be :blank?
+        credit_card.errors[:cvv].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '111')
         credit_card.valid?
-        credit_card.errors[:cvv].must_be :blank?
+        credit_card.errors[:cvv].should be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '1111')
         credit_card.valid?
-        credit_card.errors[:cvv].must_be :blank?
+        credit_card.errors[:cvv].should be_blank
       end
 
       it 'should validate expiration month' do
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 0)
         credit_card.valid?
-        credit_card.errors[:expiration_month].wont_be :blank?
+        credit_card.errors[:expiration_month].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 13)
         credit_card.valid?
-        credit_card.errors[:expiration_month].wont_be :blank?
+        credit_card.errors[:expiration_month].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 1.1)
         credit_card.valid?
-        credit_card.errors[:expiration_month].wont_be :blank?
+        credit_card.errors[:expiration_month].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 1)
         credit_card.valid?
-        credit_card.errors[:expiration_month].must_be :blank?
+        credit_card.errors[:expiration_month].should be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => '12')
         credit_card.valid?
-        credit_card.errors[:expiration_month].must_be :blank?
+        credit_card.errors[:expiration_month].should be_blank
       end
 
       it 'should validate expiration year' do
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 1975)
         credit_card.valid?
-        credit_card.errors[:expiration_year].wont_be :blank?
+        credit_card.errors[:expiration_year].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 2201)
         credit_card.valid?
-        credit_card.errors[:expiration_year].wont_be :blank?
+        credit_card.errors[:expiration_year].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 1976.1)
         credit_card.valid?
-        credit_card.errors[:expiration_year].wont_be :blank?
+        credit_card.errors[:expiration_year].should_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 1976)
         credit_card.valid?
-        credit_card.errors[:expiration_year].must_be :blank?
+        credit_card.errors[:expiration_year].should be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => '2200')
         credit_card.valid?
-        credit_card.errors[:expiration_year].must_be :blank?
+        credit_card.errors[:expiration_year].should be_blank
       end
 
     end
@@ -251,38 +257,38 @@ describe BraintreeRails::CreditCard do
     it 'should validate presence of expiration month' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:expiration_month].wont_be :blank?
+      credit_card.errors[:expiration_month].should_not be_blank
     end
 
     it 'should validate presence of expiration year' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:expiration_year].wont_be :blank?
+      credit_card.errors[:expiration_year].should_not be_blank
     end
 
     it 'should validate length of cardholder_name' do
       credit_card = BraintreeRails::CreditCard.new(:cardholder_name => 'f' * 256)
       credit_card.valid?
-      credit_card.errors[:cardholder_name].wont_be :blank?
+      credit_card.errors[:cardholder_name].should_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:cardholder_name => 'f')
       credit_card.valid?
-      credit_card.errors[:cardholder_name].must_be :blank?
+      credit_card.errors[:cardholder_name].should be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:cardholder_name => 'f' * 255)
       credit_card.valid?
-      credit_card.errors[:cardholder_name].must_be :blank?
+      credit_card.errors[:cardholder_name].should be_blank
     end
 
     it 'should validate billing_address' do
       credit_card = BraintreeRails::CreditCard.new(:billing_address => OpenStruct.new(:valid? => false))
       credit_card.valid?
-      credit_card.errors[:billing_address].wont_be :blank?
+      credit_card.errors[:billing_address].should_not be_blank
 
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
       credit_card = BraintreeRails::CreditCard.new(:billing_address => braintree_credit_card.billing_address)
       credit_card.valid?
-      credit_card.errors[:billing_address].must_be :blank?
+      credit_card.errors[:billing_address].should be_blank
     end
   end
 
@@ -291,10 +297,10 @@ describe BraintreeRails::CreditCard do
       stub_braintree_request(:put, '/payment_methods/credit_card_id', :status => 422, :body => fixture('credit_card_validation_error.xml'))
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       credit_card.update_attributes(:number => '4111111111111111', :cvv => '111')
-      credit_card.errors[:number].wont_be :blank?
+      credit_card.errors[:number].should_not be_blank
 
-      credit_card.billing_address.errors[:street_address].wont_be :blank?
-      credit_card.billing_address.errors[:postal_code].wont_be :blank?
+      credit_card.billing_address.errors[:street_address].should_not be_blank
+      credit_card.billing_address.errors[:postal_code].should_not be_blank
     end
 
     it 'should clear encrypted attributes after save' do
@@ -302,22 +308,22 @@ describe BraintreeRails::CreditCard do
       credit_card.number = "foo"
       stub_braintree_request(:put, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
       credit_card.save
-      credit_card.number.must_be :blank?
+      credit_card.number.should be_blank
     end
 
     it 'should clear encrypted attributes even when save! fails' do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
       credit_card.number = "foo"
       stub_braintree_request(:put, '/payment_methods/credit_card_id', :status => 422, :body => fixture('credit_card_validation_error.xml'))
-      lambda {credit_card.save!}.must_raise Braintree::ValidationsFailed
-      credit_card.number.must_be :blank?
+      expect {credit_card.save!}.to raise_error(Braintree::ValidationsFailed)
+      credit_card.number.should be_blank
     end
 
     it 'should clear encrypted attributes' do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
       credit_card.number = "foo"
       credit_card.clear_encryped_attributes
-      credit_card.number.must_be :blank?
+      credit_card.number.should be_blank
     end
 
     it 'should update expiration_date when required' do
@@ -328,20 +334,20 @@ describe BraintreeRails::CreditCard do
         :expiration_date => '02/2020',
       }
       credit_card.assign_attributes(attributes)
-      credit_card.attributes_for(:update)[:expiration_date].must_equal '02/2020'
+      credit_card.attributes_for(:update)[:expiration_date].should == '02/2020'
     end
   end
 
   describe 'class methods' do
     it "should wrap Braintree's Model find" do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
-      credit_card.id.must_equal 'credit_card_id'
-      credit_card.persisted?.must_equal true
+      credit_card.id.should == 'credit_card_id'
+      credit_card.should be_persisted
     end
 
     it "should delegate delete to Braintree's Model" do
       stub_braintree_request(:delete, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
-      BraintreeRails::CreditCard.delete('credit_card_id').must_equal true
+      BraintreeRails::CreditCard.delete('credit_card_id').should be_true
     end
   end
 end