spreedly_core 0.0.4 → 0.1.1

data/README.md

@@ -26,8 +26,8 @@ RubyGems:
 See the [quickstart guide](https://spreedlycore.com/manual/quickstart) for
 information regarding tokens.
 
-We'll now lookup the payment method stored on SpreedlyCore using token param
-from the transparent redirect url
+We'll now look up the payment method stored on SpreedlyCore using token param
+from the transparent redirect URL
  
     payment_token = SpreedlyCore::PaymentMethod.find(payment_token)
     transaction = payment_token.purchase(100)
@@ -71,6 +71,9 @@ Using spreedly_core in irb:
     require 'spreedly_core'
     require 'spreedly_core/test_extensions' # allow creating payment methods from the command line
     SpreedlyCore.configure("Your API Login", "Your API Secret", "Test Gateway Token")
+    # or if loading from YAML for example, configure takes a hash as well
+    SpreedlyCore.configure(:login => "Your API Login", :secret => "Your API Secret",
+                           :token => "Test Gateway Token")       
     master_card_data = SpreedlyCore::TestHelper.cc_data(:master)
     token = SpreedlyCore::PaymentMethod.create_test_token(master_card_data)
 
@@ -122,12 +125,36 @@ Credit part of a previous purchase:
     purchase_transaction.credit(50) # provide a partial credit
     purchase_transaction.succeeded? # true 
 
+Handling Exceptions:
+
+There are 2 types of exceptions which can be raised by the library:
+
+  1.  SpreedlyCore::TimeOutError is raised if communication with SpreedlyCore
+      takes longer than 10 seconds     
+  2.  SpreedlyCore::InvalidResponse is raised when the response code is
+      unexpected (I.E. we expect a HTTP response code of 200 bunt instead got a
+      500) or if the response does not contain an expected attribute. For
+      example, the response from retaining a payment method should contain an XML
+      attribute of "transaction". If this is not found (for example a HTTP
+      response 404 or 500 is returned), then an InvalidResponse is raised.
+
+      
+Both TimeOutError and InvalidResponse subclass SpreedlyCore::Error.
+
+Look up a payment method that does not exist:
+
+    begin
+      payment_method = SpreedlyCore::PaymentMethod.find("NOT-FOUND")
+    rescue SpreedlyCore::InvalidResponse => e
+      puts e.inspect
+    end  
+
    
 Additional Field Validation
 ----------
 
 
-The Spreedyly Core API provides validation of the credit card number, cve, and
+The Spreedyly Core API provides validation of the credit card number, CVE, and
 first and last name. In most cases this is enough, however sometimes you want to
 enforce the billing information as well. This can be accomplished via:
 
@@ -167,7 +194,7 @@ Inside your Rails project create config/spreedly_core.yml formatted like config/
 Then create config/initializers/spreedly_core.rb with the following:
 
     config = YAML.load(File.read(RAILS_ROOT + '/config/spreedly_core.yml'))[RAILS_ENV]
-    SpreedlyCore.configure(config['login'], config['secret'], config['gateway_token'])
+    SpreedlyCore.configure(config)
 
 Optionally require additional credit card fields:
 

data/Rakefile

@@ -1,3 +1,4 @@
+require "bundler/gem_tasks"
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |test|

data/lib/spreedly_core.rb

@@ -16,12 +16,36 @@ module SpreedlyCore
     "Discover" => "discover"
   }
 
+  class Error < RuntimeError; end
   # Custom exception which occurs when a request to SpreedlyCore times out
   # See SpreedlyCore::Base.default_timeout 
-  class TimeOutError < RuntimeError; end
+  class TimeOutError < Error; end
+  class InvalidResponse < Error
+    def initialize(response, message)
+      super("#{message}\nResponse:\n#{response.inspect}")
+    end
+  end
 
   # Configure SpreedlyCore with a particular account and default gateway
-  def self.configure(login, secret, gateway_token)
+  # If the first argume is a hash, 'login', 'secret', and 'gateway_token'
+  # keys are expected. Otherwise *args is expected to be login, secret,
+  # and gateway_token
+  def self.configure(*args)
+    login_or_hash, secret, gateway_token, *rest = args
+    if login_or_hash.is_a?(Hash)
+
+      # convert symbols to strings
+      login_or_hash.each{|k,v| login_or_hash[k.to_s] = v }
+
+      login = login_or_hash['login']
+      secret = login_or_hash['secret']
+      gateway_token = login_or_hash['gateway_token']
+    else
+      login = login_or_hash
+    end
+    if login.nil? || secret.nil? || gateway_token.nil?
+      raise ArgumentError.new("You must provide a login, secret, and gateway_token")
+    end
     Base.configure(login, secret, gateway_token)
   end
 

