braintree 1.0.0

data/spec/integration/braintree/http_spec.rb

@@ -0,0 +1,201 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Http do
+  describe "self._handle_response" do
+    it "raises an AuthenticationError if authentication fails" do
+      begin
+        original_key = Braintree::Configuration.public_key
+        Braintree::Configuration.public_key = "invalid_public_key"
+        expect do
+          Braintree::Http.get "/customers"
+        end.to raise_error(Braintree::AuthenticationError)
+      ensure
+        Braintree::Configuration.public_key = original_key
+      end
+    end
+
+    it "raises an AuthorizationError if authorization fails" do
+      expect do
+        Braintree::Http.get "/users"
+      end.to raise_error(Braintree::AuthorizationError)
+    end
+  end
+  
+  describe "self._http_do" do
+    it "logs one line of info to the logger" do
+      begin
+        old_logger = Braintree::Configuration.logger
+        now_in_utc = Time.utc(2009, 10, 10, 13, 55, 36)
+        SpecHelper.stub_time_dot_now(now_in_utc) do
+          output = StringIO.new
+          Braintree::Configuration.logger = Logger.new(output)
+          Braintree::Configuration.logger.level = Logger::INFO
+          Braintree::Customer.all
+          utc_or_gmt = Time.now.utc.strftime("%Z")
+          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] GET /customers?page=1 200")
+        end
+      ensure
+        Braintree::Configuration.logger = old_logger
+      end
+    end
+
+    it "logs full request and response for debug logger" do
+      customer = Braintree::Customer.create.customer
+      begin
+        old_logger = Braintree::Configuration.logger
+        now_in_utc = Time.utc(2009, 10, 10, 13, 55, 36)
+        SpecHelper.stub_time_dot_now(now_in_utc) do
+          output = StringIO.new
+          Braintree::Configuration.logger = Logger.new(output)
+          Braintree::Configuration.logger.level = Logger::DEBUG
+          result = Braintree::CreditCard.create(
+            :customer_id => customer.id,
+            :cardholder_name => "Sam Jones",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          )
+          result.success?.should == true
+          utc_or_gmt = Time.now.utc.strftime("%Z")
+          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /payment_methods")
+          output.string.should include("[Braintree]   <cardholder-name>Sam Jones</cardholder-name>")
+          output.string.should include("[Braintree]   <number>401288******1881</number>")
+          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] 201 Created")
+          output.string.should match(/\[Braintree\]   <token>\w+<\/token>/)
+        end
+      ensure
+        Braintree::Configuration.logger = old_logger
+      end
+    end
+
+    describe "ssl verification" do
+      it "rejects when the certificate isn't verified by our certificate authority (self-signed)" do
+        begin
+          use_ssl = Braintree::Configuration.ssl?
+          Braintree::Configuration.stub(:ssl?).and_return(true)
+          Braintree::Configuration.stub(:port).and_return(8443)
+
+          start_ssl_server do
+            expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
+          end
+        ensure
+          Braintree::Configuration.stub(:ssl?).and_return(use_ssl)
+        end
+      end
+
+      it "rejets when the certificate is signed by a different (but valid) root CA" do
+        # Random CA root file from a different certificate authority
+        begin
+          original_ca_file = Braintree::Configuration.ca_file
+          Braintree::Configuration.stub(:ca_file).and_return(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "ssl", "geotrust_global.crt")))
+          use_ssl = Braintree::Configuration.ssl?
+          Braintree::Configuration.stub(:ssl?).and_return(true)
+          Braintree::Configuration.stub(:port).and_return(8443)
+
+          start_ssl_server do
+            expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
+          end
+        ensure
+          Braintree::Configuration.stub(:ssl?).and_return(use_ssl)
+          Braintree::Configuration.stub(:ca_file).and_return(original_ca_file)
+        end
+      end
+
+      it "accepts the certificate on the QA server" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :qa
+          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+
+          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to_not raise_error
+        ensure
+          Braintree::Configuration.environment = original_env
+        end
+      end
+
+      it "accepts the certificate on the sandbox server" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :sandbox
+          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+
+          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to_not raise_error
+        ensure
+          Braintree::Configuration.environment = original_env
+        end
+      end
+
+      xit "Patrick: waiting on a production box - accepts the certificate on the production server" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :production
+          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+
+          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to_not raise_error
+        ensure
+          Braintree::Configuration.environment = original_env
+        end
+      end
+
+      it "raises an appropriate error if certificate fails validation" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :qa
+          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+          original_ca_file = Braintree::Configuration.ca_file
+          Braintree::Configuration.stub(:ca_file).and_return(nil)
+          
+          expect { Braintree::Http._http_do(Net::HTTP::Get, "/login") }.to raise_error(Braintree::SSLCertificateError)
+        ensure
+          Braintree::Configuration.environment = original_env
+        end
+      end
+    end
+  end
+
+  describe "self._verify_ssl_certificate" do
+    it "raises if preverify is false" do
+      context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
+      expect { Braintree::Http._verify_ssl_certificate(false, context) }.to raise_error(Braintree::SSLCertificateError)
+    end
+
+    it "raise if ssl_context doesn't have an error code of 0" do
+      context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
+      context.error = 19 # ca_file incorrect, self-signed
+      expect { Braintree::Http._verify_ssl_certificate(true, context) }.to raise_error(Braintree::SSLCertificateError)
+    end
+
+    it "doesn't raise if there is no error" do
+      context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
+      expect { Braintree::Http._verify_ssl_certificate(true, context) }.to_not raise_error
+    end
+
+    it "logs when there is an error" do
+      begin
+        old_logger = Braintree::Configuration.logger
+        output = StringIO.new
+        Braintree::Configuration.logger = Logger.new(output)
+        utc_or_gmt = Time.now.utc.strftime("%Z")
+        context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
+        context.error = 19
+        expect { Braintree::Http._verify_ssl_certificate(false, context) }.to raise_error(Braintree::SSLCertificateError)
+        output.string.should include("SSL Verification failed -- Preverify: false, Error: self signed certificate in certificate chain (19)")
+      ensure
+        Braintree::Configuration.logger = old_logger
+      end
+    end
+
+    it "doesn't log when there is not an error" do
+      begin
+        old_logger = Braintree::Configuration.logger
+        output = StringIO.new
+        Braintree::Configuration.logger = Logger.new(output)
+        utc_or_gmt = Time.now.utc.strftime("%Z")
+        context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
+        expect { Braintree::Http._verify_ssl_certificate(true, context) }.to_not raise_error(Braintree::SSLCertificateError)
+        output.string.should == ""
+      ensure
+        Braintree::Configuration.logger = old_logger
+      end
+    end
+  end
+end

