fake_braintree 0.2.1 → 0.3

data/lib/fake_braintree/helpers.rb

@@ -9,7 +9,7 @@ module FakeBraintree
     end
 
     def gzipped_response(status_code, uncompressed_content)
-      [status_code, { "Content-Encoding" => "gzip" }, gzip(uncompressed_content)]
+      [status_code, { 'Content-Encoding' => 'gzip' }, gzip(uncompressed_content)]
     end
 
     def md5(content)

data/lib/fake_braintree/redirect.rb

@@ -5,11 +5,12 @@ module FakeBraintree
     attr_reader :id
 
     def initialize(params, merchant_id)
-      hash, query = *params[:tr_data].split("|", 2)
-      @transparent_data = Rack::Utils.parse_query(query)
+      hash, query = *params[:tr_data].split('|', 2)
+      @transparent_data = Rack::Utils.parse_nested_query(query)
       @merchant_id = merchant_id
       @id = create_id(@merchant_id)
       @params = params
+      @kind = @transparent_data['kind']
     end
 
     def url
@@ -17,17 +18,28 @@ module FakeBraintree
     end
 
     def confirm
-      Customer.new(@params["customer"], {:merchant_id => @merchant_id}).create
+      if @kind == 'create_customer'
+        Customer.new(@params['customer'], {:merchant_id => @merchant_id}).create
+      elsif @kind == 'create_payment_method'
+        credit_card_options = {:merchant_id => @merchant_id}
+        credit_card_options.merge!(@transparent_data['credit_card'].fetch('options', {}))
+
+        credit_card_options.symbolize_keys!
+        CreditCard.new(@params['credit_card'].merge(@transparent_data['credit_card']), credit_card_options).create
+      end
     end
 
     private
 
     def uri
-      URI.parse(@transparent_data["redirect_url"]).merge("?#{base_query}&hash=#{hash(base_query)}")
+      uri = URI.parse(@transparent_data['redirect_url'])
+      merged_query = [uri.query, base_query].compact.join('&')
+      uri.query = "#{merged_query}&hash=#{hash(merged_query)}"
+      uri
     end
 
     def base_query
-      "http_status=200&id=#{@id}&kind=create_customer"
+      "http_status=200&id=#{@id}&kind=#{@kind}"
     end
 
     def hash(string)

data/lib/fake_braintree/registry.rb

@@ -3,12 +3,8 @@ class FakeBraintree::Registry
     clear!
   end
 
-  attr_accessor :customers,
-                :subscriptions,
-                :failures,
-                :transactions,
-                :redirects,
-                :credit_cards
+  attr_accessor :customers,:subscriptions, :failures, :transactions, :redirects,
+    :credit_cards
 
   def clear!
     @customers     = {}

data/lib/fake_braintree/sinatra_app.rb

@@ -10,20 +10,25 @@ module FakeBraintree
     include Helpers
 
     helpers do
-      def hash_from_request_body_with_key(request, key)
-        Hash.from_xml(request.body).delete(key)
+      def hash_from_request_body_with_key(key)
+        value = Hash.from_xml(request.body).delete(key)
+        if value.is_a?(String) # This happens if there isn't actually nested data under `key`
+          {}
+        else
+          value
+        end
       end
     end
 
     # Braintree::Customer.create
-    post "/merchants/:merchant_id/customers" do
-      customer_hash = hash_from_request_body_with_key(request, "customer")
+    post '/merchants/:merchant_id/customers' do
+      customer_hash = hash_from_request_body_with_key('customer')
       options = {:merchant_id => params[:merchant_id]}
       Customer.new(customer_hash, options).create
     end
 
     # Braintree::Customer.find
-    get "/merchants/:merchant_id/customers/:id" do
+    get '/merchants/:merchant_id/customers/:id' do
       customer = FakeBraintree.registry.customers[params[:id]]
       if customer
         gzipped_response(200, customer.to_xml(:root => 'customer'))
@@ -33,28 +38,28 @@ module FakeBraintree
     end
 
     # Braintree::Customer.update
-    put "/merchants/:merchant_id/customers/:id" do
-      customer_hash = hash_from_request_body_with_key(request, "customer")
+    put '/merchants/:merchant_id/customers/:id' do
+      customer_hash = hash_from_request_body_with_key('customer')
       options = {:id => params[:id], :merchant_id => params[:merchant_id]}
       Customer.new(customer_hash, options).update
     end
 
     # Braintree::Customer.delete