data/lib/spreedly_core/base.rb

@@ -16,7 +16,7 @@ module SpreedlyCore
 
     def self.configure(login, secret, gateway_token)
       @@login = login
-      self.basic_auth(login, secret)
+      self.basic_auth(@@login, secret)
       @@gateway_token = gateway_token
     end
 
@@ -59,16 +59,16 @@ module SpreedlyCore
         raise TimeOutError.new("Request to #{path} timed out. Is Spreedly Core down?")
       end
         
-      if allowed_codes.any?
-        if allowed_codes.include?(response.code)
-          block.call(response)
-        else
-          raise "Error retrieving #{path}. Got status of #{response.code}. Expected status to be in #{allowed_codes.join(",")}\n#{response.body}"
-        end
-      else
-        block.call(response).tap do |obj|
-          obj.instance_variable_set("@http_code", response.code)
-        end
+      if allowed_codes.any? && !allowed_codes.include?(response.code)
+        raise InvalidResponse.new(response, "Error retrieving #{path}. Got status of #{response.code}. Expected status to be in #{allowed_codes.join(",")}")
+      end
+
+      if options.has_key?(:has_key) && !response.parsed_response.has_key?(options[:has_key])
+        raise InvalidResponse.new(response, "Expected parsed response to contain key '#{options[:has_key]}'")
+      end
+
+      block.call(response).tap do |obj|
+        obj.instance_variable_set("@http_code", response.code)
       end
     end
 

data/lib/spreedly_core/payment_method.rb

@@ -19,7 +19,8 @@ module SpreedlyCore
     # Lookup the PaymentMethod by token
     def self.find(token)
       return nil if token.nil? 
-      verify_get("/payment_methods/#{token}.xml") do |response|
+      verify_get("/payment_methods/#{token}.xml",
+                 :has_key => "payment_method") do |response|
         new(response.parsed_response["payment_method"])
       end
     end
@@ -32,14 +33,16 @@ module SpreedlyCore
 
     # Retain the payment method
     def retain
-      self.class.verify_put("/payment_methods/#{token}/retain.xml", :body => {}) do |response|
+      self.class.verify_put("/payment_methods/#{token}/retain.xml",
+                            :body => {}, :has_key => "transaction") do |response|
         RetainTransaction.new(response.parsed_response["transaction"])
       end
     end
 
     # Redact the payment method
     def redact
-      self.class.verify_put("/payment_methods/#{token}/redact.xml", :body => {}) do |response|
+      self.class.verify_put("/payment_methods/#{token}/redact.xml",
+                            :body => {}, :has_key => "transaction") do |response|
         RedactTransaction.new(response.parsed_response["transaction"])
       end
     end
@@ -101,7 +104,8 @@ module SpreedlyCore
           :ip => ip_address
         }
       }
-      self.class.verify_post(path, :body => data) do |response|
+      self.class.verify_post(path, :body => data,
+                             :has_key => "transaction") do |response|
         klass = SpreedlyCore.const_get("#{transaction_type.capitalize}Transaction")
         klass.new(response.parsed_response["transaction"])
       end

data/lib/spreedly_core/test_extensions.rb

@@ -28,18 +28,23 @@ end
 
 module SpreedlyCore
   class PaymentMethod
-    def self.create_test_token(cc_data={})
+
+    # Call spreedly core to create a test token.
+    # pass_through_data will be added as the "data" field.
+    # 
+    def self.create_test_token(cc_data={}, pass_through_data=nil)
       data = cc_data.merge(:redirect_url => "http://example.com",
-                           :api_login => SpreedlyCore::Base.login)
+                           :api_login => SpreedlyCore::Base.login,
+                           :data => pass_through_data)
       
       response = self.post("/payment_methods", :body => data, :no_follow => true)
     rescue HTTParty::RedirectionTooDeep => e
       if e.response.body =~ /href="(.*?)"/
-        # rescuing the redirection too deep is apparently the way to
+        # rescuing the RedirectionTooDeep exception is apparently the way to
         # handle redirect following
         token = CGI::parse(URI.parse($1).query)["token"].first
       end
-      raise "Could not find token in body: #{response}" if token.nil?
+      raise "Could not find token in body: #{e.response.body}" if token.nil?
       return token
     end
   end

data/lib/spreedly_core/transactions.rb

@@ -16,7 +16,7 @@ module SpreedlyCore
     # Lookup the transaction by its token. Returns the correct subclass
     def self.find(token)
       return nil if token.nil? 