data/spec/integration/braintree/test/transaction_amounts_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Braintree::Test::TransactionAmounts do
+  describe "Authorize" do
+    it "creates a transaction with status authorized" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/2012"
+        }
+      )
+      transaction.status.should == "authorized"
+    end
+  end
+
+  describe "Decline" do
+    it "creates a transaction with status processor_declined" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/2012"
+        }
+      )
+      transaction.status.should == "processor_declined"
+    end
+  end
+end

data/spec/integration/braintree/transaction_spec.rb

@@ -0,0 +1,900 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Transaction do
+  describe "self.create" do
+    it "returns a successful result if successful" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.id.should =~ /^\w{6}$/
+      result.transaction.type.should == "sale"
+      result.transaction.amount.should == Braintree::Test::TransactionAmounts::Authorize
+      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      result.transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+    
+    it "returns an error result if validations fail" do
+      params = {
+        :transaction => {
+          :type => "sale",
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.create(params[:transaction])
+      result.success?.should == false
+      result.params.should == {:transaction => {:type => 'sale', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
+      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+    end
+  end
+
+  describe "self.create!" do
+    it "returns the transaction if valid" do
+      transaction = Braintree::Transaction.create!(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.id.should =~ /^\w{6}$/
+      transaction.type.should == "sale"
+      transaction.amount.should == Braintree::Test::TransactionAmounts::Authorize
+      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+    
+    it "raises a ValidationsFailed if invalid" do
+      expect do
+        Braintree::Transaction.create!(
+          :type => "sale",
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
+  describe "self.sale" do
+    it "returns a successful result with type=sale if successful" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.id.should =~ /^\w{6}$/
+      result.transaction.type.should == "sale"
+      result.transaction.amount.should == Braintree::Test::TransactionAmounts::Authorize
+      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      result.transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+
+    it "works when given all attributes" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :order_id => "123",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+          :cvv => "123"
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :company => "Braintree Payment Solutions",
+          :email => "dan@example.com",
+          :phone => "419-555-1234",
+          :fax => "419-555-1235",
+          :website => "http://braintreepaymentsolutions.com"
+        },
+        :billing => {
+          :first_name => "Carl",
+          :last_name => "Jones",
+          :company => "Braintree",
+          :street_address => "123 E Main St",
+          :extended_address => "Suite 403",
+          :locality => "Chicago",
+          :region => "IL",
+          :postal_code => "60622",
+          :country_name => "United States of America"
+        },
+        :shipping => {
+          :first_name => "Andrew",
+          :last_name => "Mason",
+          :company => "Braintree",
+          :street_address => "456 W Main St",
+          :extended_address => "Apt 2F",
+          :locality => "Bartlett",
+          :region => "IL",
+          :postal_code => "60103",
+          :country_name => "United States of America"
+        }
+      )
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.id.should =~ /\A\w{6}\z/
+      transaction.type.should == "sale"
+      transaction.status.should == "authorized"
+      transaction.amount.should == "100.00"
+      transaction.order_id.should == "123"
+      transaction.processor_response_code.should == "1000"
+      transaction.created_at.between?(Time.now - 5, Time.now).should == true
+      transaction.updated_at.between?(Time.now - 5, Time.now).should == true
+      transaction.credit_card_details.bin.should == "510510"
+      transaction.credit_card_details.last_4.should == "5100"
+      transaction.credit_card_details.masked_number.should == "510510******5100"
+      transaction.credit_card_details.card_type.should == "MasterCard"
+      transaction.avs_error_response_code.should == nil
+      transaction.avs_postal_code_response_code.should == "M"
+      transaction.avs_street_address_response_code.should == "M"
+      transaction.customer_details.first_name.should == "Dan"
+      transaction.customer_details.last_name.should == "Smith"
+      transaction.customer_details.company.should == "Braintree Payment Solutions"
+      transaction.customer_details.email.should == "dan@example.com"
+      transaction.customer_details.phone.should == "419-555-1234"
+      transaction.customer_details.fax.should == "419-555-1235"
+      transaction.customer_details.website.should == "http://braintreepaymentsolutions.com"
+      transaction.billing_details.first_name.should == "Carl"
+      transaction.billing_details.last_name.should == "Jones"
+      transaction.billing_details.company.should == "Braintree"
+      transaction.billing_details.street_address.should == "123 E Main St"
+      transaction.billing_details.extended_address.should == "Suite 403"
+      transaction.billing_details.locality.should == "Chicago"
+      transaction.billing_details.region.should == "IL"
+      transaction.billing_details.postal_code.should == "60622"
+      transaction.billing_details.country_name.should == "United States of America"
+      transaction.shipping_details.first_name.should == "Andrew"
+      transaction.shipping_details.last_name.should == "Mason"
+      transaction.shipping_details.company.should == "Braintree"
+      transaction.shipping_details.street_address.should == "456 W Main St"
+      transaction.shipping_details.extended_address.should == "Apt 2F"
+      transaction.shipping_details.locality.should == "Bartlett"
+      transaction.shipping_details.region.should == "IL"
+      transaction.shipping_details.postal_code.should == "60103"
+      transaction.shipping_details.country_name.should == "United States of America"
+    end
+    
+    it "can store customer and credit card in the vault" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :customer => {
+          :first_name => "Adam",
+          :last_name => "Williams"
+        },
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :options => {
+          :store_in_vault => true
+        }
+      )
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.customer_details.id.should =~ /\A\d{6,7}\z/
+      transaction.vault_customer.id.should == transaction.customer_details.id
+      transaction.credit_card_details.token.should =~ /\A\w{4,5}\z/
+      transaction.vault_credit_card.token.should == transaction.credit_card_details.token
+    end
+
+    it "submits for settlement if given transaction[options][submit_for_settlement]" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :options => {
+          :submit_for_settlement => true
+        }
+      )
+      result.success?.should == true
+      result.transaction.status.should == "submitted_for_settlement"
+    end
+    
+    it "can specify the customer id and payment method token" do
+      customer_id = "customer_#{rand(1000000)}"
+      payment_mehtod_token = "credit_card_#{rand(1000000)}"
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :customer => {
+          :id => customer_id,
+          :first_name => "Adam",
+          :last_name => "Williams"
+        },
+        :credit_card => {
+          :token => payment_mehtod_token,
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :options => {
+          :store_in_vault => true
+        }
+      )
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.customer_details.id.should == customer_id
+      transaction.vault_customer.id.should == customer_id
+      transaction.credit_card_details.token.should == payment_mehtod_token
+      transaction.vault_credit_card.token.should == payment_mehtod_token
+    end
+    
+    it "returns an error result if validations fail" do
+      params = {
+        :transaction => {
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.params.should == {:transaction => {:type => 'sale', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
+      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+    end
+  end
+
+  describe "self.sale!" do
+    it "returns the transaction if valid" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.id.should =~ /^\w{6}$/
+      transaction.type.should == "sale"
+      transaction.amount.should == Braintree::Test::TransactionAmounts::Authorize
+      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+    
+    it "raises a ValidationsFailed if invalid" do
+      expect do
+        Braintree::Transaction.sale!(
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
+  describe "self.submit_for_settlement" do
+    it "returns a successful result if successful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      result = Braintree::Transaction.submit_for_settlement(transaction.id)
+      result.success?.should == true
+    end
+
+    it "can submit a specific amount for settlement" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      result = Braintree::Transaction.submit_for_settlement(transaction.id, "999.99")
+      result.success?.should == true
+      result.transaction.amount.should == "999.99"
+      result.transaction.status.should == "submitted_for_settlement"
+      result.transaction.updated_at.between?(Time.now - 5, Time.now).should == true
+    end
+
+    it "returns an error result if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      result = Braintree::Transaction.submit_for_settlement(transaction.id, "1000.01")
+      result.success?.should == false
+      result.errors.for(:transaction).on(:amount)[0].message.should == "Settlement amount cannot be more than the authorized amount."
+      result.params[:transaction][:amount].should == "1000.01"
+    end
+  end
+
+  describe "self.submit_for_settlement!" do
+    it "returns the transaction if successful" do
+      original_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction = Braintree::Transaction.submit_for_settlement!(original_transaction.id)
+      transaction.status.should == "submitted_for_settlement"
+      transaction.id.should == original_transaction.id
+    end
+
+    it "raises a ValidationsFailed if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      expect do
+        Braintree::Transaction.submit_for_settlement!(transaction.id, "1000.01")
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+  
+  describe "self.credit" do
+    it "returns a successful result with type=credit if successful" do
+      result = Braintree::Transaction.credit(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.id.should =~ /^\w{6}$/
+      result.transaction.type.should == "credit"
+      result.transaction.amount.should == Braintree::Test::TransactionAmounts::Authorize
+      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      result.transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+    
+    it "returns an error result if validations fail" do
+      params = {
+        :transaction => {
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.credit(params[:transaction])
+      result.success?.should == false
+      result.params.should == {:transaction => {:type => 'credit', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
+      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+    end
+  end
+  
+  describe "self.credit!" do
+    it "returns the transaction if valid" do
+      transaction = Braintree::Transaction.credit!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.id.should =~ /^\w{6}$/
+      transaction.type.should == "credit"
+      transaction.amount.should == Braintree::Test::TransactionAmounts::Authorize
+      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+    
+    it "raises a ValidationsFailed if invalid" do
+      expect do
+        Braintree::Transaction.credit!(
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+  
+  describe "self.create_from_transparent_redirect" do
+    it "returns a successful result if successful" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      tr_data_params = {
+        :transaction => {
+          :type => "sale"
+        }
+      }
+      query_string_response = create_transaction_via_tr(params, tr_data_params)
+      result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.type.should == "sale"
+      transaction.amount.should == "1000.00"
+      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+      transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+
+    it "returns an error result if validations fail" do
+      params = {
+        :transaction => {
+          :amount => "",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      tr_data_params = {
+        :transaction => {
+          :type => "sale"
+        }
+      }
+      query_string_response = create_transaction_via_tr(params, tr_data_params)
+      result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
+      result.success?.should == false
+      result.params[:transaction].should == {:amount => "", :type => "sale", :credit_card => {:expiration_date => "05/2009"}}
+      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+    end
+  end
+  
+  describe "self.find" do
+    it "finds the transaction with the given id" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      created_transaction = result.transaction
+      found_transaction = Braintree::Transaction.find(created_transaction.id)
+      found_transaction.should == created_transaction
+    end
+
+    it "raises a NotFoundError exception if transaction cannot be found" do
+      expect do
+        Braintree::Transaction.find("invalid-id")
+      end.to raise_error(Braintree::NotFoundError, 'transaction with id "invalid-id" not found')
+    end
+  end
+
+  describe "self.void" do
+    it "returns a successful result if successful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result = Braintree::Transaction.void(transaction.id)
+      result.success?.should == true
+      result.transaction.id.should == transaction.id
+      result.transaction.status.should == "voided"
+    end
+
+    it "returns an error result if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result = Braintree::Transaction.void(transaction.id)
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].message.should == "Transaction can only be voided if status is authorized or submitted_for_settlement."
+    end
+  end
+
+  describe "void!" do
+    it "returns the transaction if successful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      returned_transaction = Braintree::Transaction.void!(transaction.id)
+      returned_transaction.should == transaction
+      returned_transaction.status.should == "voided"
+    end
+
+    it "raises a ValidationsFailed if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      expect do
+        Braintree::Transaction.void!(transaction.id)
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+  
+  describe "refund" do
+    it "returns a successful result if successful" do
+      transaction = find_transaction_to_refund
+      result = transaction.refund
+      result.success?.should == true
+      result.new_transaction.type.should == "credit"
+    end
+
+    it "returns an error result if unsuccessful" do
+      transaction = Braintree::Transaction.create!(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result = transaction.refund
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].message.should == "Cannot refund a transaction unless it is settled."
+    end
+  end
+
+  describe "submit_for_settlement" do
+    it "returns a successful result if successful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      result = transaction.submit_for_settlement
+      result.success?.should == true
+    end
+
+    it "can submit a specific amount for settlement" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      result = transaction.submit_for_settlement("999.99")
+      result.success?.should == true
+      transaction.amount.should == "999.99"
+    end
+
+    it "updates the transaction attributes" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      result = transaction.submit_for_settlement("999.99")
+      result.success?.should == true
+      transaction.amount.should == "999.99"
+      transaction.status.should == "submitted_for_settlement"
+      transaction.updated_at.between?(Time.now - 5, Time.now).should == true
+    end
+
+    it "returns an error result if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      result = transaction.submit_for_settlement("1000.01")
+      result.success?.should == false
+      result.errors.for(:transaction).on(:amount)[0].message.should == "Settlement amount cannot be more than the authorized amount."
+      result.params[:transaction][:amount].should == "1000.01"
+    end
+  end
+
+  describe "submit_for_settlement!" do
+    it "returns the transaction if successful" do
+      original_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction = original_transaction.submit_for_settlement!
+      transaction.status.should == "submitted_for_settlement"
+      transaction.id.should == original_transaction.id
+    end
+
+    it "raises a ValidationsFailed if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      transaction.amount.should == "1000.00"
+      expect do
+        transaction.submit_for_settlement!("1000.01")
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+  
+  describe "search" do
+    describe "advanced" do
+      it "pretty much works in one big fell swoop/hash" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :order_id => "123",
+          :customer => {
+            :company => "Apple",
+            :fax => "312-555-1234",
+            :first_name => "Steve",
+            :last_name => "Jobs",
+            :phone => "614-555-1234",
+            :website => "http://www.apple.com",
+          },
+          :billing => {
+            :country_name => "United States of America",
+            :extended_address => "Apt 1F",
+            :locality => "Chicago",
+            :postal_code => "60622",
+            :region => "Illinois",
+            :street_address => "1234 W North Ave",
+          },
+          :shipping => {
+            :country_name => "United States of America",
+            :extended_address => "Apt 123",
+            :locality => "Bartlett",
+            :postal_code => "60004",
+            :region => "Illinois",
+            :street_address => "123 Main St",
+          }
+        )
+        result.success?.should == true
+        expected_transaction = result.transaction
+        search_criteria = {
+          :billing_country_name => {:is => "United States of America"},
+          :billing_extended_address => {:is => "Apt 1F"},
+          :billing_locality => {:is => "Chicago"},
+          :billing_postal_code => {:is => "60622"},
+          :billing_region => {:is => "Illinois"},
+          :billing_street_address => {:is => "1234 W North Ave"},
+          :credit_card_number => {:is => Braintree::Test::CreditCardNumbers::Visa},
+          :customer_company => {:is => "Apple"},
+          :customer_fax => {:is => "312-555-1234"},
+          :customer_first_name => {:is => "Steve"},
+          :customer_last_name => {:is => "Jobs"},
+          :customer_phone => {:is => "614-555-1234"},
+          :customer_website => {:is => "http://www.apple.com"},
+          :expiration_date => {:is => "05/2009"},
+          :order_id => {:is => "123"},
+          :shipping_country_name => {:is => "United States of America"},
+          :shipping_extended_address => {:is => "Apt 123"},
+          :shipping_locality => {:is => "Bartlett"},
+          :shipping_postal_code => {:is => "60004"},
+          :shipping_region => {:is => "Illinois"},
+          :shipping_street_address => {:is => "123 Main St"},
+        }
+        search_results = Braintree::Transaction.search(search_criteria)
+        search_results.should include(expected_transaction)
+      end
+
+      it "properly parses the xml if only one transaction is found" do
+        transaction = Braintree::Transaction.create!(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        )
+        search_results = Braintree::Transaction.search(:transaction_id => {:is => transaction.id})
+        search_results.total_items.should == 1
+        search_results[0].should == transaction
+      end
+    end
+
+    describe "basic" do
+      it "returns paged transactions matching the given search terms" do
+        transactions = Braintree::Transaction.search "1111"
+        transactions.total_items.should > 0
+      end
+    
+      it "is paged" do
+        transactions = Braintree::Transaction.search "1111", :page => 2
+        transactions.current_page_number.should == 2
+      end
+    
+      it "can traverse pages" do
+        transactions = Braintree::Transaction.search "1111", :page => 1
+        transactions.next_page.current_page_number.should == 2
+      end
+    end
+  end
+  
+  describe "vault_credit_card" do
+    it "returns the Braintree::CreditCard if the transaction credit card is stored in the vault" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+      transaction = customer.credit_cards[0].sale(:amount => "100.00").transaction
+      transaction.vault_credit_card.should == customer.credit_cards[0]
+    end
+    
+    it "returns nil if the transaction credit card is not stored in the vault" do
+      transaction = Braintree::Transaction.create!(
+        :amount => "100.00",
+        :type => "sale",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+      transaction.vault_credit_card.should == nil
+    end
+  end
+
+  describe "vault_customer" do
+    it "returns the Braintree::Customer if the transaction customer is stored in the vault" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+      transaction = customer.credit_cards[0].sale(:amount => "100.00").transaction
+      transaction.vault_customer.should == customer
+    end
+    
+    it "returns nil if the transaction customer is not stored in the vault" do
+      transaction = Braintree::Transaction.create!(
+        :amount => "100.00",
+        :type => "sale",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+      transaction.vault_customer.should == nil
+    end
+  end
+  
+  describe "void" do
+    it "returns a successful result if successful" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.status.should == "authorized"
+      void_result = transaction.void
+      void_result.success?.should == true
+      void_result.transaction.should == transaction
+      transaction.status.should == void_result.transaction.status
+    end
+
+    it "returns an error result if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.status.should == "processor_declined"
+      result = transaction.void
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].message.should == "Transaction can only be voided if status is authorized or submitted_for_settlement."
+    end
+  end
+
+  describe "void!" do
+    it "returns the transaction if successful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.void!.should == transaction
+      transaction.status.should == "voided"
+    end
+
+    it "raises a ValidationsFailed if unsuccessful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.status.should == "processor_declined"
+      expect do
+        transaction.void!
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
+  def create_transaction_via_tr(params, tr_data_params)
+    response = nil
+    Net::HTTP.start(Braintree::Configuration.server, Braintree::Configuration.port) do |http|
+      request = Net::HTTP::Post.new("/" + Braintree::Transaction.create_transaction_url.split("/", 4)[3])
+      request.add_field "Content-Type", "application/x-www-form-urlencoded"
+      params = {
+        :tr_data => Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://testing.com"}.merge(tr_data_params))
+      }.merge(params)
+      request.body = Braintree::Util.hash_to_query_string(params)
+      response = http.request(request)
+    end
+    query_string = response["Location"].split("?", 2).last  
+    query_string
+  end
+
+  def find_transaction_to_refund
+    settled_transactions = Braintree::Transaction.search "settled"
+    found = settled_transactions.detect do |t|
+      t.status == "settled" && !t.refunded?
+    end
+    found || raise("unfortunately your test is not as you intended because we could not find a settled transaction that hasn't already been refunded")
+  end
+end