braintree-rails 1.2.3 → 1.3.0

data/lib/braintree_rails/individual_details.rb

@@ -0,0 +1,32 @@
+module BraintreeRails
+  class IndividualDetails
+    include Model
+
+    singleton_class.not_supported_apis(:delete)
+    not_supported_apis(:create, :create!, :update, :update!, :destroy)
+
+    define_attributes(
+      :readonly => [:ssn_last_4],
+      :as_association => [:first_name, :last_name, :email, :phone, :date_of_birth, :ssn, :address]
+    )
+
+    has_one :address, :class_name => "BraintreeRails::AddressDetails"
+
+    def self.braintree_model_name
+      "merchant_account/#{name.demodulize.underscore}"
+    end
+
+    def add_errors(validation_errors)
+      address.add_errors(validation_errors) if address
+      super(validation_errors)
+    end
+
+    def attributes_for(action)
+      super.merge(address_attributes)
+    end
+
+    def address_attributes
+      address.present? ? {:address => address.attributes_for(:as_association)} : {}
+    end
+  end
+end

data/lib/braintree_rails/individual_details_validator.rb

@@ -0,0 +1,11 @@
+module BraintreeRails
+  class IndividualDetailsValidator < Validator
+    Validations = [
+      [:first_name, :last_name, :email, :date_of_birth, :address, :presence => true]
+    ]
+
+    def validate(individual)
+      validate_association(individual, :address)
+    end
+  end
+end

data/lib/braintree_rails/merchant_account.rb

@@ -0,0 +1,45 @@
+module BraintreeRails
+  class MerchantAccount
+    include Model
+
+    # Need to remove the ! methods as those are not provided by the API
+    singleton_class.not_supported_apis(:delete, :create!, :update!)
+    not_supported_apis(:destroy, :create!, :update!)
+
+    define_attributes(
+      :create => [:tos_accepted, :master_merchant_account_id, :id, :individual, :business, :funding],
+      :readonly => [:status, :created_at, :updated_at]
+    )
+
+    belongs_to :master_merchant_account, :class_name => "BraintreeRails::MerchantAccount"
+    has_one :individual, :class_name => "BraintreeRails::IndividualDetails"
+    has_one :business, :class_name => "BraintreeRails::BusinessDetails"
+    has_one :funding, :class_name => "BraintreeRails::FundingDetails"
+
+    # Need to reload to populate association values as there's an inconsistency in the API
+    after_create :reload, :if => :persisted?
+
+    def add_errors(validation_errors)
+      [individual, business, funding].each do |association|
+        association.add_errors(validation_errors.except(:base)) if association
+        super(validation_errors)
+      end
+    end
+
+    def attributes_for(action)
+      super.merge(individual_attributes).merge(business_attributes).merge(funding_attributes)
+    end
+
+    def individual_attributes
+      individual.present? ? {:individual => individual.attributes_for(:as_association)} : {}
+    end
+
+    def business_attributes
+      business.present? ? {:business => business.attributes_for(:as_association)} : {}
+    end
+
+    def funding_attributes
+      funding.present? ? {:funding => funding.attributes_for(:as_association)} : {}
+    end
+  end
+end

data/lib/braintree_rails/merchant_account_validator.rb

@@ -0,0 +1,14 @@
+module BraintreeRails
+  class MerchantAccountValidator < Validator
+    Validations = [
+      [:id, :format => {:with => /\A[-_a-z0-9]*\z/i}, :length => {:maximum => 32}, :exclusion => {:in => %w(all new)}],
+      [:tos_accepted, :master_merchant_account_id, :individual, :funding, :presence => true],
+    ]
+
+    def validate(merchant_account)
+      [:individual, :business, :funding].each do |association_name|
+        validate_association(merchant_account, association_name)
+      end
+    end
+  end
+end

data/lib/braintree_rails/plan.rb

@@ -11,9 +11,9 @@ module BraintreeRails
         :number_of_billing_cycles, :price, :trial_duration, :trial_duration_unit, :trial_period, :updated_at
       ]
     )
-    has_many :add_ons,       :class => AddOns
-    has_many :discounts,     :class => Discounts
-    has_many :subscriptions, :class => Subscriptions
+    has_many :add_ons,       :class_name => "BraintreeRails::AddOns"
+    has_many :discounts,     :class_name => "BraintreeRails::Discounts"
+    has_many :subscriptions, :class_name => "BraintreeRails::Subscriptions"
 
     def self.all
       braintree_model_class.all.map{ |plan| new(plan) }