-      verify_get("/transactions/#{token}.xml") do |response|
+      verify_get("/transactions/#{token}.xml", :has_key => "transaction") do |response|
         attrs = response.parsed_response["transaction"]
         klass = @@transaction_type_to_class[attrs["transaction_type"]] || self
         klass.new(attrs)
@@ -33,6 +33,7 @@ module SpreedlyCore
       super(attrs)
     end
   end
+  
   class RedactTransaction < Transaction
     handles "RedactPaymentMethod"
     attr_reader :payment_method
@@ -49,7 +50,7 @@ module SpreedlyCore
     def void(ip_address=nil)
       body = {:transaction => {:ip => ip_address}}
       self.class.verify_post("/transactions/#{token}/void.xml",
-                             :body => body) do |response|
+                             :body => body, :has_key => "transaction") do |response|
         VoidedTransaction.new(response.parsed_response["transaction"])
       end      
     end
@@ -63,7 +64,7 @@ module SpreedlyCore
                {:transaction => {:amount => amount, :ip => ip_address}}
              end
       self.class.verify_post("/transactions/#{token}/credit.xml",
-                             :body => body) do |response|
+                             :body => body, :has_key => "transaction") do |response|
         CreditTransaction.new(response.parsed_response["transaction"])
       end
     end
@@ -96,7 +97,7 @@ module SpreedlyCore
                {:transaction => {:amount => amount, :ip => ip_address}}
              end
       self.class.verify_post("/transactions/#{token}/capture.xml",
-                            :body => body) do |response|
+                            :body => body, :has_key => "transaction") do |response|
         CaptureTransaction.new(response.parsed_response["transaction"])
       end
     end

data/lib/spreedly_core/version.rb

@@ -1,3 +1,3 @@
 module SpreedlyCore
-  Version = VERSION = "0.0.4"
+  Version = VERSION = "0.1.1"
 end

data/test/config/spreedly_core.yml

@@ -1,3 +1,3 @@
 login: 'Ud8NWIpG66s5ki5EX1n3ijCdGCe'
 secret: 'lS1jRuOr642CapweB4Au74oM48k9et935YXluG2Gd9sj0qCedUfG44qT3F1HNFnt'
-gateway_token: 'AY801m8Y2VIIIL56bwX3z0ac2db'
+gateway_token: 'JncEWj22g59t3CRB1VnPXmUUgKc'

data/test/configuration_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module SpreedlyCore
+  class ConfigureTest < Test::Unit::TestCase
+
+    def test_configure
+      SpreedlyCore.configure :login => "test",
+                             :secret => "secret",
+                             :gateway_token => "token"
+  
+      SpreedlyCore.configure 'login' => 'test',
+                             'secret' => 'secret',
+                             'gateway_token' => 'token'
+  
+      SpreedlyCore.configure 'test', 'secret', 'token'
+  
+      assert_raises ArgumentError do
+        SpreedlyCore.configure
+      end
+
+      assert_raises ArgumentError do
+        SpreedlyCore.configure {}
+      end
+    end
+    
+  end
+end

data/test/factories.rb

