braintree 1.0.0

data/spec/unit/braintree/ssl_expiration_check_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+# Helper method to confirm we have the right values
+def fetch_expiration_date(host, port=443)
+  cmd = "echo | openssl s_client -connect #{host}:#{port} 2>&1 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | openssl x509 -noout -subject -dates | grep notAfter"
+  date = `#{cmd}`.sub(/^.*=/, '')
+
+  Date.parse(date)
+end
+
+describe Braintree::SSLExpirationCheck do
+  SANDBOX = "sandbox.braintreegateway.com"
+  QA = "qa.braintreegateway.com"
+  PRODUCTION = "www.braintreegateway.com"
+
+  describe "check_dates" do
+    it "is done when the client library is loaded" do
+      Braintree::SSLExpirationCheck.ssl_expiration_dates_checked.should == true
+    end
+
+    describe "QA Cert" do
+      it "logs when the cert is expired" do
+        Braintree::SSLExpirationCheck.stub(:qa_expiration_date).and_return(Date.today - 1)
+
+        output = StringIO.new
+        Braintree::Configuration.logger = Logger.new(output)
+        Braintree::Configuration.logger.level = Logger::WARN
+
+        Braintree::SSLExpirationCheck.check_dates
+
+        output.string.should match(/\[Braintree\] The SSL Certificate for the QA environment will expire on \d{4}-\d{2}-\d{2}\. Please check for an updated client library\./)
+      end
+
+      it "logs when the cert is close to expiring" do
+        Braintree::SSLExpirationCheck.stub(:qa_expiration_date).and_return(Date.today)
+        output = StringIO.new
+        Braintree::Configuration.logger = Logger.new(output)
+        Braintree::Configuration.logger.level = Logger::WARN
+
+        Braintree::SSLExpirationCheck.check_dates
+
+        output.string.should match(/\[Braintree\] The SSL Certificate for the QA environment will expire on \d{4}-\d{2}-\d{2}\. Please check for an updated client library\./)
+      end
+
+      it "doesn't log when the cert is not expired" do
+        Braintree::SSLExpirationCheck.stub(:qa_expiration_date).and_return(Date.today + 365)
+        output = StringIO.new
+        Braintree::Configuration.logger = Logger.new(output)
+        Braintree::Configuration.logger.level = Logger::WARN
+
+        Braintree::SSLExpirationCheck.check_dates
+
+        output.string.should == ""
+      end
+    end
+
+    # We assume that testing logging for one is good enough for all, so we won't duplicate those tests from above
+    it "checks the sandbox cert" do
+        Braintree::SSLExpirationCheck.stub(:sandbox_expiration_date).and_return(Date.today)
+        output = StringIO.new
+        Braintree::Configuration.logger = Logger.new(output)
+        Braintree::Configuration.logger.level = Logger::WARN
+
+        Braintree::SSLExpirationCheck.check_dates
+
+        output.string.should match(/\[Braintree\] The SSL Certificate for the Sandbox environment will expire on \d{4}-\d{2}-\d{2}\. Please check for an updated client library\./)
+    end
+
+    xit "Patrick -- waiting on a production box -- checks the production server cert"
+  end
+
+  describe "production_expiration_date" do
+    xit "Patrick -- waiting on a production box -- is the date the production cert expires" do
+      Braintree::SSLExpirationCheck.production_expiration_date.should be_a(Date)
+      Braintree::SSLExpirationCheck.qa_expiration_date.should == fetch_expiration_date(PRODUCTION)
+    end
+  end
+
+  describe "qa_expiration_date" do
+    it "is the date the QA cert expires" do
+      Braintree::SSLExpirationCheck.qa_expiration_date.should be_a(Date)
+      Braintree::SSLExpirationCheck.qa_expiration_date.should == fetch_expiration_date(QA)
+    end
+  end
+
+  describe "sandbox_expiration_date" do
+    it "is the date the Sandbox cert expires" do
+      Braintree::SSLExpirationCheck.sandbox_expiration_date.should be_a(Date)
+      Braintree::SSLExpirationCheck.sandbox_expiration_date.should == fetch_expiration_date(SANDBOX)
+    end
+  end
+end