data/lib/braintree_rails/subscription.rb

@@ -17,11 +17,11 @@ module BraintreeRails
       ]
     )
 
-    has_many   :add_ons,      :class => AddOns
-    has_many   :discounts,    :class => Discounts
-    has_many   :transactions, :class => Transactions
-    belongs_to :plan,         :class => Plan,            :foreign_key => :plan_id
-    belongs_to :credit_card,  :class => CreditCard,      :foreign_key => :payment_method_token
+    has_many   :add_ons,      :class_name => "BraintreeRails::AddOns"
+    has_many   :discounts,    :class_name => "BraintreeRails::Discounts"
+    has_many   :transactions, :class_name => "BraintreeRails::Transactions"
+    belongs_to :plan,         :class_name => "BraintreeRails::Plan",            :foreign_key => :plan_id
+    belongs_to :credit_card,  :class_name => "BraintreeRails::CreditCard",      :foreign_key => :payment_method_token
 
     def self.cancel(id)
       delete(id)

data/lib/braintree_rails/transaction.rb

@@ -8,7 +8,7 @@ module BraintreeRails
       :create => [
         :amount, :billing, :channel, :custom_fields, :customer_id, :descriptor, :merchant_account_id,
         :options, :order_id, :payment_method_token, :purchase_order_number, :recurring, :shipping,
-        :tax_amount, :tax_exempt, :type, :venmo_sdk_payment_method_code
+        :tax_amount, :tax_exempt, :type, :venmo_sdk_payment_method_code, :device_data
       ],
       :readonly => [
         :avs_error_response_code, :avs_postal_code_response_code, :avs_street_address_response_code, :billing_details,
@@ -18,14 +18,14 @@ module BraintreeRails
       ]
     )
 
-    has_many   :add_ons,      :class => AddOns
-    has_many   :discounts,    :class => Discounts
-    has_one    :billing,      :class => BillingAddress,  :foreign_key => :billing_details
-    has_one    :shipping,     :class => ShippingAddress, :foreign_key => :shipping_details
-    belongs_to :customer,     :class => Customer,        :foreign_key => :customer_details
-    belongs_to :credit_card,  :class => CreditCard,      :foreign_key => :credit_card_details
-    belongs_to :subscription, :class => Subscription,    :foreign_key => :subscription_id
-    belongs_to :plan,         :class => Plan,            :foreign_key => :plan_id
+    has_many   :add_ons,      :class_name => "BraintreeRails::AddOns"
+    has_many   :discounts,    :class_name => "BraintreeRails::Discounts"
+    has_one    :billing,      :class_name => "BraintreeRails::BillingAddress",  :foreign_key => :billing_details
+    has_one    :shipping,     :class_name => "BraintreeRails::ShippingAddress", :foreign_key => :shipping_details
+    belongs_to :customer,     :class_name => "BraintreeRails::Customer",        :foreign_key => :customer_details
+    belongs_to :credit_card,  :class_name => "BraintreeRails::CreditCard",      :foreign_key => :credit_card_details
+    belongs_to :subscription, :class_name => "BraintreeRails::Subscription",    :foreign_key => :subscription_id
+    belongs_to :plan,         :class_name => "BraintreeRails::Plan",            :foreign_key => :plan_id
 
     around_persist :clear_encryped_attributes
 

data/lib/braintree_rails/transaction_validator.rb

@@ -37,11 +37,7 @@ module BraintreeRails
 
     def validate_new_credit_card(transaction)
       transaction.credit_card.billing_address = transaction.billing
-      if transaction.credit_card.invalid?
-        transaction.credit_card.errors.full_messages.each do |message|
-          transaction.errors.add(:base, message)
-        end
-      end
+      validate_association(transaction, :credit_card)
     end
   end
 end

data/lib/braintree_rails/validator.rb

@@ -33,5 +33,18 @@ module BraintreeRails
 
     def validate(record)
     end