@@ -0,0 +1,103 @@
+module SpreedlyCore
+  module Factory
+    def given_a_payment_method(cc_card=:master, card_options={})
+      token = SpreedlyCore::PaymentMethod.
+        create_test_token(cc_data(cc_card, card_options), "customer-42")
+      assert payment_method = SpreedlyCore::PaymentMethod.find(token)
+      assert_equal "customer-42", payment_method.data
+      assert_equal token, payment_method.token
+      payment_method
+    end
+  
+    def given_a_purchase(purchase_amount=100, ip_address='127.0.0.1')
+      payment_method = given_a_payment_method
+      assert transaction = payment_method.purchase(purchase_amount, nil, nil, ip_address=nil)
+      assert_equal purchase_amount, transaction.amount
+      assert_equal "USD", transaction.currency_code
+      assert_equal "Purchase", transaction.transaction_type
+      assert_equal ip_address, transaction.ip
+      assert transaction.succeeded?
+      transaction
+    end
+  
+    def given_a_retained_transaction
+      payment_method = given_a_payment_method
+      assert transaction = payment_method.retain
+      assert transaction.succeeded?
+      assert_equal "RetainPaymentMethod", transaction.transaction_type
+      transaction
+    end
+  
+    def given_a_redacted_transaction
+      retained_transaction = given_a_retained_transaction
+      assert payment_method = retained_transaction.payment_method
+      transaction = payment_method.redact
+      assert transaction.succeeded?
+      assert_equal "RedactPaymentMethod", transaction.transaction_type
+      assert !transaction.token.blank?
+      transaction
+    end
+  
+    def given_an_authorized_transaction(amount=100, ip_address='127.0.0.1')
+      payment_method = given_a_payment_method
+      assert transaction = payment_method.authorize(100, nil, nil, ip_address)
+      assert_equal 100, transaction.amount
+      assert_equal "USD", transaction.currency_code
+      assert_equal ip_address, transaction.ip
+      assert_equal SpreedlyCore::AuthorizeTransaction, transaction.class
+      transaction
+    end
+    
+    def given_a_capture(amount=100, ip_address='127.0.0.1')
+      transaction = given_an_authorized_transaction(amount, ip_address)
+      capture = transaction.capture(amount, ip_address)
+      assert capture.succeeded?
+      assert_equal amount, capture.amount
+      assert_equal "Capture", capture.transaction_type
+      assert_equal ip_address, capture.ip
+      assert_equal SpreedlyCore::CaptureTransaction, capture.class
+      capture
+    end
+  
+    def given_a_purchase_void(ip_address='127.0.0.1')
+      purchase = given_a_purchase
+      assert void = purchase.void(ip_address)
+      assert_equal purchase.token, void.reference_token
+      assert_equal ip_address, void.ip
+      assert void.succeeded?
+      void
+    end
+  
+    def given_a_capture_void(ip_address='127.0.0.1')
+      capture = given_a_capture
+      assert void = capture.void(ip_address)
+      assert_equal capture.token, void.reference_token
+      assert_equal ip_address, void.ip
+      assert void.succeeded?
+      void
+    end
+  
+    def given_a_purchase_credit(purchase_amount=100, credit_amount=100, ip_address='127.0.0.1')
+      purchase = given_a_purchase(purchase_amount, ip_address)
+      given_a_credit(purchase, credit_amount, ip_address)
+    end
+  
+    def given_a_capture_credit(capture_amount=100, credit_amount=100, ip_address='127.0.0.1')
+      capture = given_a_capture(capture_amount, ip_address)
+      given_a_credit(capture, credit_amount, ip_address)
+    end
+  
+    def given_a_credit(trans, credit_amount=100, ip_address='127.0.0.1')
+      assert credit = trans.credit(credit_amount, ip_address)
+      assert_equal trans.token, credit.reference_token
+      assert_equal credit_amount, credit.amount
+      assert_equal ip_address, credit.ip
+      assert credit.succeeded?
+      assert SpreedlyCore::CreditTransaction, credit.class
+      credit
+    end
+
+  
+
+  end
+end

data/test/spreedly_core_test.rb

@@ -1,244 +1,194 @@
-require "#{File.dirname(__FILE__)}/test_helper"
+require 'test_helper'
 
 
 # In order to run tests
 #  1. cp test/config/spreedly_core.yml.example to test/config/spreedly_core.yml
-#  2. Add your spreedly core credentials to test/config/spreedly_core.yml 
-class SpreedlyCoreTest < Test::Unit::TestCase
-  include SpreedlyCore::TestHelper
-
-  def setup
-    SpreedlyCore::PaymentMethod.reset_additional_required_cc_fields
-  end
-
-  def given_a_payment_method(cc_card=:master, card_options={})
-    token = SpreedlyCore::PaymentMethod.create_test_token(cc_data(cc_card, card_options))
-    assert payment_method = SpreedlyCore::PaymentMethod.find(token)
-    assert token, payment_method.token
-    payment_method
-  end
-
-  def given_a_purchase(purchase_amount=100, ip_address='127.0.0.1')
-    payment_method = given_a_payment_method
-    assert transaction = payment_method.purchase(purchase_amount, nil, nil, ip_address=nil)
-    assert_equal purchase_amount, transaction.amount
-    assert_equal "USD", transaction.currency_code
-    assert_equal "Purchase", transaction.transaction_type
-    assert_equal ip_address, transaction.ip
-    assert transaction.succeeded?
-    transaction
-  end
-
-  def given_a_retained_transaction
-    payment_method = given_a_payment_method
-    assert transaction = payment_method.retain
-    assert transaction.succeeded?
-    assert_equal "RetainPaymentMethod", transaction.transaction_type
-    transaction
-  end
-
-  def given_a_redacted_transaction
-    retained_transaction = given_a_retained_transaction
-    assert payment_method = retained_transaction.payment_method
-    transaction = payment_method.redact
-    assert transaction.succeeded?
-    assert_equal "RedactPaymentMethod", transaction.transaction_type
-    assert !transaction.token.blank?
-    transaction
-  end
-
-  def given_an_authorized_transaction(amount=100, ip_address='127.0.0.1')
-    payment_method = given_a_payment_method
-    assert transaction = payment_method.authorize(100, nil, nil, ip_address)
-    assert_equal 100, transaction.amount
-    assert_equal "USD", transaction.currency_code
-    assert_equal ip_address, transaction.ip
-    assert_equal SpreedlyCore::AuthorizeTransaction, transaction.class
-    transaction
-  end
+#  2. Add your spreedly core credentials to test/config/spreedly_core.yml
+module SpreedlyCore
+  class SpreedlyCoreTest < Test::Unit::TestCase
+    include TestHelper
+    include TestFactory
   
