braintree-rails 1.3.0 → 1.4.0

data/spec/unit/braintree_rails/credit_cards_spec.rb

@@ -11,14 +11,14 @@ describe BraintreeRails::CreditCards do
       braintree_credit_cards = braintree_customer.credit_cards
       credit_cards = BraintreeRails::CreditCards.new(BraintreeRails::Customer.find('customer_id'))
 
-      credit_cards.size.should == braintree_credit_cards.size
+      expect(credit_cards.size).to eq(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|
           next if BraintreeRails::CreditCard.associations.include?(attribute)
           if braintree_credit_card.respond_to?(attribute)
-            credit_card.send(attribute).should == braintree_credit_card.send(attribute)
+            expect(credit_card.send(attribute)).to eq(braintree_credit_card.send(attribute))
           end
         end
       end
@@ -33,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.should_not be_persisted
-      credit_card.customer_id.should == braintree_customer.id
-      credit_card.cardholder_name.should == 'foo bar'
+      expect(credit_card).to_not be_persisted
+      expect(credit_card.customer_id).to eq(braintree_customer.id)
+      expect(credit_card.cardholder_name).to eq('foo bar')
     end
   end
 
@@ -45,19 +45,19 @@ describe BraintreeRails::CreditCards do
 
       customer = BraintreeRails::Customer.find('customer_id')
       credit_card = customer.credit_cards.create(credit_card_hash)
-      credit_card.should be_persisted
-      customer.credit_cards.should include(credit_card)
+      expect(credit_card).to be_persisted
+      expect(customer.credit_cards).to 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
+      expect(customer.credit_cards.size).to eq(2)
 
       credit_card = customer.credit_cards.create(credit_card_hash)
-      credit_card.should_not be_persisted
-      customer.credit_cards.size.should == 2
+      expect(credit_card).to_not be_persisted
+      expect(customer.credit_cards.size).to eq(2)
     end
   end
-end
+end

data/spec/unit/braintree_rails/customer_spec.rb

@@ -10,9 +10,9 @@ describe BraintreeRails::Customer do
       customer = BraintreeRails::Customer.new('customer_id')
       braintree_customer = Braintree::Customer.find('customer_id')
 
-      customer.should be_persisted
+      expect(customer).to be_persisted
       BraintreeRails::Customer.attributes.each do |attribute|
-        customer.send(attribute).should == braintree_customer.send(attribute) if braintree_customer.respond_to?(attribute)
+        expect(customer.send(attribute)).to eq(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.should be_persisted
+      expect(customer).to be_persisted
       BraintreeRails::Customer.attributes.each do |attribute|
-        customer.send(attribute).should == braintree_customer.send(attribute) if braintree_customer.respond_to?(attribute)
+        expect(customer.send(attribute)).to eq(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.should_not be_persisted
-      customer.id.should == 'new_id'
+      expect(customer).to_not be_persisted
+      expect(customer.id).to eq('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.should be_persisted
-      customer.id.should == 'foobar'
-      customer.first_name.should == 'Foo'
-      customer.last_name.should == 'Bar'
+      expect(customer).to be_persisted
+      expect(customer.id).to eq('foobar')
+      expect(customer.first_name).to eq('Foo')
+      expect(customer.last_name).to eq('Bar')
 
       customer = BraintreeRails::Customer.new(OpenStruct.new)
-      customer.should_not be_persisted
+      expect(customer).to_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.should respond_to(:each)
-      customer.addresses.size.should == braintree_customer.addresses.size
+      expect(customer.addresses).to respond_to(:each)
+      expect(customer.addresses.size).to eq(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.should respond_to(:each)
-      customer.credit_cards.size.should == braintree_customer.credit_cards.size
+      expect(customer.credit_cards).to respond_to(:each)
+      expect(customer.credit_cards.size).to eq(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.should == "Foo Bar"
+      expect(BraintreeRails::Customer.new(:first_name => "Foo", :last_name => 'Bar').full_name).to eq("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.should == 'Foo'
-      BraintreeRails::Customer.new(:last_name => 'Bar').full_name.should == 'Bar'
+      expect(BraintreeRails::Customer.new(:first_name => "Foo").full_name).to eq('Foo')
+      expect(BraintreeRails::Customer.new(:last_name => 'Bar').full_name).to eq('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].should_not be_blank
+      expect(customer.errors[:id]).to_not be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'all')
       customer.valid?
-      customer.errors[:id].should_not be_blank
+      expect(customer.errors[:id]).to_not be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'new')
       customer.valid?
-      customer.errors[:id].should_not be_blank
+      expect(customer.errors[:id]).to_not be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'f' * 37)
       customer.valid?
-      customer.errors[:id].should_not be_blank
+      expect(customer.errors[:id]).to_not be_blank
 
       customer = BraintreeRails::Customer.new
       customer.valid?
-      customer.errors[:id].should be_blank
+      expect(customer.errors[:id]).to be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'f')
       customer.valid?
-      customer.errors[:id].should be_blank
+      expect(customer.errors[:id]).to be_blank
 
       customer = BraintreeRails::Customer.new(:id => 'f' * 36)
       customer.valid?
-      customer.errors[:id].should be_blank
+      expect(customer.errors[:id]).to 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].should be_blank
+        expect(customer.errors[attribute]).to be_blank
 
         customer = BraintreeRails::Customer.new(attribute => 'f' * 255)
         customer.valid?
-        customer.errors[attribute].should be_blank
+        expect(customer.errors[attribute]).to be_blank
 
         customer = BraintreeRails::Customer.new(attribute => 'foo' * 256)
         customer.valid?
-        customer.errors[attribute].should_not be_blank
+        expect(customer.errors[attribute]).to_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.should be_valid
+        expect(customer).to 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.should_not be_valid
+        expect(customer).to_not be_valid
       end
     end
   end
@@ -146,43 +146,43 @@ describe BraintreeRails::Customer do
     describe 'save, save!' do
       it 'should return true when saved' do
         customer = BraintreeRails::Customer.new
-        customer.save.should be_true
-        customer.should be_persisted
+        expect(customer.save).to eq(true)
+        expect(customer).to be_persisted
       end
 
       it 'should not throw error when not valid' do
         customer = BraintreeRails::Customer.new(:first_name => 'f' * 256)
-        customer.save.should be_false
-        customer.should_not be_persisted
+        expect(customer.save).to eq(false)
+        expect(customer).to_not be_persisted
       end
 
       it 'should return true when saved with bang' do
         customer = BraintreeRails::Customer.new
-        customer.save!.should be_true
-        customer.should be_persisted
+        expect(customer.save!).to eq(true)
+        expect(customer).to be_persisted
       end
 
       it 'should throw error when save invalid record with bang' do
         customer = BraintreeRails::Customer.new(:first_name => 'f' * 256)
         expect { customer.save! }.to raise_error(BraintreeRails::RecordInvalid)
-        customer.should_not be_persisted
+        expect(customer).to_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').should be_true
+        expect(customer.update_attributes(:first_name => 'f')).to eq(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).should be_false
+        expect(customer.update_attributes(:first_name => 'f' * 256)).to eq(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').should be_true
+        expect(customer.update_attributes!(:first_name => 'f')).to eq(true)
       end
 
       it 'should throw error when update_attributes invalid record with bang' do
@@ -194,18 +194,18 @@ describe BraintreeRails::Customer do
     describe 'serialization' do
       it 'can be serializable hash' do
         customer = BraintreeRails::Customer.new('customer_id')
-        customer.serializable_hash.should be_kind_of(Hash)
+        expect(customer.serializable_hash).to be_kind_of(Hash)
       end
 
       it 'can be serialized to xml' do
         customer = BraintreeRails::Customer.new('customer_id')
-        customer.to_xml.should include "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        expect(customer.to_xml).to 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.should be_kind_of(Hash)
+        expect(customer.as_json).to be_kind_of(Hash)
       end
     end
   end
-end
+end

data/spec/unit/braintree_rails/discount_spec.rb

@@ -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.should be_persisted
-      discount.never_expires?.should == braintree_discount.never_expires?
+      expect(discount).to be_persisted
+      expect(discount.never_expires?).to eq(braintree_discount.never_expires?)
       BraintreeRails::Discount.attributes.each do |attribute|
-        discount.send(attribute).should == braintree_discount.send(attribute)
+        expect(discount.send(attribute)).to eq(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.should be_persisted
+      expect(discount).to be_persisted
       BraintreeRails::Discount.attributes.each do |attribute|
-        discount.send(attribute).should == braintree_discount.send(attribute)
+        expect(discount.send(attribute)).to eq(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.should be_persisted
+      expect(discount).to be_persisted
       BraintreeRails::Discount.attributes.each do |attribute|
-        discount.send(attribute).should == braintree_discount.send(attribute)
+        expect(discount.send(attribute)).to eq(braintree_discount.send(attribute))
       end
     end
   end
@@ -43,9 +43,8 @@ describe BraintreeRails::Discount do
       braintree_discounts = Braintree::Discount.all
       discounts = BraintreeRails::Discount.all
 
-      discounts.should respond_to(:each)
-      discounts.size.should == braintree_discounts.size
+      expect(discounts).to respond_to(:each)
+      expect(discounts.size).to eq(braintree_discounts.size)
     end
   end
-end
-
+end

data/spec/unit/braintree_rails/discounts_spec.rb

@@ -11,12 +11,12 @@ describe BraintreeRails::Discounts do
       braintree_discounts = braintree_plan.discounts
       discounts = BraintreeRails::Discounts.new(BraintreeRails::Plan.find('plan_id'))
 
-      discounts.size.should == braintree_discounts.size
+      expect(discounts.size).to eq(braintree_discounts.size)
 
       braintree_discounts.each do |braintree_discount|
         discount = discounts.find(braintree_discount.id)
         BraintreeRails::Discount.attributes.each do |attribute|
-          discount.send(attribute).should == braintree_discount.send(attribute)
+          expect(discount.send(attribute)).to eq(braintree_discount.send(attribute))
         end
       end
     end
@@ -30,4 +30,4 @@ describe BraintreeRails::Discounts do
       expect { discounts.create }.to raise_error(BraintreeRails::NotSupportedApiException)
     end
   end
-end
+end

data/spec/unit/braintree_rails/funding_details_spec.rb

@@ -4,33 +4,33 @@ 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"]
+      expect(funding).to be_invalid
+      expect(funding.errors[:destination]).to eq(["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"]
+      expect(funding).to be_invalid
+      expect(funding.errors[:destination]).to eq(["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"]
+      expect(funding).to be_invalid
+      expect(funding.errors[:email]).to eq(["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"]
+      expect(funding).to be_invalid
+      expect(funding.errors[:mobile_phone]).to eq(["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"]
+      expect(funding).to be_invalid
+      expect(funding.errors[:account_number]).to eq(["can't be blank"])
+      expect(funding.errors[:routing_number]).to eq(["can't be blank"])
     end
   end
-end
+end

data/spec/unit/braintree_rails/individual_details_spec.rb

@@ -5,15 +5,15 @@ describe BraintreeRails::IndividualDetails 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"]
+        expect(individual).to be_invalid
+        expect(individual.errors[attribute]).to eq(["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
+      expect(individual).to be_invalid
+      expect(individual.errors[:address]).to_not be_empty
     end
   end
-end
+end

data/spec/unit/braintree_rails/luhn_10_validator_spec.rb

@@ -8,16 +8,16 @@ describe BraintreeRails::Luhn10Validator do
 
   describe 'valid numbers' do
     it 'should pass for valid numbers' do
-      Validatable.new(4111111111111111).should be_valid
-      Validatable.new('5454545454545454').should be_valid
+      expect(Validatable.new(4111111111111111)).to be_valid
+      expect(Validatable.new('5454545454545454')).to be_valid
     end
   end
 
   describe 'invalid numbers' do
     it 'should fail for invalid numbers' do
       invalid_record = Validatable.new('1234567890123456')
-      invalid_record.should_not be_valid
-      invalid_record.errors[:number].should include 'failed Luhn 10 validation'
+      expect(invalid_record).to_not be_valid
+      expect(invalid_record.errors[:number]).to include 'failed Luhn 10 validation'
     end
   end
-end
+end

data/spec/unit/braintree_rails/merchant_account_spec.rb

@@ -5,46 +5,46 @@ describe BraintreeRails::MerchantAccount 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"]
+        expect(merchant_account).to be_invalid
+        expect(merchant_account.errors[attribute]).to eq(["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
+        expect(merchant_account).to 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"]
+        expect(merchant_account).to be_invalid
+        expect(merchant_account.errors[:id]).to eq(["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)"]
+      expect(merchant_account).to be_invalid
+      expect(merchant_account.errors[:id]).to eq(["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
+      expect(merchant_account).to be_invalid
+      expect(merchant_account.errors[:individual]).to_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
+      expect(merchant_account).to be_invalid
+      expect(merchant_account.errors[:funding]).to_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
+      expect(merchant_account).to be_invalid
+      expect(merchant_account.errors[:business]).to_not be_empty
     end
   end
-end
+end