fake_braintree 0.0.5 → 0.0.6

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - ree
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Changelog.md

@@ -1,3 +1,10 @@
+# 0.0.6
+* Flesh out the README
+* Add support for transparent redirect
+* Add basic support for adding add-ons
+* Add basic support for adding discounts
+* Lots of internal refactorings
+
 # 0.0.5
 * Add support for Braintree::Customer.find
 

data/README.md

@@ -1,14 +1,49 @@
-# fake\_braintree, a Braintree fake
+# fake\_braintree, a Braintree fake [![Build Status](https://secure.travis-ci.org/thoughtbot/fake_braintree.png)](http://travis-ci.org/thoughtbot/fake_braintree)
 
-Currently in alpha.
+
+This library is a way to test Braintree code without hitting Braintree's servers.
+It uses [Capybara::Server](https://github.com/jnicklas/capybara/blob/master/lib/capybara/server.rb)
+to intercept all of the calls from Braintree's Ruby library and returns XML that the Braintree library
+can parse. The whole point is not to hit the Braintree API.
+
+Currently in alpha (i.e. it does not support every Braintree call).
+
+## Supported API methods
+
+### Customer
+* `Braintree::Customer.find`
+* `Braintree::Customer.create` (including adding add-ons and discounts)
+* `Braintree::Customer.update`
+* `Braintree::Customer.delete`
+
+### Subscription
+* `Braintree::Subscription.find`
+* `Braintree::Subscription.create`
+* `Braintree::Subscription.update`
+
+### CreditCard
+* `Braintree::CreditCard.find`
+* `Braintree::CreditCard.sale`
+
+### Transaction
+* `Braintree::Transaction.sale`
+
+### TransparentRedirect
+* `Braintree::TransparentRedirect.url`
+* `Braintree::TransparentRedirect.confirm` (only for creating customers)
 
 ## Quick start
-Call `FakeBraintree.activate!` to make it go. `FakeBraintree.clear!` will clear
-all data, which you probably want to do before each test.
+Just require the library and you're good to go:
+
+    require 'fake_braintree'
 
-Example, in spec\_helper.rb:
+`FakeBraintree.clear!` will clear all data, which you almost certainly want to
+do before each test.
 
-    FakeBraintree.activate!
+Full example:
+
+    # spec_helper.rb
+    require 'fake_braintree'
 
     RSpec.configure do |c|
       c.before do
@@ -16,6 +51,15 @@ Example, in spec\_helper.rb:
       end
     end
 
+If you're using Cucumber, add this too:
+
+    # env.rb
+    require 'fake_braintree'
+
+    Before do
+      FakeBraintree.clear!
+    end
+
 ## Verifying credit cards
 
 To verify every credit card you try to use, call:
@@ -30,3 +74,56 @@ Calling FakeBraintree.clear! _will not_ change this setting. It does very basic
 verification: it only matches the credit card number against these:
 http://www.braintreepayments.com/docs/ruby/reference/sandbox and rejects them if
 they aren't one of the listed numbers.
+
+## Declining credit cards
+
+To decline every card you try, call:
+
+    FakeBraintree.decline_all_cards!
+
+This will decline all cards until you call
+
+    FakeBraintree.clear!
+
+This behavior is different from `FakeBraintree.verify_all_cards`, which will
+stay on even when `clear!` is called.
+
+Note that after `decline_all_cards!` is set, Braintree will still create
+customers, but will not be able to charge them (so charging for e.g. a subscription
+will fail). Setting `verify_all_cards!`, on the other hand, will prevent
+creation of customers with bad credit cards - Braintree won't even get to trying
+to charge them.
+
+## Generating transactions
+
+You can generate a transaction using `FakeBraintree.generate_transaction`. This
+is for use in testing, e.g.
+`before { user.transaction = FakeBraintree.generate_transaction }`.
+
+It takes the following options:
+
+* `:subscription_id`: the ID of the subscription associated with the transaction.
+* `:created_at`: when the transaction was created (defaults to `Time.now`)
+* `:amount`: the amount of the transaction
+* `:status`: the status of the transaction, e.g. `Braintree::Transaction::Status::Failed`
+
+Any or all of these can be nil, and in fact are nil by default. You can also
+call it with no arguments.
+
+Full example:
+
+    transaction = FakeBraintree.generate_transaction(:amount => '20.00',
+                                                     :status => Braintree::Transaction::Status::Settled,
+                                                     :subscription_id => 'foobar',
+                                                     :created_at => Time.now + 60)
+    p transaction
+    # {
+    #   "status_history" =>
+    #     [{
+    #       "timestamp"  => 2011-11-20 12:57:25 -0500,
+    #       "amount"     => "20.00",
+    #       "status"     => "settled",
+    #       "created_at" => 2011-11-20 12:58:25 -0500
+    #     }],
+    #   "subscription_id" => "foobar"
+    # }

data/Rakefile

@@ -1,6 +1,6 @@
+require "bundler/setup"
 require "bundler/gem_tasks"
-
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 

data/fake_braintree.gemspec

@@ -16,12 +16,17 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'sham_rack'
+  s.add_dependency 'capybara'
   s.add_dependency 'activesupport'
   s.add_dependency 'i18n'
   s.add_dependency 'sinatra'
   s.add_dependency 'braintree', '~> 2.5'
+  s.add_dependency 'mongrel', '~> 1.2.0.pre'
 
   s.add_development_dependency 'rspec', '~> 2.6.0'
   s.add_development_dependency 'mocha', '~> 0.9.12'
+  s.add_development_dependency 'timecop', '~> 0.3.5'
+  s.add_development_dependency 'spork', '~> 0.9.0.rc9'
+  s.add_development_dependency 'bundler', '>= 1.0.14'
+  s.add_development_dependency 'rake'
 end

data/lib/fake_braintree.rb

@@ -1,10 +1,13 @@
 require 'fileutils'
 require 'braintree'
-require 'sham_rack'
+require 'capybara'
+require 'capybara/server'
+require 'rack/handler/mongrel'
 
 require 'fake_braintree/helpers'
 require 'fake_braintree/customer'
 require 'fake_braintree/subscription'
+require 'fake_braintree/redirect'
 
 require 'fake_braintree/sinatra_app'
 require 'fake_braintree/valid_credit_cards'
@@ -15,20 +18,18 @@ module FakeBraintree
     @customers     = {}
     @subscriptions = {}
     @failures      = {}
-    @transaction   = {}
+    @transactions  = {}
+    @redirects     = {}
 
     @decline_all_cards = false
     @verify_all_cards  = false
-    attr_accessor :customers, :subscriptions, :failures, :transaction, :decline_all_cards, :verify_all_cards
+    attr_accessor :customers, :subscriptions, :failures, :transactions, :decline_all_cards, :verify_all_cards, :redirects
   end
 
   def self.activate!
-    Braintree::Configuration.environment = :production
-    Braintree::Configuration.merchant_id = "xxx"
-    Braintree::Configuration.public_key  = "xxx"
-    Braintree::Configuration.private_key = "xxx"
+    set_configuration
     clear!
-    ShamRack.mount(FakeBraintree::SinatraApp, "www.braintreegateway.com", 443)
+    boot_server
   end
 
   def self.log_file_path
@@ -39,7 +40,8 @@ module FakeBraintree
     self.customers         = {}
     self.subscriptions     = {}
     self.failures          = {}
-    self.transaction       = {}
+    self.transactions      = {}
+    self.redirects         = {}
     self.decline_all_cards = false
     clear_log!
   end
@@ -53,7 +55,7 @@ module FakeBraintree
     self.failures.include?(card_number)
   end
 
-  def self.failure_response(card_number)
+  def self.failure_response(card_number = nil)
     failure = self.failures[card_number] || {}
     failure["errors"] ||= { "errors" => [] }
 
@@ -96,6 +98,43 @@ module FakeBraintree
       return card if card
     end
   end
+
+  def self.generate_transaction(options = {})
+    history_item = { 'timestamp'       => Time.now,
+                     'amount'          => options[:amount],
+                     'status'          => options[:status] }
+    created_at = options[:created_at] || Time.now
+    {'status_history'  => [history_item],
+     'subscription_id' => options[:subscription_id],
+     'created_at'      => created_at }
+  end
+
+  private
+
+  def self.set_configuration
+    Braintree::Configuration.environment = :development
+    Braintree::Configuration.merchant_id = "xxx"
+    Braintree::Configuration.public_key  = "xxx"
+    Braintree::Configuration.private_key = "xxx"
+  end
+
+  def self.boot_server
+    with_mongrel_runner do
+      server = Capybara::Server.new(FakeBraintree::SinatraApp)
+      server.boot
+      ENV['GATEWAY_PORT'] = server.port.to_s
+    end
+  end
+
+  def self.with_mongrel_runner
+    default_server_process = Capybara.server
+    Capybara.server do |app, port|
+      Rack::Handler::Mongrel.run(app, :Port => port)
+    end
+    yield
+  ensure
+    Capybara.server(&default_server_process)
+  end
 end
 
 FakeBraintree.activate!

data/lib/fake_braintree/customer.rb

@@ -2,31 +2,44 @@ module FakeBraintree
   class Customer
     include Helpers
 
-    def initialize(request, merchant_id)
-      @request_hash = Hash.from_xml(request.body).delete("customer")
-      @merchant_id  = merchant_id
+    def initialize(customer_hash, options)
+      @customer_hash = customer_hash.merge("merchant_id" => options[:merchant_id],
+                                           "id" => options[:id])
     end
 
-    def invalid?
-      credit_card_is_failure? || invalid_credit_card?
+    def create
+      if invalid?
+        failure_response
+      else
+        hash = customer_hash
+        FakeBraintree.customers[hash["id"]] = hash
+        gzipped_response(201, hash.to_xml(:root => 'customer'))
+      end
     end
 
-    def failure_response
-      gzipped_response(422, FakeBraintree.failure_response(@request_hash["credit_card"]["number"]).to_xml(:root => 'api_error_response'))
+    def update
+      if existing_customer_hash
+        hash = update_existing_customer!
+        gzipped_response(200, hash.to_xml(:root => 'customer'))
+      else
+        failure_response(404)
+      end
+    end
+
+    def delete
+      FakeBraintree.customers[existing_customer_id] = nil
+      gzipped_response(200, '')
     end
 
     def customer_hash
-      hash = @request_hash.dup
+      hash = @customer_hash.dup
       hash["id"] ||= create_id
-      hash["merchant-id"] = @merchant_id
+
       if hash["credit_card"] && hash["credit_card"].is_a?(Hash)
-        hash["credit_card"].delete("__content__")
         if !hash["credit_card"].empty?
-          hash["credit_card"]["last_4"]           = hash["credit_card"].delete("number")[-4..-1]
-          hash["credit_card"]["token"]            = md5("#{hash['merchant_id']}#{hash['id']}")
-          expiration_date = hash["credit_card"].delete("expiration_date")
-          hash["credit_card"]["expiration_month"] = expiration_date.split('/')[0]
-          hash["credit_card"]["expiration_year"]  = expiration_date.split('/')[1]
+          hash["credit_card"]["last_4"] = last_four(hash)
+          hash["credit_card"]["token"]  = credit_card_token(hash)
+          split_expiration_date_into_month_and_year!(hash)
 
           credit_card = hash.delete("credit_card")
           hash["credit_cards"] = [credit_card]
@@ -38,30 +51,73 @@ module FakeBraintree
 
     private
 
-    def create_id
-      md5("#{@merchant_id}#{Time.now.to_f}")
+    def invalid?
+      credit_card_is_failure? || invalid_credit_card?
+    end
+
+    def split_expiration_date_into_month_and_year!(hash)
+      if expiration_date = hash["credit_card"].delete("expiration_date")
+        hash["credit_card"]["expiration_month"] = expiration_date.split('/')[0]
+        hash["credit_card"]["expiration_year"]  = expiration_date.split('/')[1]
+      end
+    end
+
+    def existing_customer_hash
+      existing_customer_id && FakeBraintree.customers[existing_customer_id]
+    end
+
+    def update_existing_customer!
+      existing_customer_hash.merge!(customer_hash)
+    end
+
+    def credit_card_token(hash)
+      md5("#{hash['merchant_id']}#{hash['id']}")
+    end
+
+    def last_four(hash)
+      hash["credit_card"].delete("number")[-4..-1]
+    end
+
+    def failure_response(code = 422)
+      gzipped_response(code, FakeBraintree.failure_response(credit_card_number).to_xml(:root => 'api_error_response'))
     end
 
     def credit_card_is_failure?
-      @request_hash.key?('credit_card') &&
-        FakeBraintree.failure?(@request_hash["credit_card"]["number"])
+      @customer_hash.key?('credit_card') &&
+        FakeBraintree.failure?(@customer_hash["credit_card"]["number"])
     end
 
     def invalid_credit_card?
-      verify_credit_card?(@request_hash) && has_invalid_credit_card?(@request_hash)
+      verify_credit_card?(@customer_hash) && has_invalid_credit_card?(@customer_hash)
     end
 
     def verify_credit_card?(customer_hash)
       return true if FakeBraintree.verify_all_cards
 
-      @request_hash.key?("credit_card") &&
-        @request_hash["credit_card"].key?("options") &&
-        @request_hash["credit_card"]["options"].is_a?(Hash) &&
-        @request_hash["credit_card"]["options"]["verify_card"] == true
+      @customer_hash.key?("credit_card") &&
+        @customer_hash["credit_card"].is_a?(Hash) &&
+        @customer_hash["credit_card"].key?("options") &&
+        @customer_hash["credit_card"]["options"].is_a?(Hash) &&
+        @customer_hash["credit_card"]["options"]["verify_card"] == true
     end
 
     def has_invalid_credit_card?(customer_hash)
-      ! FakeBraintree::VALID_CREDIT_CARDS.include?(@request_hash["credit_card"]["number"])
+      has_credit_card_number? &&
+        ! FakeBraintree::VALID_CREDIT_CARDS.include?(@customer_hash["credit_card"]["number"])
+    end
+
+    def has_credit_card_number?
+      @customer_hash.key?("credit_card") &&
+        @customer_hash["credit_card"].is_a?(Hash) &&
+        @customer_hash["credit_card"].key?("number")
+    end
+
+    def credit_card_number
+      has_credit_card_number? && @customer_hash["credit_card"]["number"]
+    end
+
+    def existing_customer_id
+      @customer_hash['id']
     end
   end
 end

data/lib/fake_braintree/helpers.rb

@@ -15,5 +15,9 @@ module FakeBraintree
     def md5(content)
       Digest::MD5.hexdigest(content)
     end
+
+    def create_id
+      md5("#{@merchant_id}#{Time.now.to_f}")
+    end
   end
 end

data/lib/fake_braintree/redirect.rb

@@ -0,0 +1,37 @@
+module FakeBraintree
+  class Redirect
+    include Helpers
+
+    attr_reader :id
+
+    def initialize(params, merchant_id)
+      hash, query = *params[:tr_data].split("|", 2)
+      @transparent_data = Rack::Utils.parse_query(query)
+      @merchant_id = merchant_id
+      @id = create_id
+      @params = params
+    end
+
+    def url
+      uri.to_s
+    end
+
+    def confirm
+      Customer.new(@params["customer"], {:merchant_id => @merchant_id}).create
+    end
+
+    private
+
+    def uri
+      URI.parse(@transparent_data["redirect_url"]).merge("?#{base_query}&hash=#{hash(base_query)}")
+    end
+
+    def base_query
+      "http_status=200&id=#{@id}&kind=create_customer"
+    end
+
+    def hash(string)
+      Braintree::Digest.hexdigest(Braintree::Configuration.private_key, string)
+    end
+  end
+end