-  def given_a_capture(amount=100, ip_address='127.0.0.1')
-    transaction = given_an_authorized_transaction(amount, ip_address)
-    capture = transaction.capture(amount, ip_address)
-    assert capture.succeeded?
-    assert_equal amount, capture.amount
-    assert_equal "Capture", capture.transaction_type
-    assert_equal ip_address, capture.ip
-    assert_equal SpreedlyCore::CaptureTransaction, capture.class
-    capture
-  end
-
-  def given_a_purchase_void(ip_address='127.0.0.1')
-    purchase = given_a_purchase
-    assert void = purchase.void(ip_address)
-    assert_equal purchase.token, void.reference_token
-    assert_equal ip_address, void.ip
-    assert void.succeeded?
-    void
-  end
-
-  def given_a_capture_void(ip_address='127.0.0.1')
-    capture = given_a_capture
-    assert void = capture.void(ip_address)
-    assert_equal capture.token, void.reference_token
-    assert_equal ip_address, void.ip
-    assert void.succeeded?
-    void
-  end
-
-  def given_a_purchase_credit(purchase_amount=100, credit_amount=100, ip_address='127.0.0.1')
-    purchase = given_a_purchase(purchase_amount, ip_address)
-    given_a_credit(purchase, credit_amount, ip_address)
-  end
-
-  def given_a_capture_credit(capture_amount=100, credit_amount=100, ip_address='127.0.0.1')
-    capture = given_a_capture(capture_amount, ip_address)
-    given_a_credit(capture, credit_amount, ip_address)
-  end
-
-  def given_a_credit(trans, credit_amount=100, ip_address='127.0.0.1')
-    assert credit = trans.credit(credit_amount, ip_address)
-    assert_equal trans.token, credit.reference_token
-    assert_equal credit_amount, credit.amount
-    assert_equal ip_address, credit.ip
-    assert credit.succeeded?
-    assert SpreedlyCore::CreditTransaction, credit.class
-    credit
-  end
-
-
-
-  def test_can_get_payment_token
-    payment_method = given_a_payment_method(:master,
-                                            :credit_card => {:year => 2015})
-    assert_equal "John", payment_method.first_name
-    assert_equal "Foo", payment_method.last_name
-    assert_equal "XXX", payment_method.verification_value
-    assert payment_method.errors.empty?
-    assert_equal 4, payment_method.month
-    assert_equal 2015, payment_method.year
-  end
-
-  def test_can_retain_payment_method
-    given_a_retained_transaction
-  end
-
-  def test_can_redact_payment_method
-    given_a_redacted_transaction
-  end
-
-  def test_can_make_purchase
-    given_a_purchase
-  end
-
-  def test_can_authorize
-    given_an_authorized_transaction
-  end
-
-  def test_payment_failed
-    payment_method = given_a_payment_method(:master, :card_number => :failed)
-
-    assert transaction = payment_method.purchase(100)
-    assert !transaction.succeeded?
-    assert_equal("Unable to obtain a successful response from the gateway.",
-                 transaction.message)
-
-    assert_equal("Unable to process the transaction.", transaction.response.message)
-  end
-
-  def test_can_capture_after_authorize
-    given_a_capture
-  end
-
-  def test_can_capture_partial_after_authorize
-    given_a_capture 50
-  end
-
-  def test_can_void_after_purchase
-    given_a_purchase_void
-  end
-
-  def test_can_void_after_capture
-    given_a_capture_void
-  end
-
-  def test_can_credit_after_purchase
-    given_a_purchase_credit
-  end
-
-  def test_can_credit_partial_after_purchase
-    given_a_purchase_credit(100, 50)
-  end
+    def setup
+      config = YAML.load(File.read(File.dirname(__FILE__) + '/config/spreedly_core.yml'))
+      SpreedlyCore.configure(config)
+      PaymentMethod.reset_additional_required_cc_fields
+    end
+
+    def test_can_get_payment_token
+      payment_method = given_a_payment_method(:master,
+                                              :credit_card => {:year => 2015})
+      assert_equal "John", payment_method.first_name
+      assert_equal "Foo", payment_method.last_name
+      assert_equal "XXX", payment_method.verification_value
+      assert payment_method.errors.empty?
+      assert_equal 4, payment_method.month
+      assert_equal 2015, payment_method.year
+    end
   
