braintree 1.0.0

data/spec/integration/spec_helper.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+require 'timeout'
+require 'socket'
+
+
+def start_ssl_server
+  web_server_pid_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "httpsd.pid"))
+
+  TCPSocket.class_eval do
+    def self.wait_for_service(options)
+      Timeout::timeout(options[:timeout] || 20) do
+        loop do
+          begin
+            socket = TCPSocket.new(options[:host], options[:port])
+            socket.close
+            return
+          rescue Errno::ECONNREFUSED
+            sleep 0.5
+          end
+        end
+      end
+    end
+  end
+
+  FileUtils.rm(web_server_pid_file) if File.exist?(web_server_pid_file)
+  command = File.expand_path(File.join(File.dirname(__FILE__), "..", "script", "httpsd.rb"))
+  #puts command
+  `#{command} #{web_server_pid_file}`
+  #puts "== waiting for web server - port: #{8433}"
+  TCPSocket.wait_for_service :host => "127.0.0.1", :port => 8443
+
+  yield
+
+  10.times { unless File.exists?(web_server_pid_file); sleep 1; end }
+  #puts "\n== killing web server - pid: #{File.read(web_server_pid_file).to_i}"
+  Process.kill "INT", File.read(web_server_pid_file).to_i
+end

data/spec/script/httpsd.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'webrick'
+require 'webrick/https'
+require 'openssl'
+
+private_key_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "ssl", "privateKey.key"))
+cert_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "ssl", "certificate.crt"))
+
+pkey = OpenSSL::PKey::RSA.new(File.read(private_key_file))
+cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
+
+pid_file = ARGV[0]
+
+s = WEBrick::HTTPServer.new(
+  :Port => 8443,
+  :Logger => WEBrick::Log::new(nil, WEBrick::Log::ERROR),
+  :DocumentRoot => File.join(File.dirname(__FILE__)),
+  :ServerType => WEBrick::Daemon,
+  :SSLEnable => true,
+  :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
+  :SSLCertificate => cert,
+  :SSLPrivateKey => pkey,
+  :SSLCertName => [ [ "CN",WEBrick::Utils::getservername ] ],
+  :StartCallback => proc { File.open(pid_file, "w") { |f| f.write $$.to_s }}
+)
+trap("INT"){ s.shutdown }
+s.start

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+unless defined?(SPEC_HELPER_LOADED)
+  SPEC_HELPER_LOADED = true
+
+  project_root = File.expand_path(File.dirname(__FILE__) + "/..")
+  require "rubygems"
+  gem "libxml-ruby", ENV["LIBXML_VERSION"] || "1.1.3"
+  gem "builder", ENV["BUILDER_VERSION"] || "2.1.2"
+  braintree_lib = "#{project_root}/lib"
+  $LOAD_PATH << braintree_lib
+  require "braintree"
+  
+  Braintree::Configuration.environment = :development
+  Braintree::Configuration.merchant_id = "integration_merchant_id"
+  Braintree::Configuration.public_key = "integration_public_key"
+  Braintree::Configuration.private_key = "integration_private_key"
+  Braintree::Configuration.logger = Logger.new("/dev/null")
+  Braintree::Configuration.logger.level = Logger::INFO
+
+  Spec::Runner.configure do |config|
+  end
+
+  module SpecHelper
+    def self.stub_time_dot_now(desired_time)
+      Time.class_eval do
+        class << self
+          alias original_now now
+        end  
+      end
+      (class << Time; self; end).class_eval do
+        define_method(:now) { desired_time }
+      end
+      yield
+    ensure
+      Time.class_eval do
+        class << self
+          alias now original_now
+        end  
+      end  
+    end
+  end
+end