data/spec/unit/braintree/successful_result_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::SuccessfulResult do
+  describe "initialize" do
+    it "creates attr readers the values in the hash" do
+      result = Braintree::SuccessfulResult.new(
+        :foo => "foo_value",
+        :bar => "bar_value"
+      )
+      result.success?.should == true
+      result.foo.should == "foo_value"
+      result.bar.should == "bar_value"
+    end
+
+    it "can be initialized without any values" do
+      result = Braintree::SuccessfulResult.new
+      result.success?.should == true
+    end
+  end
+
+  describe "inspect" do
+    it "is pretty" do
+      result = Braintree::SuccessfulResult.new(:foo => "foo_value")
+      result.inspect.should == "#<Braintree::SuccessfulResult foo:\"foo_value\">"
+    end
+  end
+end

data/spec/unit/braintree/transaction/credit_card_details_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Braintree::Transaction::CreditCardDetails do
+  describe "expiration_date" do
+    it "concats expiration_month and expiration_year" do
+      details = Braintree::Transaction::CreditCardDetails.new(
+        :expiration_month => "08",
+        :expiration_year => "2009"
+      )
+      details.expiration_date.should == "08/2009"
+    end
+  end
+
+  describe "masked_number" do
+    it "concatenates the bin, some *'s, and the last_4" do
+      details = Braintree::Transaction::CreditCardDetails.new(
+        :bin => "510510", :last_4 => "5100"
+      )
+      details.masked_number.should == "510510******5100"
+    end
+  end
+end