-  def test_can_credit_after_capture
-    given_a_capture_credit
-  end
+    def test_can_find_payment_method
+      payment_method = given_a_payment_method
+      assert PaymentMethod.find(payment_method.token)
+    end
   
-  def test_can_credit_partial_after_capture
-    given_a_capture_credit(50, 25)
-  end
-
-  def test_find_returns_retain_transaction_type
-    retain = given_a_retained_transaction
-    assert_find_transaction(retain, SpreedlyCore::RetainTransaction)
-  end
-
-  def test_find_returns_redact_transaction_type
-    redact = given_a_redacted_transaction
-    assert_find_transaction(redact, SpreedlyCore::RedactTransaction)
-  end
-
-  def test_find_returns_authorize_transaction_type
-    authorize = given_an_authorized_transaction
-    assert_find_transaction(authorize, SpreedlyCore::AuthorizeTransaction)
-  end
-
-  def test_find_returns_purchase_transaction_type
-    purchase = given_a_purchase
-    assert_find_transaction(purchase, SpreedlyCore::PurchaseTransaction)
-  end
-
-  def test_find_returns_capture_transaction_type
-    capture = given_a_capture
-    assert_find_transaction(capture, SpreedlyCore::CaptureTransaction)
-  end
-
-  def test_find_returns_voided_transaction_type
-    void = given_a_capture_void
-    assert_find_transaction(void, SpreedlyCore::VoidedTransaction)
-  end
-
-  def test_find_returns_credit_transaction_type
-    credit = given_a_capture_credit
-    assert_find_transaction(credit, SpreedlyCore::CreditTransaction)
-  end
-
+    def test_not_found_payment_method
+      assert_raises InvalidResponse do
+        PaymentMethod.find("NOT-FOUND")
+      end
+    end
+    
+    def test_can_retain_payment_method
+      given_a_retained_transaction
+    end
   
-  def test_can_enforce_additional_payment_method_validations
-    SpreedlyCore::PaymentMethod.additional_required_cc_fields :state
-
-    token = SpreedlyCore::PaymentMethod.create_test_token(cc_data(:master))
-    assert payment_method = SpreedlyCore::PaymentMethod.find(token)
-    assert !payment_method.valid?
-    assert_equal 1, payment_method.errors.size
-
-    assert_equal "State can't be blank", payment_method.errors.first
-
-    token =  SpreedlyCore::PaymentMethod.
-      create_test_token(cc_data(:master, :credit_card => {:state => "IL"}))
-
-    assert payment_method = SpreedlyCore::PaymentMethod.find(token)
-
-    assert payment_method.valid?
-  end
-
-  def test_can_list_supported_gateways
-    assert SpreedlyCore::Gateway.supported_gateways.any?
-  end
-
-  protected
-  def assert_find_transaction(trans, expected_class)
-    assert actual = SpreedlyCore::Transaction.find(trans.token)
-    assert_equal expected_class, actual.class
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_retain
+      payment_method = given_a_payment_method
+      payment_method.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        payment_method.retain
+      end
+    end
+  
+    def test_can_not_retain_after_redact
+      retained_transaction = given_a_retained_transaction
+      payment_method = retained_transaction.payment_method
+      redact_transaction = payment_method.redact
+      assert redact_transaction.succeeded?
+      retained_transaction2 = payment_method.retain
+      assert_false retained_transaction2.succeeded?
+    end
+  
+    def test_can_redact_payment_method
+      given_a_redacted_transaction
+    end
+  
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_redact
+      payment_method = given_a_payment_method
+      payment_method.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        payment_method.redact
+      end
+    end
+  
+    def test_can_make_purchase
+      given_a_purchase
+    end
+  
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_purchase
+      payment_method = given_a_payment_method
+      payment_method.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        payment_method.purchase(20)
+      end
+    end
+  
+    def test_can_authorize
+      given_an_authorized_transaction
+    end
+  
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_authorize
+      payment_method = given_a_payment_method
+      payment_method.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        payment_method.authorize(20)
+      end
+    end
+  
+    def test_payment_failed
+      payment_method = given_a_payment_method(:master, :card_number => :failed)
+  
+      assert transaction = payment_method.purchase(100)
+      assert !transaction.succeeded?
+      assert_equal("Unable to obtain a successful response from the gateway.",
+                   transaction.message)
+  
+      assert_equal("Unable to process the transaction.", transaction.response.message)
+    end
+  
+    def test_can_capture_after_authorize
+      given_a_capture
+    end
+  
+    def test_can_capture_partial_after_authorize
+      given_a_capture 50
+    end
+  
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_capture_after_authorize
+      transaction = given_an_authorized_transaction
+      transaction.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        transaction.capture
+      end
+    end
+  
+    def test_can_void_after_purchase
+      given_a_purchase_void
+    end
+  
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_void
+      purchase = given_a_purchase
+      purchase.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        purchase.void
+      end
+    end
+  
+    def test_can_void_after_capture
+      given_a_capture_void
+    end
+  
+    def test_can_credit_after_purchase
+      given_a_purchase_credit
+    end
+  
+    # Here we change the token to get an invalid response from spreedly core
+    def test_bad_response_on_credit
+      purchase = given_a_purchase
+      purchase.instance_variable_set("@token", "NOT-FOUND")
+      assert_raises InvalidResponse do
+        purchase.credit
+      end
+    end
+  
+    def test_can_credit_partial_after_purchase
+      given_a_purchase_credit(100, 50)
+    end
+    
+    def test_can_credit_after_capture
+      given_a_capture_credit
+    end
+    
+    def test_can_credit_partial_after_capture
+      given_a_capture_credit(50, 25)
+    end
+  
+    
+    def test_can_enforce_additional_payment_method_validations
+      PaymentMethod.additional_required_cc_fields :state
+  
+      token = PaymentMethod.create_test_token(cc_data(:master))
+      assert payment_method = PaymentMethod.find(token)
+      assert !payment_method.valid?
+      assert_equal 1, payment_method.errors.size
+  
+      assert_equal "State can't be blank", payment_method.errors.first
+  
+      token =  PaymentMethod.
+        create_test_token(cc_data(:master, :credit_card => {:state => "IL"}))
+  
+      assert payment_method = PaymentMethod.find(token)
+  
+      assert payment_method.valid?
+    end
+  
+    def test_can_list_supported_gateways
+      assert Gateway.supported_gateways.any?
+    end
   end
 end