-    delete "/merchants/:merchant_id/customers/:id" do
+    delete '/merchants/:merchant_id/customers/:id' do
       customer_hash = {}
       options = {:id => params[:id], :merchant_id => params[:merchant_id]}
       Customer.new(customer_hash, options).delete
     end
 
     # Braintree::Subscription.create
-    post "/merchants/:merchant_id/subscriptions" do
-      subscription_hash = hash_from_request_body_with_key(request, "subscription")
+    post '/merchants/:merchant_id/subscriptions' do
+      subscription_hash = hash_from_request_body_with_key('subscription')
       options = {:merchant_id => params[:merchant_id]}
       Subscription.new(subscription_hash, options).create
     end
 
     # Braintree::Subscription.find
-    get "/merchants/:merchant_id/subscriptions/:id" do
+    get '/merchants/:merchant_id/subscriptions/:id' do
       subscription = FakeBraintree.registry.subscriptions[params[:id]]
       if subscription
         gzipped_response(200, subscription.to_xml(:root => 'subscription'))
@@ -64,98 +69,111 @@ module FakeBraintree
     end
 
     # Braintree::Subscription.update
-    put "/merchants/:merchant_id/subscriptions/:id" do
-      subscription_hash = hash_from_request_body_with_key(request, "subscription")
+    put '/merchants/:merchant_id/subscriptions/:id' do
+      subscription_hash = hash_from_request_body_with_key('subscription')
       options = {:id => params[:id], :merchant_id => params[:merchant_id]}
       Subscription.new(subscription_hash, options).update
     end
 
     # Braintree::Subscription.cancel
-    put "/merchants/:merchant_id/subscriptions/:id/cancel" do
-      updates = {"status" => Braintree::Subscription::Status::Canceled}
+    put '/merchants/:merchant_id/subscriptions/:id/cancel' do
+      updates = {'status' => Braintree::Subscription::Status::Canceled}
       options = {:id => params[:id], :merchant_id => params[:merchant_id]}
       Subscription.new(updates, options).update
     end
 
     # Braintree::CreditCard.find
-    get "/merchants/:merchant_id/payment_methods/:credit_card_token" do
+    get '/merchants/:merchant_id/payment_methods/:credit_card_token' do
       credit_card = FakeBraintree.registry.credit_cards[params[:credit_card_token]]
-      gzipped_response(200, credit_card.to_xml(:root => "credit_card"))
-    end
-
-    post "/merchants/:merchant_id/payment_methods" do
-      opts = {
-        :token => md5("#{Time.now}#{rand}"),
-        :merchant_id => params[:merchant_id]
-      }
-      data = hash_from_request_body_with_key(request, 'credit_card')
-      if data[:token]
-        opts[:token] = data[:token]
+      if credit_card
+        gzipped_response(200, credit_card.to_xml(:root => 'credit_card'))
+      else
+        gzipped_response(404, {})
       end
-      credit_card = CreditCard.new(data, opts)
-      FakeBraintree.registry.credit_cards[opts[:token]] = credit_card
-      gzipped_response(200, credit_card.to_xml)
     end
 
     # Braintree::CreditCard.update
-    put "/merchants/:merchant_id/payment_methods/:credit_card_token" do
+    put '/merchants/:merchant_id/payment_methods/:credit_card_token' do
       credit_card = FakeBraintree.registry.credit_cards[params[:credit_card_token]]
-      updates     = hash_from_request_body_with_key(request, "credit_card")
+      updates     = hash_from_request_body_with_key('credit_card')
       options     = {:token => params[:credit_card_token], :merchant_id => params[:merchant_id]}
       CreditCard.new(updates, options).update
     end
 
+    # Braintree::CreditCard.create
+    post '/merchants/:merchant_id/payment_methods' do
+      credit_card_hash = hash_from_request_body_with_key('credit_card')
+      options = {:merchant_id => params[:merchant_id]}
+
+      if credit_card_hash['options']
+        options.merge!(credit_card_hash.delete('options')).symbolize_keys!
+      end
+
+      CreditCard.new(credit_card_hash, options).create
+    end
+
     # Braintree::Transaction.sale
     # Braintree::CreditCard.sale
-    post "/merchants/:merchant_id/transactions" do
+    post '/merchants/:merchant_id/transactions' do
       if FakeBraintree.decline_all_cards?
         gzipped_response(422, FakeBraintree.create_failure.to_xml(:root => 'api_error_response'))
       else
