fake_braintree 0.0.5 → 0.0.6

data/lib/fake_braintree/sinatra_app.rb

@@ -11,14 +11,9 @@ module FakeBraintree
 
     # Braintree::Customer.create
     post "/merchants/:merchant_id/customers" do
-      customer = Customer.new(request, params[:merchant_id])
-      if customer.invalid?
-        customer.failure_response
-      else
-        customer_hash = customer.customer_hash
-        FakeBraintree.customers[customer_hash["id"]] = customer_hash
-        gzipped_response(201, customer_hash.to_xml(:root => 'customer'))
-      end
+      customer_hash = Hash.from_xml(request.body).delete("customer")
+      options = {:merchant_id => params[:merchant_id]}
+      Customer.new(customer_hash, options).create
     end
 
     # Braintree::Customer.find
@@ -31,12 +26,25 @@ module FakeBraintree
       end
     end
 
+    # Braintree::Customer.update
+    put "/merchants/:merchant_id/customers/:id" do
+      customer_hash = Hash.from_xml(request.body).delete("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
+      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
-      response_hash = Subscription.new(request).response_hash
-
-      FakeBraintree.subscriptions[response_hash["id"]] = response_hash
-      gzipped_response(201, response_hash.to_xml(:root => 'subscription'))
+      subscription_hash = Hash.from_xml(request.body).delete("subscription")
+      options = {:merchant_id => params[:merchant_id]}
+      Subscription.new(subscription_hash, options).create
     end
 
     # Braintree::Subscription.find
@@ -49,6 +57,13 @@ module FakeBraintree
       end
     end
 
+    # Braintree::Subscription.update
+    put "/merchants/:merchant_id/subscriptions/:id" do
+      subscription_hash = Hash.from_xml(request.body).delete("subscription")
+      options = {:id => params[:id], :merchant_id => params[:merchant_id]}
+      Subscription.new(subscription_hash, options).update
+    end
+
     # Braintree::CreditCard.find
     get "/merchants/:merchant_id/payment_methods/:credit_card_token" do
       credit_card = FakeBraintree.credit_card_from_token(params[:credit_card_token])
@@ -64,18 +79,36 @@ module FakeBraintree
         transaction          = Hash.from_xml(request.body)["transaction"]
         transaction_id       = md5("#{params[:merchant_id]}#{Time.now.to_f}")
         transaction_response = {"id" => transaction_id, "amount" => transaction["amount"]}
-        FakeBraintree.transaction.replace(transaction_response)
+        FakeBraintree.transactions[transaction_id] = transaction_response
         gzipped_response(200, transaction_response.to_xml(:root => "transaction"))
       end
     end
 
     # Braintree::Transaction.find
     get "/merchants/:merchant_id/transactions/:transaction_id" do
-      if FakeBraintree.transaction["id"] == params[:transaction_id]
-        gzipped_response(200, FakeBraintree.transaction.to_xml(:root => "transaction"))
+      transaction = FakeBraintree.transactions[params[:transaction_id]]
+      if transaction
+        gzipped_response(200, transaction.to_xml(:root => "transaction"))
       else
         gzipped_response(404, {})
       end
     end
+
+    # Braintree::TransparentRedirect.url
+    post "/merchants/:merchant_id/transparent_redirect_requests" do
+      if params[:tr_data]
+        redirect = Redirect.new(params, params[:merchant_id])
+        FakeBraintree.redirects[redirect.id] = redirect
+        redirect to(redirect.url), 303
+      else
+        [422, { "Content-Type" => "text/html" }, ["Invalid submission"]]
+      end
+    end
+
+    # Braintree::TransparentRedirect.confirm
+    post "/merchants/:merchant_id/transparent_redirect_requests/:id/confirm" do
+      redirect = FakeBraintree.redirects[params[:id]]
+      redirect.confirm
+    end
   end
 end

data/lib/fake_braintree/subscription.rb

@@ -2,20 +2,71 @@ module FakeBraintree
   class Subscription
     include Helpers
 
-    def initialize(request)
-      @subscription_hash = Hash.from_xml(request.body).delete("subscription")
+    def initialize(subscription_hash, options)
+      @subscription_hash = subscription_hash.merge("merchant_id" => options[:merchant_id],
+                                                   "id" => options[:id])
     end
 
-    def response_hash
-      response_hash = {}
-      response_hash["id"]                = md5("#{@subscription_hash["payment_method_token"]}#{Time.now.to_f}")[0,6]
-      response_hash["transactions"]      = []
-      response_hash["add_ons"]           = []
-      response_hash["discounts"]         = []
-      response_hash["next_billing_date"] = 1.month.from_now
-      response_hash["status"]            = Braintree::Subscription::Status::Active
+    def create
+      hash = subscription_hash
+      FakeBraintree.subscriptions[hash["id"]] = hash
+      gzipped_response(201, hash.to_xml(:root => 'subscription'))
+    end
+
+    def update
+      if existing_subscription_hash
+        hash = update_existing_subscription!
+        gzipped_response(200, hash.to_xml(:root => 'subscription'))
+      end
+    end
+
+    def subscription_hash
+      subscription_hash = @subscription_hash.dup
+      subscription_hash["id"]                   ||= subscription_id
+      subscription_hash["transactions"]         = []
+      subscription_hash["add_ons"]              = added_add_ons
+      subscription_hash["discounts"]            = added_discounts
+      subscription_hash["plan_id"]              = @subscription_hash["plan_id"]
+      subscription_hash["next_billing_date"]    = braintree_formatted_date(1.month.from_now)
+      subscription_hash["payment_method_token"] = @subscription_hash["payment_method_token"]
+      subscription_hash["status"]               = Braintree::Subscription::Status::Active
+
+      subscription_hash
+    end
+
+    private
+
+    def existing_subscription_hash
+      @subscription_hash['id'] && FakeBraintree.subscriptions[@subscription_hash["id"]]
+    end
+
+    def update_existing_subscription!
+      new_hash = existing_subscription_hash.merge(subscription_hash)
+      FakeBraintree.subscriptions[@subscription_hash['id']] = new_hash
+    end
+
+    def braintree_formatted_date(date)
+      date.strftime('%Y-%m-%d')
+    end
+
+    def subscription_id
+      md5("#{@subscription_hash["payment_method_token"]}#{Time.now.to_f}")[0,6]
+    end
+
+    def added_add_ons
+      if @subscription_hash["add_ons"] && @subscription_hash["add_ons"]["add"]
+        @subscription_hash["add_ons"]["add"].map { |add_on| { "id" => add_on["inherited_from_id"] } }
+      else
+        []
+      end
+    end
 
-      response_hash
+    def added_discounts
+      if @subscription_hash["discounts"] && @subscription_hash["discounts"]["add"]
+        @subscription_hash["discounts"]["add"].map { |discount| { "id" => discount["inherited_from_id"] } }
+      else
+        []
+      end
     end
   end
 end

data/lib/fake_braintree/version.rb

@@ -1,3 +1,3 @@
 module FakeBraintree
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/fake_braintree/credit_card_spec.rb

@@ -2,31 +2,24 @@ require 'spec_helper'
 
 describe FakeBraintree::SinatraApp do
   context "Braintree::CreditCard.find" do
-    let(:cc_number)         { %w(4111 1111 1111 9876).join }
-    let(:expiration_date)   { "04/2016" }
-    let(:token)             { braintree_credit_card_token(cc_number, expiration_date) }
-
     it "gets the correct credit card" do
       credit_card = Braintree::CreditCard.find(token)
 
-      credit_card.last_4.should == "9876"
-      credit_card.expiration_year.should == "2016"
-      credit_card.expiration_month.should == "04"
+      credit_card.last_4.should == TEST_CC_NUMBER[-4,4]
+      credit_card.expiration_month.should == month
+      credit_card.expiration_year.should ==  year
     end
+
+    let(:month) { '04' }
+    let(:year)  { '2016' }
+    let(:token) { braintree_credit_card_token(TEST_CC_NUMBER, [month, year].join('/')) }
   end
 
   context "Braintree::CreditCard.sale" do
-    let(:cc_number)         { %w(4111 1111 1111 9876).join }
-    let(:expiration_date)   { "04/2016" }
-    let(:token)             { braintree_credit_card_token(cc_number, expiration_date) }
-    let(:amount)            { 10.00 }
-
     it "successfully creates a sale" do
-      result = Braintree::CreditCard.sale(token, amount: amount, options: {submit_for_settlement: true})
+      result = Braintree::CreditCard.sale(cc_token, :amount => 10.00)
       result.should be_success
-
       Braintree::Transaction.find(result.transaction.id).should be
-      lambda { Braintree::Transaction.find("foo") }.should raise_error(Braintree::NotFoundError)
     end
   end
 end

data/spec/fake_braintree/customer_spec.rb

@@ -1,24 +1,28 @@
 require 'spec_helper'
 
 describe "Braintree::Customer.create" do
-  let(:cc_number)       { %w(4111 1111 1111 1111).join }
-  let(:expiration_date) { "04/2016" }
   after { FakeBraintree.verify_all_cards = false }
 
-  def create_customer_with_credit_card(options)
-    Braintree::Customer.create(:credit_card => options)
+  it "successfully creates a customer" do
+    result = Braintree::Customer.create(:credit_card => { :number => TEST_CC_NUMBER,
+                                                          :expiration_date => '04/2016'})
+    result.should be_success
   end
 
-  it "successfully creates a customer" do
-    result = create_customer_with_credit_card(:number => cc_number,
-                                              :expiration_date => expiration_date)
+  it "can handle an empty credit card hash" do
+    result = Braintree::Customer.create(:credit_card => {})
+    result.should be_success
+  end
+
+  it "creates a customer using an expiration month and year" do
+    result = Braintree::Customer.create(:credit_card => { :number => TEST_CC_NUMBER,
+                                                          :expiration_month => '04',
+                                                          :expiration_year => '2016'})
     result.should be_success
   end
 
   it "records the billing address" do
-    result = create_customer_with_credit_card(
-      :number => cc_number,
-      :expiration_date => expiration_date,
+    result = create_customer(
       :billing_address => {
         :street_address => "1 E Main St",
         :extended_address => "Suite 3",
@@ -34,54 +38,34 @@ describe "Braintree::Customer.create" do
     billing_address.street_address.should == "1 E Main St"
     billing_address.postal_code.should == "60622"
   end
+end
 
-  context "when passed :verify_card => true" do
-    it "accepts valid cards" do
-      create_customer_with_credit_card(
-        :number          => cc_number,
-        :expiration_date => expiration_date,
-        :options         => { :verify_card => true }
-      ).should be_success
-    end
-
-    it "rejects invalid cards" do
-      create_customer_with_credit_card(
-        :number          => '123456',
-        :expiration_date => expiration_date,
-        :options         => { :verify_card => true }
-      ).should_not be_success
-    end
+describe "Braintree::Customer.create", "when passed :verify_card => true" do
+  it "accepts valid cards" do
+    create_customer(:options => { :verify_card => true }).should be_success
   end
 
-  context "when FakeBraintree.verify_all_cards == true" do
-    before { FakeBraintree.verify_all_cards! }
-
-    it "accepts valid cards" do
-      create_customer_with_credit_card(
-        :number          => cc_number,
-        :expiration_date => expiration_date
-      ).should be_success
-    end
-
-    it "rejects invalid cards" do
-      create_customer_with_credit_card(
-        :number          => '123456',
-        :expiration_date => expiration_date
-      ).should_not be_success
-    end
+  it "rejects invalid cards" do
+    create_customer_with_invalid_card(:options => { :verify_card => true }).should_not be_success
   end
 end
 
-describe "Braintree::Customer.find" do
-  let(:cc_number)       { %w(4111 1111 1111 1111).join }
-  let(:expiration_date) { "04/2016" }
+describe "Braintree::Customer.create", "when FakeBraintree.verify_all_cards == true" do
+  before { FakeBraintree.verify_all_cards! }
+
+  it "accepts valid cards" do
+    create_customer.should be_success
+  end
 
-  def create_customer(options)
-    Braintree::Customer.create(:credit_card => options)
+  it "rejects invalid cards" do
+    create_customer_with_invalid_card.should_not be_success
   end
+end
 
+describe "Braintree::Customer.find" do
   it "successfully finds a customer" do
-    result = Braintree::Customer.create(:first_name => "Bob", :last_name => "Smith")
+    result = Braintree::Customer.create(:first_name => "Bob",
+                                        :last_name => "Smith")
 
     Braintree::Customer.find(result.customer.id).first_name.should == "Bob"
   end
@@ -90,3 +74,27 @@ describe "Braintree::Customer.find" do
     lambda { Braintree::Customer.find("foo") }.should raise_error(Braintree::NotFoundError)
   end
 end
+
+describe "Braintree::Customer.update" do
+  it "successfully updates a customer" do
+    customer_id = create_customer.customer.id
+    result = Braintree::Customer.update(customer_id, :first_name => "Jerry")
+
+    result.should be_success
+    Braintree::Customer.find(customer_id).first_name.should == "Jerry"
+  end
+
+  it "raises an error for a nonexistent customer" do
+    lambda { Braintree::Customer.update("foo", {:first_name => "Bob"}) }.should raise_error(Braintree::NotFoundError)
+  end
+end
+
+describe "Braintree::Customer.delete" do
+  it "successfully deletes a customer" do
+    customer_id = create_customer.customer.id
+    result = Braintree::Customer.delete(customer_id)
+
+    result.should be_success
+    expect { Braintree::Customer.find(customer_id) }.to raise_error(Braintree::NotFoundError)
+  end
+end

data/spec/fake_braintree/subscription_spec.rb

@@ -1,56 +1,82 @@
 require 'spec_helper'
 
-describe FakeBraintree::SinatraApp do
-  context "Braintree::Subscription.create" do
-    let(:plan_id)                { 'plan-id-from-braintree-control-panel' }
-    let(:cc_number)              { %w(4111 1111 1111 9876).join }
-    let(:expiration_date)        { "04/2016" }
-    let(:payment_method_token)   { braintree_credit_card_token(cc_number, expiration_date) }
-    let(:payment_method_token_2) { braintree_credit_card_token(cc_number.sub('1', '5'), expiration_date) }
-
-    it "successfully creates a subscription" do
-      result = Braintree::Subscription.create(:payment_method_token => payment_method_token,
-                                              :plan_id => plan_id)
-      result.should be_success
-    end
+describe "Braintree::Subscription.create" do
+  let(:plan_id)                { 'plan-id-from-braintree-control-panel' }
+  let(:expiration_date)        { "04/2016" }
 
-    it "assigns a Braintree-esque ID to the subscription" do
-      result = Braintree::Subscription.create(:payment_method_token => payment_method_token,
-                                              :plan_id => plan_id)
+  it "successfully creates a subscription" do
+    Braintree::Subscription.create(:payment_method_token => cc_token,
+                                   :plan_id => 'my_plan_id').should be_success
+  end
 
-      result.subscription.id.should =~ /^[a-z0-9]{6}$/
-    end
+  it "assigns a Braintree-esque ID to the subscription" do
+    create_subscription.subscription.id.should =~ /^[a-z0-9]{6}$/
+  end
 
-    it "assigns unique IDs to each subscription" do
-      first_result = Braintree::Subscription.create(:payment_method_token => payment_method_token,
-                                                    :plan_id => plan_id)
-      second_result = Braintree::Subscription.create(:payment_method_token => payment_method_token_2,
-                                                     :plan_id => plan_id)
+  it "assigns unique IDs to each subscription" do
+    cc_token_1 = cc_token
+    cc_token_2 = braintree_credit_card_token(TEST_CC_NUMBER.sub('1', '5'), expiration_date)
+    first_result = Braintree::Subscription.create(:payment_method_token => cc_token_1,
+                                                  :plan_id => plan_id)
+    second_result = Braintree::Subscription.create(:payment_method_token => cc_token_2,
+                                                   :plan_id => plan_id)
 
-      first_result.subscription.id.should_not == second_result.subscription.id
-    end
+    first_result.subscription.id.should_not == second_result.subscription.id
+  end
 
-    it "sets the next billing date to 1 month from now in UTC" do
-      result = Braintree::Subscription.create(:payment_method_token => payment_method_token,
-                                              :plan_id => plan_id)
+  it "stores created subscriptions in FakeBraintree.subscriptions" do
+    FakeBraintree.subscriptions[create_subscription.subscription.id].should_not be_nil
+  end
 
-      result.subscription.next_billing_date.to_i.should == 1.month.from_now.utc.to_i
+  it "sets the next billing date to a string of 1.month.from_now in UTC" do
+    Timecop.freeze do
+      create_subscription.subscription.next_billing_date.should == 1.month.from_now.utc.strftime('%Y-%m-%d')
     end
   end
+end
+
+describe "Braintree::Subscription.find" do
+  it "can find a created subscription" do
+    payment_method_token = cc_token
+    plan_id = "abc123"
+    subscription_id =
+      create_subscription(:payment_method_token => payment_method_token, :plan_id => plan_id).subscription.id
+    subscription = Braintree::Subscription.find(subscription_id)
+    subscription.should_not be_nil
+    subscription.payment_method_token.should == payment_method_token
+    subscription.plan_id.should == plan_id
+  end
 
-  context "Braintree::Subscription.find" do
-    let(:cc_number)            { %w(4111 1111 1111 9876).join }
-    let(:expiration_date)      { "04/2016" }
-    let(:payment_method_token) { braintree_credit_card_token(cc_number, expiration_date) }
-    let(:subscription_result)  { Braintree::Subscription.create(:payment_method_token => payment_method_token,
-                                                                :plan_id => 'my-plan-id') }
+  it "raises a Braintree:NotFoundError when it cannot find a subscription" do
+    create_subscription
+    expect { Braintree::Subscription.find('abc123') }.to raise_error(Braintree::NotFoundError, /abc123/)
+  end
 
-    it "can find a created subscription" do
-      Braintree::Subscription.find(subscription_result.subscription.id).should be
-    end
+  it "returns add-ons added with the subscription" do
+    add_on_id = "def456"
+    subscription_id = create_subscription(:add_ons => { :add => [{ :inherited_from_id => add_on_id }] }).subscription.id
+    subscription = Braintree::Subscription.find(subscription_id)
+    add_ons = subscription.add_ons
+    add_ons.size.should == 1
+    add_ons.first.id.should == add_on_id
+  end
 
-    it "raises a Braintree:NotFoundError when it cannot find a subscription" do
-      expect { Braintree::Subscription.find('abc123') }.to raise_error(Braintree::NotFoundError, /abc123/)
-    end
+  it "returns discounts added with the subscription" do
+    discount_id = "def456"
+    subscription_id = create_subscription(:discounts => { :add => [{ :inherited_from_id => discount_id, :amount => BigDecimal.new("15.00") }]}).subscription.id
+    subscription = Braintree::Subscription.find(subscription_id)
+    discounts = subscription.discounts
+    discounts.size.should == 1
+    discounts.first.id.should == discount_id
   end
 end
+
+describe "Braintree::Subscription.update" do
+  it "can update a subscription" do
+    Braintree::Subscription.update(subscription_id, :plan_id => 'a_new_plan')
+    Braintree::Subscription.find(subscription_id).plan_id.should == 'a_new_plan'
+  end
+
+  let(:subscription_id) { subscription.subscription.id }
+  let(:subscription)    { create_subscription }
+end