data/test/test_factory.rb

@@ -0,0 +1,99 @@
+module SpreedlyCore
+  module TestFactory
+    def given_a_payment_method(cc_card=:master, card_options={})
+      token = PaymentMethod.create_test_token cc_data(cc_card, card_options), "customer-42"
+      assert payment_method = PaymentMethod.find(token)
+      assert_equal "customer-42", payment_method.data
+      assert_equal token, payment_method.token
+      payment_method
+    end
+  
+    def given_a_purchase(purchase_amount=100, ip_address='127.0.0.1')
+      payment_method = given_a_payment_method
+      assert transaction = payment_method.purchase(purchase_amount, nil, nil, ip_address=nil)
+      assert_equal purchase_amount, transaction.amount
+      assert_equal "USD", transaction.currency_code
+      assert_equal "Purchase", transaction.transaction_type
+      assert_equal ip_address, transaction.ip
+      assert transaction.succeeded?
+      transaction
+    end
+  
+    def given_a_retained_transaction
+      payment_method = given_a_payment_method
+      assert transaction = payment_method.retain
+      assert transaction.succeeded?
+      assert_equal "RetainPaymentMethod", transaction.transaction_type
+      transaction
+    end
+  
+    def given_a_redacted_transaction
+      retained_transaction = given_a_retained_transaction
+      assert payment_method = retained_transaction.payment_method
+      transaction = payment_method.redact
+      assert transaction.succeeded?
+      assert_equal "RedactPaymentMethod", transaction.transaction_type
+      assert !transaction.token.blank?
+      transaction
+    end
+  
+    def given_an_authorized_transaction(amount=100, ip_address='127.0.0.1')
+      payment_method = given_a_payment_method
+      assert transaction = payment_method.authorize(100, nil, nil, ip_address)
+      assert_equal 100, transaction.amount
+      assert_equal "USD", transaction.currency_code
+      assert_equal ip_address, transaction.ip
+      assert_equal AuthorizeTransaction, transaction.class
+      transaction
+    end
+    
+    def given_a_capture(amount=100, ip_address='127.0.0.1')
+      transaction = given_an_authorized_transaction(amount, ip_address)
+      capture = transaction.capture(amount, ip_address)
+      assert capture.succeeded?
+      assert_equal amount, capture.amount
+      assert_equal "Capture", capture.transaction_type
+      assert_equal ip_address, capture.ip
+      assert_equal CaptureTransaction, capture.class
+      capture
+    end
+  
+    def given_a_purchase_void(ip_address='127.0.0.1')
+      purchase = given_a_purchase
+      assert void = purchase.void(ip_address)
+      assert_equal purchase.token, void.reference_token
+      assert_equal ip_address, void.ip
+      assert void.succeeded?
+      void
+    end
+  
+    def given_a_capture_void(ip_address='127.0.0.1')
+      capture = given_a_capture
+      assert void = capture.void(ip_address)
+      assert_equal capture.token, void.reference_token
+      assert_equal ip_address, void.ip
+      assert void.succeeded?
+      void
+    end
+  
+    def given_a_purchase_credit(purchase_amount=100, credit_amount=100, ip_address='127.0.0.1')
+      purchase = given_a_purchase(purchase_amount, ip_address)
+      given_a_credit(purchase, credit_amount, ip_address)
+    end
+  
+    def given_a_capture_credit(capture_amount=100, credit_amount=100, ip_address='127.0.0.1')
+      capture = given_a_capture(capture_amount, ip_address)
+      given_a_credit(capture, credit_amount, ip_address)
+    end
+  
+    def given_a_credit(trans, credit_amount=100, ip_address='127.0.0.1')
+      assert credit = trans.credit(credit_amount, ip_address)
+      assert_equal trans.token, credit.reference_token
+      assert_equal credit_amount, credit.amount
+      assert_equal ip_address, credit.ip
+      assert credit.succeeded?
+      assert CreditTransaction, credit.class
+      credit
+    end
+  end
+end