+
+    def validate_association(record, name)
+      record.instance_eval do
+        association = record.send(name)
+        return unless association.present?
+        if association.invalid?
+          errors.add(name, "is invalid")
+          association.errors.full_messages.each do |message|
+            errors.add(:base, message)
+          end
+        end
+      end
+    end
   end
 end

data/lib/braintree_rails/version.rb

@@ -1,3 +1,3 @@
 module BraintreeRails
-  Version = "1.2.3"
+  Version = "1.3.0"
 end

data/lib/tasks/ci.rake

@@ -0,0 +1,7 @@
+require 'coveralls/rake/task'
+
+namespace :ci do
+  Coveralls::RakeTask.new
+  desc "Run all specs in Travis CI"
+  task :travis => ["spec:all", "coveralls:push"]
+end

data/lib/tasks/spec.rake

@@ -0,0 +1,18 @@
+require 'rspec/core/rake_task'
+
+namespace :spec do
+  desc "Run unit specs"
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = 'spec/unit/**/*_spec.rb'
+    t.verbose = true
+  end
+
+  desc "Run integration specs"
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.pattern = 'spec/integration/**/*_spec.rb'
+    t.verbose = true
+  end
+
+  desc "Run all specs"
+  task :all => [:unit, :integration]
+end

data/lib/test_env.rb

@@ -1,10 +1,4 @@
 require 'simplecov'
-SimpleCov.start do
-  add_filter "/test/"
-end
-
+SimpleCov.start {add_filter '/spec/'}
 require File.join(File.dirname(__FILE__), 'env')
-require 'minitest/autorun'
 require 'braintree-rails'
-require 'turn/autorun'
-require 'active_support/core_ext/date/calculations'

data/spec/fixtures/merchant_account.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<merchant-account>
+  <status>active</status>
+  <id>default_merchant_account_id</id>
+  <currency-iso-code>USD</currency-iso-code>
+  <sub-merchant-account type="boolean">false</sub-merchant-account>
+</merchant-account>