data/spec/unit/braintree/address_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Address do
+  describe "==" do
+    it "returns true if given an address with the same id and customer_id" do
+      first = Braintree::Address._new(:customer_id => "c1", :id => 'a1')
+      second = Braintree::Address._new(:customer_id => "c1", :id => "a1")
+      
+      first.should == second
+      second.should == first
+    end
+    
+    it "returns false if given an address with a different id and the same customer_id" do
+      first = Braintree::Address._new(:customer_id => "c1", :id => "a1")
+      second = Braintree::Address._new(:customer_id => "c1", :id => "not a1")
+      
+      first.should_not == second
+      second.should_not == first
+    end
+    
+    it "returns false if given an address with a different customer_id and the same id" do
+      first = Braintree::Address._new(:customer_id => "c1", :id => "a1")
+      second = Braintree::Address._new(:customer_id => "not c1", :id => "a1")
+
+      first.should_not == second
+      second.should_not == first
+    end
+
+    it "returns false when not given an address" do
+      address = Braintree::Address._new(:id => "a1")
+      address.should_not == "not an address"
+    end
+  end
+
+  describe "self.create" do
+    it "raises an ArgumentError if not given a :customer_id" do
+      expect do
+        Braintree::Address.create({})
+      end.to raise_error(ArgumentError, "Expected hash to contain a :customer_id")
+    end
+
+    it "raises if customer id contains invalid chars" do
+      expect do
+        Braintree::Address.create(:customer_id => "invalid@chars")
+      end.to raise_error(ArgumentError, ":customer_id contains invalid characters")
+    end
+
+    it "raises an exception if hash includes an invalid key" do
+      expect do
+        Braintree::Address.create(:street_address => "123 E Main St", :invalid_key => "foo")
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+  
+  describe "self.update" do
+    it "raises an exception if hash includes an invalid key" do
+      expect do
+        Braintree::Address.update("customer_id", "address_id", :street_address => "456 E Main", :invalid_key => "foo")
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+
+  describe "self.find" do
+    it "raises an error if customer_id contains invalid chars" do
+      expect do
+        Braintree::Address.find("spaces not allowed", "address_id")
+      end.to raise_error(ArgumentError, "customer_id contains invalid characters")
+    end
+  end
+  
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::Address.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "update" do
+    it "raises an exception if hash includes an invalid key" do
+      expect do
+        Braintree::Address._new({}).update(:street_address => "456 E Main", :invalid_key2 => "foo")
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key2")
+    end
+  end
+end

data/spec/unit/braintree/configuration_spec.rb