data/test/test_helper.rb

@@ -10,8 +10,10 @@ Bundler.require(:default, :development)
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'spreedly_core'
 require 'spreedly_core/test_extensions'
+require 'test_factory'
 
-
-config = YAML.load(File.read(File.dirname(__FILE__) + '/config/spreedly_core.yml'))
-SpreedlyCore.configure(config['login'], config['secret'], config['gateway_token'])
-
+class Test::Unit::TestCase
+  def assert_false(test, failure_message=nil)
+    assert(!test, failure_message)
+  end
+end

data/test/transaction_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module SpreedlyCore
+  class TransactionTest < Test::Unit::TestCase
+    include TestHelper
+    include TestFactory
+  
+    def setup
+      config = YAML.load(File.read(File.dirname(__FILE__) + '/config/spreedly_core.yml'))
+      SpreedlyCore.configure(config)
+      PaymentMethod.reset_additional_required_cc_fields
+    end
+
+    def test_not_found_transaction
+      assert_raises InvalidResponse do
+        Transaction.find("NOT-FOUND")
+      end
+    end
+    
+    def test_find_returns_retain_transaction_type
+      retain = given_a_retained_transaction
+      assert_find_transaction(retain, RetainTransaction)
+    end
+  
+    def test_find_returns_redact_transaction_type
+      redact = given_a_redacted_transaction
+      assert_find_transaction(redact, RedactTransaction)
+    end
+  
+    def test_find_returns_authorize_transaction_type
+      authorize = given_an_authorized_transaction
+      assert_find_transaction(authorize, AuthorizeTransaction)
+    end
+  
+    def test_find_returns_purchase_transaction_type
+      purchase = given_a_purchase
+      assert_find_transaction(purchase, PurchaseTransaction)
+    end
+  
+    def test_find_returns_capture_transaction_type
+      capture = given_a_capture
+      assert_find_transaction(capture, CaptureTransaction)
+    end
+  
+    def test_find_returns_voided_transaction_type
+      void = given_a_capture_void
+      assert_find_transaction(void, VoidedTransaction)
+    end
+  
+    def test_find_returns_credit_transaction_type
+      credit = given_a_capture_credit
+      assert_find_transaction(credit, CreditTransaction)
+    end
+
+    protected
+
+    def assert_find_transaction(trans, expected_class)
+      assert actual = Transaction.find(trans.token)
+      assert_equal expected_class, actual.class
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: spreedly_core
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 25
   prerelease: 
   segments: 
   - 0
-  - 0
-  - 4
-  version: 0.0.4
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - 403 Labs
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-13 00:00:00 -05:00
-default_executable: 
+date: 2012-02-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: httparty
@@ -85,9 +84,12 @@ files:
 - lib/spreedly_core.rb
 - test/config/spreedly_core.yml
 - test/config/spreedly_core.yml.example
+- test/configuration_test.rb
+- test/factories.rb
 - test/spreedly_core_test.rb
+- test/test_factory.rb
 - test/test_helper.rb
-has_rdoc: true
+- test/transaction_test.rb
 homepage: http://github.com/403labs/spreedly_core
 licenses: []
 
@@ -117,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Ruby API for Spreedly Core