-        transaction          = hash_from_request_body_with_key(request, "transaction")
-        transaction_id       = md5("#{params[:merchant_id]}#{Time.now.to_f}")
-        transaction_response = {"id" => transaction_id, "amount" => transaction["amount"]}
+        transaction = hash_from_request_body_with_key('transaction')
+        transaction_id = md5("#{params[:merchant_id]}#{Time.now.to_f}")
+        options = transaction["options"] || {}
+        status = "authorized"
+        if options.fetch("submit_for_settlement", false) == true
+          status = "submitted_for_settlement"
+        end
+        transaction_response = {'id' => transaction_id, 'amount' => transaction['amount'], 'status' => status}
         FakeBraintree.registry.transactions[transaction_id] = transaction_response
-        gzipped_response(200, transaction_response.to_xml(:root => "transaction"))
+        gzipped_response(200, transaction_response.to_xml(:root => 'transaction'))
       end
     end
 
     # Braintree::Transaction.find
-    get "/merchants/:merchant_id/transactions/:transaction_id" do
+    get '/merchants/:merchant_id/transactions/:transaction_id' do
       transaction = FakeBraintree.registry.transactions[params[:transaction_id]]
       if transaction
-        gzipped_response(200, transaction.to_xml(:root => "transaction"))
+        gzipped_response(200, transaction.to_xml(:root => 'transaction'))
       else
         gzipped_response(404, {})
       end
     end
 
     # Braintree::Transaction.refund
-    # Braintree::CreditCard.refund
-    post "/merchants/:merchant_id/transactions/:transaction_id/refund" do
-      if FakeBraintree.decline_all_cards?
-        gzipped_response(422, FakeBraintree.create_failure.to_xml(:root => 'api_error_response'))
-      else
-        transaction          = hash_from_request_body_with_key(request, "transaction")
-        transaction_id       = md5("#{params[:merchant_id]}#{Time.now.to_f}")
-        transaction_response = {"id" => transaction_id, "amount" => transaction["amount"], "type" => "credit"}
-        FakeBraintree.registry.transactions[transaction_id] = transaction_response
-        gzipped_response(200, transaction_response.to_xml(:root => "transaction"))
-      end
+    post '/merchants/:merchant_id/transactions/:transaction_id/refund' do
+      transaction          = hash_from_request_body_with_key('transaction')
+      transaction_id       = md5('#{params[:merchant_id]}#{Time.now.to_f}')
+      transaction_response = {'id' => transaction_id, 'amount' => transaction['amount'], 'type' => 'credit'}
+      FakeBraintree.registry.transactions[transaction_id] = transaction_response
+      gzipped_response(200, transaction_response.to_xml(:root => 'transaction'))
+    end
+
+    # Braintree::Transaction.void
+    put '/merchants/:merchant_id/transactions/:transaction_id/void' do
+      transaction = FakeBraintree.registry.transactions[params[:transaction_id]]
+      transaction_response = {'id' => transaction['id'],
+                              'type' => transaction['sale'],
+                              'amount' => transaction['amount'],
+                              'status' => Braintree::Transaction::Status::Voided}
+      FakeBraintree.registry.transactions[transaction['id']] = transaction_response
+      gzipped_response(200, transaction_response.to_xml(:root => 'transaction'))
     end
 
     # Braintree::TransparentRedirect.url
-    post "/merchants/:merchant_id/transparent_redirect_requests" do
+    post '/merchants/:merchant_id/transparent_redirect_requests' do
       if params[:tr_data]
         redirect = Redirect.new(params, params[:merchant_id])
         FakeBraintree.registry.redirects[redirect.id] = redirect
         redirect to(redirect.url), 303
       else
-        [422, { "Content-Type" => "text/html" }, ["Invalid submission"]]
+        [422, { 'Content-Type' => 'text/html' }, ['Invalid submission']]
       end
     end
 
     # Braintree::TransparentRedirect.confirm
-    post "/merchants/:merchant_id/transparent_redirect_requests/:id/confirm" do
+    post '/merchants/:merchant_id/transparent_redirect_requests/:id/confirm' do
       redirect = FakeBraintree.registry.redirects[params[:id]]
       redirect.confirm
     end

data/lib/fake_braintree/subscription.rb