@@ -0,0 +1,190 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Configuration do
+  
+  before do
+    @original_merchant_id = Braintree::Configuration.merchant_id
+    @original_public_key = Braintree::Configuration.public_key
+    @original_private_key = Braintree::Configuration.private_key
+    @original_environment = Braintree::Configuration.environment
+  end
+
+  after do
+    Braintree::Configuration.merchant_id = @original_merchant_id
+    Braintree::Configuration.public_key  = @original_public_key 
+    Braintree::Configuration.private_key = @original_private_key
+    Braintree::Configuration.environment = @original_environment
+  end
+  
+  describe "self.base_merchant_path" do
+    it "returns /merchants/{merchant_id}" do
+      Braintree::Configuration.base_merchant_path.should == "/merchants/integration_merchant_id"
+    end
+  end
+
+  describe "self.base_merchant_url" do
+    it "returns the expected url for the development env" do
+      Braintree::Configuration.environment = :development
+      Braintree::Configuration.base_merchant_url.should == "http://localhost:3000/merchants/integration_merchant_id"
+    end
+
+    it "returns the expected url for the sandbox env" do
+      Braintree::Configuration.environment = :sandbox
+      Braintree::Configuration.base_merchant_url.should == "https://sandbox.braintreegateway.com:443/merchants/integration_merchant_id"
+    end
+
+    it "returns the expected url for the production env" do
+      Braintree::Configuration.environment = :production
+      Braintree::Configuration.base_merchant_url.should == "https://www.braintreegateway.com:443/merchants/integration_merchant_id"
+    end
+  end
+
+  describe "self.ca_file" do
+    it "qa" do
+      Braintree::Configuration.environment = :qa
+      ca_file = Braintree::Configuration.ca_file
+      ca_file.should match(/valicert_ca.crt$/)
+      File.exists?(ca_file).should == true
+    end
+
+    it "sandbox" do
+      Braintree::Configuration.environment = :sandbox
+      ca_file = Braintree::Configuration.ca_file
+      ca_file.should match(/valicert_ca.crt$/)
+      File.exists?(ca_file).should == true
+    end
+
+    it "production" do
+      Braintree::Configuration.environment = :production
+      ca_file = Braintree::Configuration.ca_file
+      ca_file.should match(/securetrust_ca.crt$/)
+      File.exists?(ca_file).should == true
+    end
+  end
+
+  describe "self.environment" do
+    it "raises an exception if it hasn't been set yet" do
+      Braintree::Configuration.instance_variable_set(:@environment, nil)
+      expect do
+        Braintree::Configuration.environment
+      end.to raise_error(Braintree::ConfigurationError, "Braintree::Configuration.environment needs to be set")
+    end
+  end
+  
+  describe "self.environment=" do
+    it "raises an exception if the environment is invalid" do
+      expect do
+        Braintree::Configuration.environment = :invalid_environment
+      end.to raise_error(ArgumentError, ":invalid_environment is not a valid environment")
+    end
+  end
+  
+  describe "self.logger" do
+    it "defaults to logging to stdout with log_level info" do
+      begin
+        old_logger = Braintree::Configuration.logger
+        Braintree::Configuration.logger = nil
+        Braintree::Configuration.logger.level.should == Logger::INFO
+      ensure
+        Braintree::Configuration.logger = old_logger
+      end
+    end
+  end
+
+  describe "self.merchant_id" do
+    it "raises an exception if it hasn't been set yet" do
+      Braintree::Configuration.instance_variable_set(:@merchant_id, nil)
+      expect do
+        Braintree::Configuration.merchant_id
+      end.to raise_error(Braintree::ConfigurationError, "Braintree::Configuration.merchant_id needs to be set")
+    end
+  end
+  
+  describe "self.public_key" do
+    it "raises an exception if it hasn't been set yet" do
+      Braintree::Configuration.instance_variable_set(:@public_key, nil)
+      expect do
+        Braintree::Configuration.public_key
+      end.to raise_error(Braintree::ConfigurationError, "Braintree::Configuration.public_key needs to be set")
+    end
+  end
+
+  describe "self.private_key" do
+    it "raises an exception if it hasn't been set yet" do
+      Braintree::Configuration.instance_variable_set(:@private_key, nil)
+      expect do
+        Braintree::Configuration.private_key
+      end.to raise_error(Braintree::ConfigurationError, "Braintree::Configuration.private_key needs to be set")
+    end
+  end
+
+  describe "self.port" do
+    it "is 443 for production" do
+      Braintree::Configuration.environment = :production
+      Braintree::Configuration.port.should == 443
+    end
+
+    it "is 443 for sandbox" do
+      Braintree::Configuration.environment = :sandbox
+      Braintree::Configuration.port.should == 443
+    end
+
+    it "is 3000 for development" do
+      Braintree::Configuration.environment = :development
+      Braintree::Configuration.port.should == 3000
+    end
+  end
+
+  describe "self.protocol" do
+    it "is http for development" do
+      Braintree::Configuration.environment = :development      
+      Braintree::Configuration.protocol.should == "http"
+    end
+
+    it "is https for production" do
+      Braintree::Configuration.environment = :production      
+      Braintree::Configuration.protocol.should == "https"
+    end
+
+    it "is https for sandbox" do
+      Braintree::Configuration.environment = :sandbox
+      Braintree::Configuration.protocol.should == "https"
+    end
+
+  end
+
+  describe "self.server" do
+    it "is localhost for development" do
+      Braintree::Configuration.environment = :development
+      Braintree::Configuration.server.should == "localhost"
+    end
+
+    it "is www.braintreegateway.com for production" do
+      Braintree::Configuration.environment = :production
+      Braintree::Configuration.server.should == "www.braintreegateway.com"
+    end
+
+    it "is sandbox.braintreegateway.com for sandbox" do
+      Braintree::Configuration.environment = :sandbox
+      Braintree::Configuration.server.should == "sandbox.braintreegateway.com"
+    end
+  end
+  
+  describe "self.ssl?" do
+    it "returns false for development" do
+      Braintree::Configuration.environment = :development
+      Braintree::Configuration.ssl?.should == false
+    end
+
+    it "returns true for production" do
+      Braintree::Configuration.environment = :production
+      Braintree::Configuration.ssl?.should == true
+    end
+
+    it "returns true for sandbox" do
+      Braintree::Configuration.environment = :sandbox
+      Braintree::Configuration.ssl?.should == true
+    end
+  end
+  
+end

