spreedly_core 0.0.2

data/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2011 403 Labs, LLC <http://www.403labs.com>
+
+SpreedlyCore library is free software: you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+SpreedlyCore library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
+General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

data/README.md

@@ -0,0 +1,186 @@
+SpreedlyCore
+======
+
+SpreedlyCore is a Ruby library for accessing the [Spreedly Core API](https://spreedlycore.com/).
+
+The beauty behind Spreedly Core is that you lower your
+[PCI Compliance](https://www.pcisecuritystandards.org/) risk 
+by storing credit card information on their service while still having access
+to make payments and credits. This is possible by having your customers POST their
+credit card info to the spreedly core service while embedding a transparent
+redirect URL back to your application. See "Submit payment form" on
+[the quick start guide](https://spreedlycore.com/manual/quickstart)
+how the magic happens.
+
+
+Quickstart
+----------
+
+RubyGems:
+
+    gem install spreedly_core
+    irb
+    require 'rubygems'
+    require 'spreedly_core'
+    SpreedlyCore.configure("Your API Login", "Your API Secret", "Test Gateway Token")
+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
+ 
+    payment_token = SpreedlyCore::PaymentMethod.find(payment_token)
+    transaction = payment_token.purchase(100)
+
+Test Integration
+----------
+    
+Since your web form handles the creation of payment methods on their service,
+integration testing can be a bit of a headache. No worries though:
+
+    require 'spreedly_core'
+    require 'spreedly_core/test_extensions'
+    SpreedlyCore.configure("Your API Login", "Your API Secret", "Test Gateway Token")
+    master_card_data = SpreedlyCore::TestHelper.cc_data(:master) # Lookup test credit card data
+    token = SpreedlyCore::PaymentMethod.create_test_token(master_card_data)
+
+You now have access to a payment method token, which can be used just like your
+application would use it. Note, you should use a test gateway since you are
+actually hitting the Spreedly Core service. Let's use the test credit card
+payment method to make a purchase:
+    
+    payment_method = SpreedlyCore::PaymentMethod.find(token)
+    purchase_transaction = payment_method.purchase(100)
+    purchase_transaction.succeeded? # true
+
+Let's now use a credit card that is configured to fail upon purchase:
+
+    master_card_data = SpreedlyCore::TestHelper.cc_data(:master, :card_type => :failed)
+    token = SpreedlyCore::PaymentMethod.create_test_token(master_card_data)
+    payment_method = SpreedlyCore::PaymentMethod.find(token)
+    purchase_transaction = payment_method.purchase(100)
+    purchase_transaction.succeeded? # false
+
+Other test cards available include :visa, :american_express, and :discover
+    
+Usage
+----------
+
+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")
+    master_card_data = SpreedlyCore::TestHelper.cc_data(:master)
+    token = SpreedlyCore::PaymentMethod.create_test_token(master_card_data)
+
+
+Look up a payment method:
+
+    payment_method = SpreedlyCore::PaymentMethod.find(token)
+
+Retain a payment method for later use:
+
+    retain_transaction = payment_method.retain
+    retain_transaction.succeeded? # true
+
+Redact a previously retained payment method:
+
+    redact_transaction = payment_method.redact
+    redact_transaction.succeeded?
+
+Make a purchase against a payment method:
+
+    purchase_transaction = payment_method.purchase(100) 
+    purchase_transaction.succeeded? # true
+
+Make an authorize request against a payment method, then capture the payment
+
+    authorize = payment_method.authorize(100)
+    authorize.succeeded? # true
+    capture = authorize.capture(50) # Capture only half of the authorized amount
+    capture.succeeded? # true
+
+    authorize = payment_method.authorize(100)
+    authorize.succeeded? # true
+    authorized.capture # Capture the full amount
+    capture.succeeded? # true
+    
+Void a previous purchase:
+
+    purchase_transaction.void # void the purchase
+
+Credit a previous purchase:
+
+    purchase_transaction = payment_method.purchase(100) # make a purchase
+    purchase_transaction.credit
+    purchase_transaction.succeeded? # true 
+
+Credit part of a previous purchase:
+
+    purchase_transaction = payment_method.purchase(100) # make a purchase
+    purchase_transaction.credit(50) # provide a partial credit
+    purchase_transaction.succeeded? # true 
+
+   
+Additional Field Validation
+----------
+
+
+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:
+
+    require 'spreedly_core'
+    require 'spreedly_core/test_extensions'
+    SpreedlyCore.configure("Your API Login", "Your API Secret", "Test Gateway Token")
+    SpreedlyCore::PaymentMethod.additional_required_cc_fields :address1, :city, :state, :zip
+    master_card_data = SpreedlyCore::TestHelper.cc_data(:master)
+    token = SpreedlyCore::PaymentMethod.create_test_token(master_card_data)
+    payment_method = SpreedlyCore::PaymentMethod.find(token)
+    payment_method.valid? # returns false
+    payment_method.errors # ["Address1 can't be blank", "City can't be blank", "State can't be blank", "Zip can't be blank"]
+    master_card_data = SpreedlyCore::TestHelper.cc_data(:master, :credit_card => {:address1 => "742 Evergreen Terrace", :city => "Springfield", :state => "IL", 62701})
+    payment_method = SpreedlyCore::PaymentMethod.find(token)
+    payment_method.valid? # returns true
+    payment_method.errors # []
+
+   
+Configuring SpreedlyCore with Rails
+----------
+
+Inside your Rails project create config/spreedly_core.yml formatted like config/database.yml. For example:
+
+    development:
+      login: <Login Key>
+      secret: <Secret Key>
+      gateway_token: 'JncEWj22g59t3CRB1VnPXmUUgKc' # this is the test gateway, replace with your real gateway in production
+    test:
+      login: <Login Key>
+      secret: <Secret Key>
+      gateway_token: 'JncEWj22g59t3CRB1VnPXmUUgKc' # this is the test gateway, replace with your real gateway in production
+    production:
+      login: <Login Key>
+      secret: <Secret Key>
+      gateway_token: 'JncEWj22g59t3CRB1VnPXmUUgKc' # this is the test gateway, replace with your real gateway in production
+
+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'])
+
+Optionally require additional credit card fields:
+
+    SpreedlyCore::PaymentMethod.additional_required_cc_fields :address1, :city, :state, :zip  
+
+Contributing
+------------
+
+Once you've made your commits:
+
+1. [Fork](http://help.github.com/forking/) SpreedlyCore
+2. Create a topic branch - `git checkout -b my_branch`
+3. Push to your branch - `git push origin my_branch`
+4. Create a [Pull Request](http://help.github.com/pull-requests/) from your branch
+5. Profit! 
+

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "someproject #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/lib/spreedly_core/base.rb

@@ -0,0 +1,93 @@
+module SpreedlyCore
+  # Base class for all SpreedlyCore API requests
+  class Base
+    include HTTParty
+    
+    # Net::HTTP::Options is configured to not have a body.
+    # Lets give it the body it's always dreamed of
+    Net::HTTP::Options::RESPONSE_HAS_BODY = true
+    
+    format :xml
+
+    # timeout requests after 10 seconds
+    default_timeout 10
+
+    base_uri "https://spreedlycore.com/v1"
+
+    def self.configure(login, secret, gateway_token)
+      @@login = login
+      self.basic_auth(login, secret)
+      @@gateway_token = gateway_token
+    end
+
+    def self.login; @@login; end
+    def self.gateway_token; @@gateway_token; end
+
+    # make a post request to path
+    # If the request succeeds, provide the respones to the &block
+    def self.verify_post(path, options={}, &block)
+      verify_request(:post, path, options, 200, 422, &block)
+    end
+
+    # make a put request to path
+    # If the request succeeds, provide the respones to the &block
+    def self.verify_put(path, options={}, &block)
+      verify_request(:put, path, options,  &block)
+    end
+
+    # make a get request to path
+    # If the request succeeds, provide the respones to the &block
+    def self.verify_get(path, options={}, &block)
+      verify_request(:get, path, options, 200, &block)
+    end
+
+    # make an options request to path
+    # If the request succeeds, provide the respones to the &block
+    def self.verify_options(path, options={}, &block)
+      verify_request(:options, path, options, 200, &block)
+    end
+
+    # make a request to path using the HTTP method provided as request_type
+    # *allowed_codes are passed in, verify the response code (200, 404, etc)
+    # is one of the allowed codes.
+    # If *allowed_codes is empty, don't check the response code, but set an instance
+    # variable on the object created in the block containing the response code.
+    def self.verify_request(request_type, path, options, *allowed_codes, &block)
+      begin 
+        response = self.send(request_type, path, options)
+      rescue Timeout::Error, Errno::ETIMEDOUT => e
+        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
+      end
+    end
+
+    # Given a hash of attrs, assign instance variables using the hash key as the
+    # attribute name and hash value as the attribute value
+    #
+    def initialize(attrs={})
+      attrs.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end
+      # errors may be nil, empty, a string, or an array of strings. 
+      @errors = if @errors.nil? || @errors["error"].blank?
+                  []
+                elsif @errors["error"].is_a?(String)
+                  [@errors["error"]]
+                else
+                  @errors["error"]
+                end
+    end
+  end
+
+end

data/lib/spreedly_core/gateway.rb

@@ -0,0 +1,19 @@
+module SpreedlyCore
+  class Gateway < Base
+    attr_reader(:name, :gateway_type, :auth_modes, :supports_capture,
+                :supports_authorize, :supports_purchase, :supports_void,
+                :supports_credit)
+
+    # returns an array of Gateway which are supported
+    def self.supported_gateways
+      verify_options("/gateways.xml") do |response|
+        response.parsed_response["gateways"]["gateway"].map{|h| new(h) }
+      end
+    end
+
+    def initialize(attrs={})
+      attrs.merge!(attrs.delete("characteristics") || {})
+      super(attrs)
+    end
+  end
+end

data/lib/spreedly_core/payment_method.rb

@@ -0,0 +1,106 @@
+module SpreedlyCore
+  class PaymentMethod < Base
+    attr_reader( :address1, :address2, :card_type, :city, :country, :created_at,
+                 :data, :email, :errors, :first_name, :last_four_digits,
+                 :last_name, :month, :number, :payment_method_type, :phone_number,
+                 :state, :token, :updated_at, :verification_value, :year, :zip)
+
+    # configure additional required fiels. Like :address1, :city, :state
+    def self.additional_required_cc_fields *fields
+      @@additional_required_fields ||= Set.new
+      @@additional_required_fields += fields
+    end
+
+    # clear the configured additional required fields
+    def self.reset_additional_required_cc_fields
+      @@additional_required_fields = Set.new
+    end
+
+    # Lookup the PaymentMethod by token
+    def self.find(token)
+      return nil if token.nil? 
+      verify_get("/payment_methods/#{token}.xml") do |response|
+        new(response.parsed_response["payment_method"])
+      end
+    end
+
+    # Create a new PaymentMethod based on the attrs hash and then validate
+    def initialize(attrs={})
+      super(attrs)
+      validate
+    end
+
+    # Retain the payment method
+    def retain
+      self.class.verify_put("/payment_methods/#{token}/retain.xml", :body => {}) 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|
+        RedactTransaction.new(response.parsed_response["transaction"])
+      end
+    end
+
+    # Make a purchase against the payment method
+    def purchase(amount, currency="USD", _gateway_token=nil)
+      purchase_or_authorize(:purchase, amount, currency, _gateway_token)
+    end
+
+    # Make an authorize against payment method. You can then later capture against the authorize
+    def authorize(amount, currency="USD",  _gateway_token=nil)
+      purchase_or_authorize(:authorize, amount, currency, _gateway_token)
+    end
+
+    # Returns the URL that CC data should be submitted to.
+    def self.submit_url
+      Base.base_uri + '/payment_methods'
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    protected
+
+    # Validate additional cc fields like first_name, last_name, etc when
+    # configured to do so
+    def validate
+      return if @has_been_validated
+      @has_been_validated = true
+      self.class.additional_required_cc_fields.each do |field|
+        if instance_variable_get("@#{field}").blank?
+          str_field= field.to_s
+          friendly_name = if str_field.respond_to?(:humanize)
+                            str_field.humanize
+                          else
+                            str_field.split("_").join(" ")
+                          end
+                            
+          @errors << "#{friendly_name.capitalize} can't be blank"
+        end
+      end
+      @errors = @errors.sort
+    end
+
+    def purchase_or_authorize(tran_type, amount, currency, _gateway_token)
+      transaction_type = tran_type.to_s
+      raise "Unknown transaction type" unless %w{purchase authorize}.include?(transaction_type)
+
+      _gateway_token ||= self.class.gateway_token
+      path = "/gateways/#{_gateway_token}/#{transaction_type}.xml"
+      data = {:transaction => {
+          :amount => amount,
+          :transaction_type => transaction_type, 
+          :payment_method_token => token,
+          :currency_code => currency }}
+
+      self.class.verify_post(path, :body => data) do |response|
+        klass = SpreedlyCore.const_get("#{transaction_type.capitalize}Transaction")
+        klass.new(response.parsed_response["transaction"])
+      end
+    end
+  end
+end

data/lib/spreedly_core/test_extensions.rb

@@ -0,0 +1,47 @@
+require 'cgi'
+
+module SpreedlyCore::TestHelper
+  extend self
+
+  def cc_data(cc_type, options={})
+
+    card_numbers = {:master => [5555555555554444, 5105105105105100],
+      :visa => [4111111111111111, 4012888888881881],
+      :american_express => [378282246310005, 371449635398431],
+      :discover => [6011111111111117, 6011000990139424]
+    }
+    
+    card_number = options[:card_number] == :failed ? :last : :first
+    number = card_numbers[cc_type].send(card_number)
+    
+    { :credit_card => {
+        :first_name => "John",
+        :last_name => "Foo",
+        :card_type => cc_type,
+        :number => number,
+        :verification_value => 123,
+        :month => 4,
+        :year => Time.now.year + 1 }.merge(options[:credit_card] || {})
+    }
+  end
+end
+
+module SpreedlyCore
+  class PaymentMethod
+    def self.create_test_token(cc_data={})
+      data = cc_data.merge(:redirect_url => "http://example.com",
+                           :api_login => SpreedlyCore::Base.login)
+      
+      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
+        # handle redirect following
+        token = CGI::parse(URI.parse($1).query)["token"].first
+      end
+      raise "Could not find token in body: #{response}" if token.nil?
+      return token
+    end
+  end
+end
+

data/lib/spreedly_core/transactions.rb

@@ -0,0 +1,127 @@
+module SpreedlyCore
+  # Abstract class for all the different spreedly core transactions
+  class Transaction < Base
+    attr_reader(:amount, :on_test_gateway, :created_at, :updated_at, :currency_code,
+                :succeeded, :token, :message, :transaction_type, :gateway_token,
+                :response)
+    alias :succeeded? :succeeded
+
+    # Breaks enacapsulation a bit, but allow subclasses to register the 'transaction_type'
+    # they handle.
+    def self.handles(transaction_type)
+      @@transaction_type_to_class ||= {}
+      @@transaction_type_to_class[transaction_type] = self
+    end
+
+    # 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|
+        attrs = response.parsed_response["transaction"]
+        klass = @@transaction_type_to_class[attrs["transaction_type"]] || self
+        klass.new(attrs)
+      end
+    end
+  end
+
+  class RetainTransaction < Transaction
+    handles "RetainPaymentMethod"
+    attr_reader :payment_method
+    
+    def initialize(attrs={})
+      @payment_method = PaymentMethod.new(attrs.delete("payment_method") || {})
+      super(attrs)
+    end
+  end
+  class RedactTransaction < Transaction
+    handles "RedactPaymentMethod"
+    attr_reader :payment_method
+    
+    def initialize(attrs={})
+      @payment_method = PaymentMethod.new(attrs.delete("payment_method") || {})
+      super(attrs)
+    end
+  end
+  
+  module NullifiableTransaction
+    # Void is used to cancel out authorizations and, with some gateways, to
+    # cancel actual payment transactions within the first 24 hours
+    def void
+      self.class.verify_post("/transactions/#{token}/void.xml") do |response|
+        VoidedTransaction.new(response.parsed_response["transaction"])
+      end      
+    end
+
+    # Credit amount. If amount is nil, then credit the entire previous purchase
+    # or captured amount 
+    def credit(amount=nil)
+      body = if amount.nil? 
+               {}
+             else
+               {:transaction => {:amount => amount}}
+             end
+      self.class.verify_post("/transactions/#{token}/credit.xml",
+                             :body => body) do |response|
+        CreditTransaction.new(response.parsed_response["transaction"])
+      end
+    end
+  end
+
+  class AuthorizeTransaction < Transaction
+    handles "authorization"
+    attr_reader :payment_method
+    
+    def initialize(attrs={})
+      @payment_method = PaymentMethod.new(attrs.delete("payment_method") || {})
+      @response = Response.new(attrs.delete("response") || {})
+      super(attrs)
+    end
+
+    # Capture the previously authorized payment. If the amount is nil, the
+    # captured amount will the amount from the original authorization. Some
+    # gateways support partial captures which can be done by specifiying an
+    # amount
+    def capture(amount=nil)
+      body = if amount.nil?
+               {}
+             else
+               {:transaction => {:amount => amount}}
+             end
+      self.class.verify_post("/transactions/#{token}/capture.xml",
+                            :body => body) do |response|
+        CaptureTransaction.new(response.parsed_response["transaction"])
+      end
+    end
+  end
+
+  class PurchaseTransaction < Transaction
+    include NullifiableTransaction
+
+    handles "purchase"
+    attr_reader :payment_method
+
+    def initialize(attrs={})
+      @payment_method = PaymentMethod.new(attrs.delete("payment_method") || {})
+      @response = Response.new(attrs.delete("response") || {})
+      super(attrs)
+    end
+  end
+
+  class CaptureTransaction < Transaction
+    include NullifiableTransaction
+
+    handles "capture"
+    attr_reader :reference_token
+  end
+
+  class VoidedTransaction < Transaction
+    handles "void"
+    attr_reader :reference_token
+  end
+
+  class CreditTransaction < Transaction
+    handles "credit"
+    attr_reader :reference_token
+  end
+  
+end

data/lib/spreedly_core/version.rb

@@ -0,0 +1,3 @@
+module SpreedlyCore
+  Version = VERSION = "0.0.2"
+end

data/lib/spreedly_core.rb

@@ -0,0 +1,37 @@
+require 'set'
+
+require 'httparty'
+
+require 'spreedly_core/base'
+require 'spreedly_core/payment_method'
+require 'spreedly_core/gateway'
+require 'spreedly_core/transactions'
+
+module SpreedlyCore
+  # Hash of user friendly credit card name to SpreedlyCore API name
+  CARD_TYPES = {
+    "Visa" => "visa",
+    "MasterCard" => "master",
+    "American Express" => "american_express",
+    "Discover" => "discover"
+  }
+
+  # Custom exception which occurs when a request to SpreedlyCore times out
+  # See SpreedlyCore::Base.default_timeout 
+  class TimeOutError < RuntimeError; end
+
+  # Configure SpreedlyCore with a particular account and default gateway
+  def self.configure(login, secret, gateway_token)
+    Base.configure(login, secret, gateway_token)
+  end
+
+  # returns the configured SpreedlyCore login
+  def self.login; Base.login; end
+
+  # A container for a response from a payment gateway
+  class Response < Base
+    attr_reader(:success, :message, :avs_code, :avs_message, :cvv_code,
+                :cvv_message, :error_code, :error_detail, :created_at,
+                :updated_at) 
+  end
+end

data/test/config/spreedly_core.yml

@@ -0,0 +1,3 @@
+login: 'Ud8NWIpG66s5ki5EX1n3ijCdGCe'
+secret: 'KF0ytewcrSuU55JA4oaTz5ggo1n46tqqsePXQTXWYU4UZM4pdfCfRDELOXT2kEnh'
+gateway_token: 'JncEWj22g59t3CRB1VnPXmUUgKc'

data/test/config/spreedly_core.yml.example

@@ -0,0 +1,3 @@
+login: <Login Key>
+secret: <Secret Key>
+gateway_token: 'JncEWj22g59t3CRB1VnPXmUUgKc' # test gateway

data/test/spreedly_core_test.rb

@@ -0,0 +1,237 @@
+require "#{File.dirname(__FILE__)}/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)
+    payment_method = given_a_payment_method
+    assert transaction = payment_method.purchase(purchase_amount)
+    assert_equal purchase_amount, transaction.amount
+    assert_equal "USD", transaction.currency_code
+    assert_equal "purchase", transaction.transaction_type
+    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)
+    payment_method = given_a_payment_method
+    assert transaction = payment_method.authorize(100)
+    assert_equal 100, transaction.amount
+    assert_equal "USD", transaction.currency_code
+    assert_equal SpreedlyCore::AuthorizeTransaction, transaction.class
+    transaction
+  end
+  
+  def given_a_capture(amount=100)
+    transaction = given_an_authorized_transaction
+    capture = transaction.capture(amount)
+    assert capture.succeeded?
+    assert_equal amount, capture.amount
+    assert_equal "capture", capture.transaction_type
+    assert_equal SpreedlyCore::CaptureTransaction, capture.class
+    capture
+  end
+
+  def given_a_purchase_void
+    purchase = given_a_purchase
+    assert void = purchase.void
+    assert_equal purchase.token, void.reference_token
+    assert void.succeeded?
+    void
+  end
+
+  def given_a_capture_void
+    capture = given_a_capture
+    assert void = capture.void
+    assert_equal capture.token, void.reference_token
+    assert void.succeeded?
+    void
+  end
+
+  def given_a_purchase_credit(purchase_amount=100, credit_amount=100)
+    purchase = given_a_purchase(purchase_amount)
+    given_a_credit(purchase, credit_amount)
+  end
+
+  def given_a_capture_credit(capture_amount=100, credit_amount=100)
+    capture = given_a_capture(capture_amount)
+    given_a_credit(capture, credit_amount)
+  end
+
+  def given_a_credit(trans, credit_amount=100)
+    assert credit = trans.credit(credit_amount)
+    assert_equal trans.token, credit.reference_token
+    assert_equal credit_amount, credit.amount
+    assert credit.succeeded?
+    assert SpreedlyCore::CreditTransaction, credit.class
+    credit
+  end
+
+
+
+  def test_can_get_payment_token
+    payment_method = given_a_payment_method
+    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 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_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_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
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup(:default, :development)
+
+Bundler.require(:default, :development)
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'spreedly_core'
+require 'spreedly_core/test_extensions'
+
+
+config = YAML.load(File.read(File.dirname(__FILE__) + '/config/spreedly_core.yml'))
+SpreedlyCore.configure(config['login'], config['secret'], config['gateway_token'])
+

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: spreedly_core
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- 403 Labs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 7
+        - 7
+        version: 0.7.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: github@403labs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- LICENSE
+- lib/spreedly_core/base.rb
+- lib/spreedly_core/gateway.rb
+- lib/spreedly_core/payment_method.rb
+- lib/spreedly_core/test_extensions.rb
+- lib/spreedly_core/transactions.rb
+- lib/spreedly_core/version.rb
+- lib/spreedly_core.rb
+- test/config/spreedly_core.yml
+- test/config/spreedly_core.yml.example
+- test/spreedly_core_test.rb
+- test/test_helper.rb
+homepage: http://github.com/403labs/spreedly_core
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Ruby API for Spreedly Core
+test_files: []
+