@@ -3,8 +3,10 @@ module FakeBraintree
     include Helpers
 
     def initialize(subscription_hash_from_params, options)
-      @subscription_hash = subscription_hash_from_params.merge("merchant_id" => options[:merchant_id],
-                                                               "id" => options[:id])
+      @subscription_hash = subscription_hash_from_params.merge(
+        'merchant_id' => options[:merchant_id],
+        'id' => options[:id]
+      )
       set_subscription_id
       set_subscription_status
     end
@@ -26,10 +28,12 @@ module FakeBraintree
     private
 
     def subscription_hash
-      @subscription_hash.merge({"transactions"      => [],
-                                "add_ons"           => added_add_ons,
-                                "discounts"         => added_discounts,
-                                "next_billing_date" => braintree_formatted_date(1.month.from_now)})
+      @subscription_hash.merge(
+        'transactions' => [],
+        'add_ons' => added_add_ons,
+        'discounts' => added_discounts,
+        'next_billing_date' => braintree_formatted_date(1.month.from_now)
+      )
     end
 
     def update_existing_subscription(updates)
@@ -38,7 +42,7 @@ module FakeBraintree
     end
 
     def create_subscription_with(new_subscription_hash)
-      FakeBraintree.registry.subscriptions[new_subscription_hash["id"]] = new_subscription_hash
+      FakeBraintree.registry.subscriptions[new_subscription_hash['id']] = new_subscription_hash
     end
 
     def subscription_from_registry
@@ -54,31 +58,31 @@ module FakeBraintree
     end
 
     def added_add_ons
-      if @subscription_hash["add_ons"].is_a?(Hash) && @subscription_hash["add_ons"]["add"]
-        @subscription_hash["add_ons"]["add"].map { |add_on| { "id" => add_on["inherited_from_id"] } }
+      if @subscription_hash['add_ons'].is_a?(Hash) && @subscription_hash['add_ons']['add']
+        @subscription_hash['add_ons']['add'].map { |add_on| { 'id' => add_on['inherited_from_id'] } }
       else
         []
       end
     end
 
     def added_discounts
-      if @subscription_hash["discounts"].is_a?(Hash) && @subscription_hash["discounts"]["add"]
-        @subscription_hash["discounts"]["add"].map { |discount| { "id" => discount["inherited_from_id"] } }
+      if @subscription_hash['discounts'].is_a?(Hash) && @subscription_hash['discounts']['add']
+        @subscription_hash['discounts']['add'].map { |discount| { 'id' => discount['inherited_from_id'] } }
       else
         []
       end
     end
 
     def set_subscription_id
-      @subscription_hash["id"] ||= generate_new_subscription_id
+      @subscription_hash['id'] ||= generate_new_subscription_id
     end
 
     def set_subscription_status
-      @subscription_hash["status"] ||= active_status
+      @subscription_hash['status'] ||= active_status
     end
 
     def subscription_id
-      subscription_hash["id"]
+      subscription_hash['id']
     end
 
     def generate_new_subscription_id
@@ -86,7 +90,7 @@ module FakeBraintree
     end
 
     def payment_method_token
-      @subscription_hash["payment_method_token"]
+      @subscription_hash['payment_method_token']
     end
 
     def active_status
@@ -94,7 +98,7 @@ module FakeBraintree
     end
 
     def response_for_created_subscription(hash)
-      gzipped_response(201, hash.to_xml(:root => "subscription"))
+      gzipped_response(201, hash.to_xml(:root => 'subscription'))
     end
 
     def response_for_subscription_not_found
@@ -102,7 +106,7 @@ module FakeBraintree
     end
 
     def response_for_created_subscription(hash)
-      gzipped_response(201, hash.to_xml(:root => "subscription"))
+      gzipped_response(201, hash.to_xml(:root => 'subscription'))
     end
   end
 end

data/lib/fake_braintree/version.rb

@@ -1,3 +1,3 @@
 module FakeBraintree
-  VERSION = '0.2.1'
+  VERSION = '0.3'
 end

data/spec/fake_braintree/credit_card_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "Braintree::CreditCard.find" do
-  it "gets the correct credit card" do
+describe 'Braintree::CreditCard.find' do
+  it 'gets the correct credit card' do
     credit_card = Braintree::CreditCard.find(token)
 
     credit_card.last_4.should == TEST_CC_NUMBER[-4,4]