data/spec/unit/braintree/credit_card_spec.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::CreditCard do
+  describe "self.create" do
+    it "raises an exception if attributes contain an invalid key" do
+      expect do
+        Braintree::CreditCard.create(:invalid_key => 'val')
+      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::CreditCard.create_from_transparent_redirect("forged=query_string")
+      end.to raise_error(Braintree::ForgedQueryString)
+    end
+  end
+
+  describe "self.create_credit_card_url" do
+    it "returns the url" do
+      Braintree::CreditCard.create_credit_card_url.should == "http://localhost:3000/merchants/integration_merchant_id/payment_methods/all/create_via_transparent_redirect_request"
+    end
+  end  
+
+  describe "==" do
+    it "returns true if given a credit card with the same token" do
+      first = Braintree::CreditCard._new(:token => 123)
+      second = Braintree::CreditCard._new(:token => 123)
+      
+      first.should == second
+      second.should == first
+    end
+    
+    it "returns false if given a credit card with a different token" do
+      first = Braintree::CreditCard._new(:token => 123)
+      second = Braintree::CreditCard._new(:token => 124)
+      
+      first.should_not == second
+      second.should_not == first      
+    end
+    
+    it "returns false if not given a credit card" do
+      credit_card = Braintree::CreditCard._new(:token => 123)
+      credit_card.should_not == "not a credit card"
+    end
+  end
+  
+  describe "default?" do
+    it "is true if the credit card is the default credit card for the customer" do
+      Braintree::CreditCard._new(:default => true).default?.should == true
+    end
+    
+    it "is false if the credit card is not the default credit card for the customer" do
+      Braintree::CreditCard._new(:default => false).default?.should == false
+    end
+  end
+  
+  describe "expired?" do
+    it "is true if the payment method is this year and the month has passed" do
+      SpecHelper.stub_time_dot_now(Time.mktime(2009, 10, 20)) do
+        expired_pm = Braintree::CreditCard._new(:expiration_month => "09", :expiration_year => "2009")
+        expired_pm.expired?.should == true
+      end
+    end
+    
+    it "is true if the payment method is in a previous year" do
+      expired_pm = Braintree::CreditCard._new(:expiration_month => "12", :expiration_year => (Time.now.year - 1).to_s)
+      expired_pm.expired?.should == true
+    end
+    
+    it "is false if the payment method is not expired" do
+      not_expired_pm = Braintree::CreditCard._new(:expiration_month => "01", :expiration_year => (Time.now.year + 1).to_s)
+      not_expired_pm.expired?.should == false
+    end
+  end
+  
+  describe "inspect" do
+    it "includes the token first" do
+      output = Braintree::CreditCard._new(:token => "cc123").inspect
+      output.should include("#<Braintree::CreditCard token: \"cc123\",")
+    end
+
+    it "includes all customer attributes" do
+      credit_card = Braintree::CreditCard._new(
+        :bin => "411111",
+        :card_type => "Visa",
+        :cardholder_name => "John Miller",
+        :created_at => Time.now,
+        :customer_id => "cid1",
+        :expiration_month => "01",
+        :expiration_year => "2020",
+        :last_4 => "1111",
+        :token => "tok1",
+        :updated_at => Time.now
+      )
+      output = credit_card.inspect
+      output.should include(%q(bin: "411111"))
+      output.should include(%q(card_type: "Visa"))
+      output.should include(%q(cardholder_name: "John Miller"))
+
+      output.should include(%q(customer_id: "cid1"))
+      output.should include(%q(expiration_month: "01"))
+      output.should include(%q(expiration_year: "2020"))
+      output.should include(%q(last_4: "1111"))
+      output.should include(%q(token: "tok1"))
+      output.should include(%Q(updated_at: #{credit_card.updated_at.inspect}))
+      output.should include(%Q(created_at: #{credit_card.created_at.inspect}))
+    end
+  end
+  
+  describe "masked_number" do
+    it "uses the bin and last_4 to build the masked number" do
+      credit_card = Braintree::CreditCard._new(
+        :bin => "510510",
+        :last_4 => "5100"
+      )
+      credit_card.masked_number.should == "510510******5100"
+    end
+  end
+  
+  describe "self.update" do
+    it "raises an exception if attributes contain an invalid key" do
+      expect do
+        Braintree::CreditCard._new({}).update(:invalid_key => 'val')
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+  
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::CreditCard.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+end