data/{test/integration/braintree_rails/address_integration_test.rb → spec/integration/braintree_rails/address_integration_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../integration_test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../integration_spec_helper'))
 
 describe 'Address Integration' do
   before do
@@ -13,7 +13,7 @@ describe 'Address Integration' do
     braintree_address = braintree_customer.addresses.first
 
     attributes.each do |key, value|
-      braintree_address.send(key).must_equal value
+      braintree_address.send(key).should == value
     end
   end
 
@@ -24,26 +24,26 @@ describe 'Address Integration' do
 
     braintree_customer = Braintree::Customer.find(customer.id)
     braintree_address = braintree_customer.addresses.first
-    braintree_address.first_name.must_equal 'Foo'
+    braintree_address.first_name.should == 'Foo'
 
     address.last_name = 'Bar'
     address.save!
 
     braintree_customer = Braintree::Customer.find(customer.id)
     braintree_address = braintree_customer.addresses.first
-    braintree_address.last_name.must_equal 'Bar'
+    braintree_address.last_name.should == 'Bar'
   end
 
   it 'should be able to destroy existing address' do
     customer = BraintreeRails::Customer.create!(customer_hash)
     address = customer.addresses.create!(address_hash)
     address.destroy
-    lambda{ Braintree::Address.find(customer.id, address.id) }.must_raise Braintree::NotFoundError
-    address.persisted?.must_equal false
-    address.frozen?.must_equal true
+    expect { Braintree::Address.find(customer.id, address.id) }.to raise_error(Braintree::NotFoundError)
+    address.should_not be_persisted
+    address.should be_frozen
 
     address = customer.addresses.create!(address_hash)
     BraintreeRails::Address.delete(customer.id, address.id)
-    lambda{ Braintree::Address.find(customer.id, address.id) }.must_raise Braintree::NotFoundError
+    expect { Braintree::Address.find(customer.id, address.id) }.to raise_error(Braintree::NotFoundError)
   end
 end

data/{test/integration/braintree_rails/credit_card_integration_test.rb → spec/integration/braintree_rails/credit_card_integration_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../integration_test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../integration_spec_helper'))
 
 describe 'Credit Card Integration' do
   before do
@@ -12,11 +12,11 @@ describe 'Credit Card Integration' do
     credit_card = BraintreeRails::CreditCard.new(braintree_customer.credit_cards.first.token)
 
     attributes.except(:number, :cvv, :billing_address).each do |key, value|
-      credit_card.send(key).must_equal value
+      credit_card.send(key).should == value
     end
 
     attributes[:billing_address].each do |key, value|
-      credit_card.billing_address.send(key).must_equal value
+      credit_card.billing_address.send(key).should == value
     end
   end
 
@@ -27,12 +27,12 @@ describe 'Credit Card Integration' do
 
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
     attributes.except(:number, :cvv, :billing_address).each do |key, value|
-      braintree_credit_card.send(key).must_equal value
+      braintree_credit_card.send(key).should == value
     end
 
     braintree_address = braintree_credit_card.billing_address
     attributes[:billing_address].each do |key, value|
-      braintree_address.send(key).must_equal value
+      braintree_address.send(key).should == value
     end
   end
 
@@ -42,8 +42,8 @@ describe 'Credit Card Integration' do
 
     credit_card.update_attributes!(:cardholder_name => 'Foo Bar', :number => '4111111111111111', :options => {:verify_card => true}, :billing_address => address_hash.merge(:postal_code => '56789'))
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
-    braintree_credit_card.cardholder_name.must_equal 'Foo Bar'
-    braintree_credit_card.billing_address.postal_code.must_equal '56789'
+    braintree_credit_card.cardholder_name.should == 'Foo Bar'
+    braintree_credit_card.billing_address.postal_code.should == '56789'
   end
 
   it 'should be able to update just expiration year' do
@@ -52,10 +52,10 @@ describe 'Credit Card Integration' do
 
     credit_card.update_attributes!(:cardholder_name => 'Foo Bar', :number => '4111111111111111', :options => {:verify_card => true}, :expiration_month => '07', :expiration_year => '2013', :billing_address => address_hash.merge(:postal_code => '56789'))
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
-    braintree_credit_card.cardholder_name.must_equal 'Foo Bar'
-    braintree_credit_card.billing_address.postal_code.must_equal '56789'
-    braintree_credit_card.expiration_month.must_equal '07'
-    braintree_credit_card.expiration_year.must_equal '2013'
+    braintree_credit_card.cardholder_name.should == 'Foo Bar'
+    braintree_credit_card.billing_address.postal_code.should == '56789'
+    braintree_credit_card.expiration_month.should == '07'
+    braintree_credit_card.expiration_year.should == '2013'
   end
 
   it 'should be able to update by expiration date' do
@@ -64,11 +64,11 @@ describe 'Credit Card Integration' do
 
     credit_card.update_attributes!(:cardholder_name => 'Foo Bar', :number => '4111111111111111', :options => {:verify_card => true}, :expiration_date => '08/2013', :billing_address => address_hash.merge(:postal_code => '56789'))
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
-    braintree_credit_card.cardholder_name.must_equal 'Foo Bar'
-    braintree_credit_card.billing_address.postal_code.must_equal '56789'
-    braintree_credit_card.expiration_month.must_equal '08'
-    braintree_credit_card.expiration_year.must_equal '2013'
-    braintree_credit_card.expiration_date.must_equal '08/2013'
+    braintree_credit_card.cardholder_name.should == 'Foo Bar'
+    braintree_credit_card.billing_address.postal_code.should == '56789'
+    braintree_credit_card.expiration_month.should == '08'
+    braintree_credit_card.expiration_year.should == '2013'
+    braintree_credit_card.expiration_date.should == '08/2013'
   end
 
   it 'should be able to destroy existing credit card' do
@@ -76,13 +76,13 @@ describe 'Credit Card Integration' do
     credit_card = BraintreeRails::CreditCard.new(braintree_customer.credit_cards.first.token)
 
     credit_card.destroy!
-    lambda{ Braintree::CreditCard.find(credit_card.token) }.must_raise Braintree::NotFoundError
-    credit_card.persisted?.must_equal false
-    credit_card.frozen?.must_equal true
+    expect { Braintree::CreditCard.find(credit_card.token) }.to raise_error(Braintree::NotFoundError)
+    credit_card.should_not be_persisted
+    credit_card.should be_frozen
   end
 
   it 'should be able to capture braintree api errors' do
     customer = BraintreeRails::Customer.create!(:id => 'customer_id', :first_name => 'Brain', :last_name => 'Tree')
-    lambda{customer.credit_cards.create!(credit_card_hash.merge(:number => 'foo'))}.must_raise Braintree::ValidationsFailed
+    expect {customer.credit_cards.create!(credit_card_hash.merge(:number => 'foo'))}.to raise_error(Braintree::ValidationsFailed)
   end
 end

data/{test/integration/braintree_rails/customer_integration_test.rb → spec/integration/braintree_rails/customer_integration_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../integration_test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../integration_spec_helper'))
 
 describe 'Customer Integration' do
   before do
@@ -8,24 +8,24 @@ describe 'Customer Integration' do
   it 'should fetch customer from Braintree for given id' do
     braintree_customer = Braintree::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer = BraintreeRails::Customer.new(braintree_customer.id)
-    customer.id.must_equal braintree_customer.id
-    customer.first_name.must_equal 'Brain'
-    customer.last_name.must_equal 'Tree'
-    customer.persisted?.must_equal true
+    customer.id.should == braintree_customer.id
+    customer.first_name.should == 'Brain'
+    customer.last_name.should == 'Tree'
+    customer.should be_persisted
   end
 
   it 'should be able to create new customer' do
     customer = BraintreeRails::Customer.create(:first_name => 'Brain', :last_name => 'Tree')
     braintree_customer = Braintree::Customer.find(customer.id)
 
-    braintree_customer.first_name.must_equal 'Brain'
-    braintree_customer.last_name.must_equal 'Tree'
+    braintree_customer.first_name.should == 'Brain'
+    braintree_customer.last_name.should == 'Tree'
   end
 
   it 'should be able to create new customer with a credit card' do
     customer = BraintreeRails::Customer.create(:first_name => 'Brain', :last_name => 'Tree', :credit_card => credit_card_hash)
     braintree_customer = Braintree::Customer.find(customer.id)
-    braintree_customer.credit_cards.count.must_equal 1
+    braintree_customer.credit_cards.count.should == 1
   end
 
   it 'should be able to update existing customer' do
@@ -33,8 +33,8 @@ describe 'Customer Integration' do
     customer.update_attributes!(:first_name => 'Foo', :last_name => 'Bar')
 
     braintree_customer = Braintree::Customer.find(customer.id)
-    braintree_customer.first_name.must_equal 'Foo'
-    braintree_customer.last_name.must_equal 'Bar'
+    braintree_customer.first_name.should == 'Foo'
+    braintree_customer.last_name.should == 'Bar'
   end
 
   it 'should be able to update existing customer with new credit card' do
@@ -42,35 +42,35 @@ describe 'Customer Integration' do
     customer.update_attributes!(:first_name => 'Foo', :last_name => 'Bar', :credit_card => credit_card_hash.merge(:cardholder_name => "FooBar"))
 
     braintree_customer = Braintree::Customer.find(customer.id)
-    braintree_customer.credit_cards.first.cardholder_name.must_equal "FooBar"
+    braintree_customer.credit_cards.first.cardholder_name.should == "FooBar"
   end
 
   it 'should be able to destroy existing customer' do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer.destroy
-    lambda{ Braintree::Customer.find(customer.id) }.must_raise Braintree::NotFoundError
-    customer.persisted?.must_equal false
-    customer.frozen?.must_equal true
+    expect { Braintree::Customer.find(customer.id) }.to raise_error(Braintree::NotFoundError)
+    customer.should_not be_persisted
+    customer.should be_frozen
   end
 
   it 'should not throw error when trying to destory an already destoryed customer' do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer.destroy
-    lambda{ customer.destroy }.must_be_silent
-    customer.persisted?.must_equal false
-    customer.frozen?.must_equal true
+    expect { customer.destroy }.not_to raise_error()
+    customer.should_not be_persisted
+    customer.should be_frozen
   end
 
   it "should be able to reload the customer attributes" do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer.first_name = 'new name'
-    customer.reload.first_name.must_equal 'Brain'
+    customer.reload.first_name.should == 'Brain'
   end
 
   it "should be able to reload associations" do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
-    customer.credit_cards.must_be :empty?
+    customer.credit_cards.should be_empty
     Braintree::CreditCard.create(credit_card_hash.merge(:customer_id => customer.id))
-    customer.reload.credit_cards.size.must_equal 1
+    customer.reload.credit_cards.size.should == 1
   end
 end