@@ -14,30 +14,82 @@ describe "Braintree::CreditCard.find" do
   let(:token) { braintree_credit_card_token(TEST_CC_NUMBER, [month, year].join('/')) }
 end
 
-describe "Braintree::CreditCard.create" do
-  let(:month) { '04' }
-  let(:year)  { '2016' }
-  let(:token) { braintree_credit_card_token(TEST_CC_NUMBER, [month, year].join('/')) }
-  it "successfully creates card with valid data" do
-    result = Braintree::CreditCard.create :token => token,
-      :number => TEST_CC_NUMBER
+describe 'Braintree::CreditCard.sale' do
+  it 'successfully creates a sale' do
+    result = Braintree::CreditCard.sale(cc_token, :amount => 10.00)
     result.should be_success
-
-    Braintree::CreditCard.find(token).should be
+    Braintree::Transaction.find(result.transaction.id).should be
   end
 end
 
-describe "Braintree::CreditCard.sale" do
-  it "successfully creates a sale" do
-    result = Braintree::CreditCard.sale(cc_token, :amount => 10.00)
+
+describe 'Braintree::CreditCard.create' do
+  def build_credit_card_hash
+    {
+      :customer_id => @customer && @customer.id,
+      :number => '4111111111111111',
+      :cvv => '123',
+      :token => 'token',
+      :expiration_date => '07/2020',
+      :billing_address => {
+        :postal_code => '94110'
+      },
+      :options => {
+        :make_default => true
+      }
+    }
+  end
+
+  it 'allows creating a credit card without a customer' do
+    result = Braintree::CreditCard.create(build_credit_card_hash)
     result.should be_success
-    Braintree::Transaction.find(result.transaction.id).should be
+    Braintree::CreditCard.find('token').should_not be_nil
+  end
+
+  context 'with a customer' do
+    before do
+      @customer = Braintree::Customer.create.customer
+    end
+
+    it 'fails to create a credit card if decline_all_cards is set' do
+      FakeBraintree.decline_all_cards!
+      result = Braintree::CreditCard.create(build_credit_card_hash)
+      result.should_not be_success
+      expect { Braintree::CreditCard.find('token') }.to raise_exception Braintree::NotFoundError
+      FakeBraintree.clear!
+    end
+
+    it 'fails to create a credit card if verify_all_cards is set and card is invalid' do
+      FakeBraintree.verify_all_cards!
+      result = Braintree::CreditCard.create(build_credit_card_hash.merge(:number => '12345'))
+      result.should_not be_success
+      expect { Braintree::CreditCard.find('token') }.to raise_exception Braintree::NotFoundError
+      FakeBraintree.verify_all_cards = false
+    end
+
+    it 'successfully creates a credit card' do
+      result = Braintree::CreditCard.create(build_credit_card_hash)
+      result.should be_success
+      Braintree::Customer.find(@customer.id).credit_cards.last.token.should == 'token'
+      Braintree::Customer.find(@customer.id).credit_cards.last.default?.should be_true
+    end
+
+    it 'only allows one credit card to be default' do
+      result = Braintree::CreditCard.create(build_credit_card_hash)
+      result.should be_success
+      result = Braintree::CreditCard.create(build_credit_card_hash)
+      result.should be_success
+      # Reload the customer
+      @customer = Braintree::Customer.find(@customer.id)
+      @customer.credit_cards.select {|c| c.default?}.length.should == 1
+      @customer.credit_cards.length.should == 2
+    end
   end
 end
 
-describe "Braintree::CreditCard.update" do
-  it "successfully updates the credit card" do
-    new_expiration_date = "08/2012"
+describe 'Braintree::CreditCard.update' do
+  it 'successfully updates the credit card' do
+    new_expiration_date = '08/2012'
     token = cc_token
 
     result = Braintree::CreditCard.update(token, :expiration_date => new_expiration_date)
@@ -45,7 +97,7 @@ describe "Braintree::CreditCard.update" do
     Braintree::CreditCard.find(token).expiration_date.should == new_expiration_date
   end
 
-  it "raises an error for a nonexistent credit card" do
-    lambda { Braintree::CreditCard.update("foo", {:number => TEST_CC_NUMBER}) }.should raise_error(Braintree::NotFoundError)
+  it 'raises an error for a nonexistent credit card' do
+    lambda { Braintree::CreditCard.update('foo', {:number => TEST_CC_NUMBER}) }.should raise_error(Braintree::NotFoundError)
   end
 end