data/spec/unit/braintree/transaction_spec.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Transaction do
+  describe "self.create" do
+    it "raises an exception if hash includes an invalid key" do
+      expect do
+        Braintree::Transaction.create(:amount => "Joe", :invalid_key => "foo")
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+
+  describe "self.create_from_transparent_redirect" do
+    it "raises an exception if the query string is forged" do
+      expect do
+        Braintree::Transaction.create_from_transparent_redirect("forged=query_string")
+      end.to raise_error(Braintree::ForgedQueryString)
+    end
+  end
+
+  describe "self.create_transaction_url" do
+    it "returns the url" do
+      Braintree::Transaction.create_transaction_url.should == "http://localhost:3000/merchants/integration_merchant_id/transactions/all/create_via_transparent_redirect_request"
+    end
+  end
+
+  describe "self.submit_for_settlement" do
+    it "raises an ArgumentError if transaction_id is an invalid format" do
+      expect do
+        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+      end.to raise_error(ArgumentError, "transaction_id is invalid")
+    end
+  end
+  
+  describe "initialize" do
+    it "sets up customer attributes in customer_details" do
+      transaction = Braintree::Transaction._new(
+        :customer => {
+          :id => "123",
+          :first_name => "Adam",
+          :last_name => "Taylor",
+          :company => "Ledner LLC",
+          :email => "adam.taylor@lednerllc.com",
+          :website => "lednerllc.com",
+          :phone => "1-999-652-4189 x56883",
+          :fax => "012-161-8055"
+        }
+      )
+      transaction.customer_details.id.should == "123"
+      transaction.customer_details.first_name.should == "Adam"
+      transaction.customer_details.last_name.should == "Taylor"
+      transaction.customer_details.company.should == "Ledner LLC"
+      transaction.customer_details.email.should == "adam.taylor@lednerllc.com"
+      transaction.customer_details.website.should == "lednerllc.com"
+      transaction.customer_details.phone.should == "1-999-652-4189 x56883"
+      transaction.customer_details.fax.should == "012-161-8055"
+    end
+    
+    it "sets up credit card attributes in credit_card_details" do
+      transaction = Braintree::Transaction._new(
+        :credit_card => {
+          :token => "mzg2",
+          :bin => "411111",
+          :last_4 => "1111",
+          :card_type => "Visa",
+          :expiration_month => "08",
+          :expiration_year => "2009",
+          :issuer_location => "US"
+        }
+      )
+      transaction.credit_card_details.token.should == "mzg2"
+      transaction.credit_card_details.bin.should == "411111"
+      transaction.credit_card_details.last_4.should == "1111"
+      transaction.credit_card_details.card_type.should == "Visa"
+      transaction.credit_card_details.expiration_month.should == "08"
+      transaction.credit_card_details.expiration_year.should == "2009"
+      transaction.credit_card_details.issuer_location.should == "US"
+    end
+
+    it "handles receiving custom as an empty string" do
+      transaction = Braintree::Transaction._new(
+        :custom => "\n    "
+      )
+    end
+  end
+  
+  describe "inspect" do
+    it "includes the id, type, amount, and status first" do
+      transaction = Braintree::Transaction._new(
+        :id => "1234",
+        :type => "sale",
+        :amount => "100.00",
+        :status => "authorized"
+      )
+      output = transaction.inspect
+      output.should include(%Q(#<Braintree::Transaction id: "1234", type: "sale", amount: "100.00", status: "authorized"))
+    end
+  end
+  
+  describe "==" do
+    it "returns true when it should" do
+      first = Braintree::Transaction._new(:id => 123)
+      second = Braintree::Transaction._new(:id => 123)
+      
+      first.should == second
+      second.should == first
+    end
+    
+    it "returns false when it should" do
+      first = Braintree::Transaction._new(:id => 123)
+      second = Braintree::Transaction._new(:id => 124)
+      
+      first.should_not == second
+      second.should_not == first      
+    end
+  end
+  
+  describe "new" do
+    it "is protected" do
+      expect do
+        Braintree::Transaction.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+  
+  describe "refunded?" do
+    it "is true if the transaciton has been refunded" do
+      transaction = Braintree::Transaction._new(:refund_id => "123")
+      transaction.refunded?.should == true
+    end
+
+    it "is false if the transaciton has not been refunded" do
+      transaction = Braintree::Transaction._new(:refund_id => nil)
+      transaction.refunded?.should == false
+    end
+  end
+end

data/spec/unit/braintree/transparent_redirect_spec.rb

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::TransparentRedirect do
+  describe "self.create_credit_card_data" do
+    it "raises an exception if any keys are invalid" do
+      expect do
+        Braintree::TransparentRedirect.create_credit_card_data(
+          :credit_card => {:number => "ok", :invalid_key => "bad"}
+        )
+      end.to raise_error(ArgumentError, "invalid keys: credit_card[invalid_key]")
+    end
+  end
+
+  describe "self.create_customer_data" do
+    it "raises an exception if any keys are invalid" do
+      expect do
+        Braintree::TransparentRedirect.create_customer_data(
+          :customer => {:first_name => "ok", :invalid_key => "bad"}
+        )
+      end.to raise_error(ArgumentError, "invalid keys: customer[invalid_key]")
+    end
+  end
+
+  describe "self.parse_and_validate_query_string" do
+    it "returns the parsed query string params if the hash is valid" do
+      query_string_without_hash = "one=1&two=2&http_status=200"
+      hash = Braintree::Digest.hexdigest(query_string_without_hash)
+      
+      query_string_with_hash = "#{query_string_without_hash}&hash=#{hash}"
+      result = Braintree::TransparentRedirect.parse_and_validate_query_string query_string_with_hash
+      result.should == {:one => "1", :two => "2", :http_status => "200", :hash => hash}
+    end
+    
+    it "raises Braintree::ForgedQueryString if the hash param is not valid" do
+      query_string_without_hash = "one=1&two=2"
+      hash = Digest::SHA1.hexdigest("invalid#{query_string_without_hash}")
+      
+      query_string_with_hash = "#{query_string_without_hash}&hash=#{hash}"
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string query_string_with_hash
+      end.to raise_error(Braintree::ForgedQueryString)
+    end
+    
+    it "raises Braintree::ForgedQueryString if hash is missing from the query string" do
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string "query_string=without_a_hash"
+      end.to raise_error(Braintree::ForgedQueryString)
+    end
+
+    it "raises an AuthenticationError if authentication fails" do
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=401")
+      end.to raise_error(Braintree::AuthenticationError)
+    end
+
+    it "raises an AuthorizationError if authorization fails" do
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=403")
+      end.to raise_error(Braintree::AuthorizationError)
+    end
+    
+    it "raises a ServerError if the server 500's" do
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=500")
+      end.to raise_error(Braintree::ServerError)
+    end
+
+    it "raises a DownForMaintenanceError if the server is down for maintenance" do
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=503")
+      end.to raise_error(Braintree::DownForMaintenanceError)
+    end
+    
+    it "raises an UnexpectedError if some other code is returned" do
+      expect do
+        Braintree::TransparentRedirect.parse_and_validate_query_string add_hash_to_query_string("http_status=600")
+      end.to raise_error(Braintree::UnexpectedError, "Unexpected HTTP_RESPONSE 600")
+    end
+  end
+
+  describe "self.transaction_data" do
+    it "raises an exception if any keys are invalid" do
+      expect do
+        Braintree::TransparentRedirect.transaction_data(
+          :transaction => {:amount => "100.00", :invalid_key => "bad"}
+        )
+      end.to raise_error(ArgumentError, "invalid keys: transaction[invalid_key]")
+    end
+    
+    it "raises an exception if not given a type" do
+      expect do
+        Braintree::TransparentRedirect.transaction_data(
+          :redirect_url => "http://example.com",
+          :transaction => {:amount => "100.00"}
+        )
+      end.to raise_error(ArgumentError, "expected transaction[type] of sale or credit, was: nil")
+    end
+    
+    it "raises an exception if not given a type of sale or credit" do
+      expect do
+        Braintree::TransparentRedirect.transaction_data(
+          :redirect_url => "http://example.com",
+          :transaction => {:amount => "100.00", :type => "auth"}
+        )
+      end.to raise_error(ArgumentError, "expected transaction[type] of sale or credit, was: \"auth\"")
+    end
+  end
+
+  describe "self.update_credit_card_data" do
+    it "raises an exception if any keys are invalid" do
+      expect do
+        Braintree::TransparentRedirect.update_credit_card_data(
+          :credit_card => {:number => "ok", :invalid_key => "bad"}
+        )
+      end.to raise_error(ArgumentError, "invalid keys: credit_card[invalid_key]")
+    end
+    
+    it "raises an exception if not given a payment_method_token" do
+      expect do
+        Braintree::TransparentRedirect.update_credit_card_data({})
+      end.to raise_error(ArgumentError, "expected params to contain :payment_method_token of payment method to update")
+    end
+  end
+  
+  describe "self.update_customer_data" do
+    it "raises an exception if any keys are invalid" do
+      expect do
+        Braintree::TransparentRedirect.update_customer_data(
+          :customer => {:first_name => "ok", :invalid_key => "bad"}
+        )
+      end.to raise_error(ArgumentError, "invalid keys: customer[invalid_key]")
+    end
+
+    it "raises an exception if not given a customer_id" do
+      expect do
+        Braintree::TransparentRedirect.update_customer_data({})
+      end.to raise_error(ArgumentError, "expected params to contain :customer_id of customer to update")
+    end
+  end
+
+  describe "self._data" do
+    it "raises an exception if :redirect_url isn't given" do
+      expect do
+        Braintree::TransparentRedirect._data(:redirect_url => nil)
+      end.to raise_error(ArgumentError, "expected params to contain :redirect_url")
+    end
+  end
+  
+  def add_hash_to_query_string(query_string_without_hash)
+    hash = Braintree::TransparentRedirect._hash(query_string_without_hash)
+    query_string_without_hash + "&hash=" + hash
+  end
+end
+

data/spec/unit/braintree/util_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Util do
+  describe "self.verify_keys" do
+    it "raises an exception if the hash contains an invalid key" do
+      expect do
+        Braintree::Util.verify_keys([:allowed], :allowed => "ok", :disallowed => "bad")
+      end.to raise_error(ArgumentError, "invalid keys: disallowed")
+    end
+
+    it "raises an exception with all keys listed if the hash contains invalid keys" do
+      expect do
+        Braintree::Util.verify_keys([:allowed], :allowed => "ok", :disallowed => "bad", "also_invalid" => true)
+      end.to raise_error(ArgumentError, "invalid keys: also_invalid, disallowed")
+    end
+    
+    it "raises an exception if a nested hash contains an invalid key" do
+      expect do
+        Braintree::Util.verify_keys(
+          [:allowed, {:nested => [:nested_allowed, :nested_allowed2]}],
+          :allowed => "ok",
+          :top_level_invalid => "bad",
+          :nested => {
+            :nested_allowed => "ok",
+            :nested_allowed2 => "also ok",
+            :nested_invalid => "bad"
+          }
+        )
+      end.to raise_error(ArgumentError, "invalid keys: nested[nested_invalid], top_level_invalid")
+    end
+    
+    it "raises an exception if a deeply nested hash contains an invalid key" do
+      expect do
+        Braintree::Util.verify_keys(
+          [:allowed, {:nested => [:nested_allowed, :nested_allowed2, {:deeply_allowed => [:super_deep_allowed]}]}],
+          :allowed => "ok",
+          :top_level_invalid => "bad",
+          :nested => {
+            :nested_allowed => "ok",
+            :nested_allowed2 => "also ok",
+            :nested_invalid => "bad",
+            :deeply_allowed => {
+              :super_deep_allowed => "yep",
+              :real_deep_invalid => "nope"
+            }
+          }
+        )
+      end.to raise_error(ArgumentError, "invalid keys: nested[deeply_allowed][real_deep_invalid], nested[nested_invalid], top_level_invalid")
+    end
+  end
+  
+  describe "self._flatten_hash_keys" do
+    it "flattens hash keys" do
+      Braintree::Util._flatten_hash_keys(:nested => {
+        :nested_allowed => "ok",
+        :nested_allowed2 => "also ok",
+        :nested_invalid => "bad"
+      }).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "nested[nested_invalid]"]
+    end
+  end
+
+  describe "self._flatten_valid_keys" do
+    it "flattens hash keys" do
+      Braintree::Util._flatten_valid_keys(
+        [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}]
+      ).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "top_level"]
+    end
+  end
+
+  describe "self.extract_attribute_as_array" do
+    it "delets the attribute from the hash" do
+      hash = {:foo => ["x"], :bar => :baz}
+      Braintree::Util.extract_attribute_as_array(hash, :foo)
+      hash.should == {:bar => :baz}
+    end
+
+    it "puts the attribute in an array if it's not an array" do
+      hash = {:foo => "x", :bar => :baz}
+      result = Braintree::Util.extract_attribute_as_array(hash, :foo)
+      result.should == ["x"]
+    end
+
+    it "returns the value if it's already an array" do
+      hash = {:foo => ["one", "two"], :bar => :baz}
+      result = Braintree::Util.extract_attribute_as_array(hash, :foo)
+      result.should == ["one", "two"]
+    end
+  end
+
+  describe "self.hash_to_query_string" do
+    it "generates a query string from the hash" do
+      hash = {:foo => {:key_one => "value_one", :key_two => "value_two"}}
+      Braintree::Util.hash_to_query_string(hash).should == "foo%5Bkey_one%5D=value_one&foo%5Bkey_two%5D=value_two"
+    end
+  end
+  
+  describe "self.parse_query_string" do
+    it "parses the query string" do
+      query_string = "foo=bar%20baz&hash=a1b2c3"
+      Braintree::Util.parse_query_string(query_string).should == {:foo => "bar baz", :hash => "a1b2c3"}
+    end
+  end
+
+  describe "self.raise_exception_for_status_code" do
+    it "raises an AuthenticationError if authentication fails" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(401)
+      end.to raise_error(Braintree::AuthenticationError)
+    end
+
+    it "raises an AuthorizationError if authorization fails" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(403)
+      end.to raise_error(Braintree::AuthorizationError)
+    end
+    
+    it "raises a ServerError if the server 500's" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(500)
+      end.to raise_error(Braintree::ServerError)
+    end
+
+    it "raises a DownForMaintenanceError if the server is down for maintenance" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(503)
+      end.to raise_error(Braintree::DownForMaintenanceError)
+    end
+    
+    it "raises an UnexpectedError if some other code is returned" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(600)
+      end.to raise_error(Braintree::UnexpectedError, "Unexpected HTTP_RESPONSE 600")
+    end
+  end
+
+  
+  describe "self.url_encode" do
+    it "url encodes the given text" do
+      Braintree::Util.url_encode("foo?bar").should == "foo%3Fbar"
+    end
+  end
+end