spreedly-core-ruby 0.1.0

data/lib/spreedly_core/payment_method.rb

@@ -0,0 +1,118 @@
+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",
+                 :has_key => "payment_method") 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
+      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
+      verify_put("/payment_methods/#{token}/redact.xml", :body => {}, :has_key => "transaction") do |response|
+        RedactTransaction.new(response.parsed_response["transaction"])
+      end
+    end
+
+    # Make a purchase against the payment method
+    def purchase(amount, currency=nil, _gateway_token=nil, ip_address=nil)
+      purchase_or_authorize(:purchase, amount, currency, _gateway_token, ip_address)
+    end
+
+    # Make an authorize against payment method. You can then later capture against the authorize
+    def authorize(amount, currency=nil,  _gateway_token=nil, ip_address=nil)
+      purchase_or_authorize(:authorize, amount, currency, _gateway_token, ip_address)
+    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, ip_address)
+      transaction_type = tran_type.to_s
+      raise "Unknown transaction type" unless %w{purchase authorize}.include?(transaction_type)
+
+      currency ||= "USD"
+      _gateway_token ||= self.class.gateway_token
+      path = "/gateways/#{_gateway_token}/#{transaction_type}.xml"
+      data = {
+        :transaction => {
+          :transaction_type => transaction_type, 
+          :payment_method_token => token,
+          :amount => amount,
+          :currency_code => currency,
+          :ip => ip_address
+        }
+      }
+      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
+    end
+  end
+end

data/lib/spreedly_core/test_extensions.rb

@@ -0,0 +1,62 @@
+require 'cgi'
+require 'uri'
+
+module SpreedlyCore
+  module 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
+    
+    # Return the base uri as a mocking framework would expect
+    def mocked_base_uri_string
+      uri = URI.parse(Base.base_uri)
+      auth_params = Base.default_options[:basic_auth]
+      uri.user = auth_params[:username]
+      uri.password = auth_params[:password]
+      uri.to_s
+    end
+  end
+
+  class PaymentMethod
+
+    # 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,
+                           :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 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: #{e.response.body}" if token.nil?
+      return token
+    end
+  end
+end
+

data/lib/spreedly_core/test_gateway.rb

@@ -0,0 +1,32 @@
+module SpreedlyCore
+  class TestGateway < Gateway
+    # gets a test gateway, creates if necessary
+    def self.get_or_create
+      # get the list of gateways and return the first test gateway
+      # if none exist, create one
+      verify_get("/gateways.xml") do |response|
+        # will return Hash if only 1 gateways->gateway, Array otherwise
+        gateways = response.parsed_response["gateways"]["gateway"]
+        gateways = [gateways] unless gateways.is_a?(Array)
+        
+        gateways.each do |gateway_hash|
+          g = new gateway_hash
+          return g if g.gateway_type == "test" && g.redacted == false
+        end unless gateways.nil?
+      end
+
+      # no test gateway yet, let's create one
+      opts = {
+        :headers => {"Content-Type" => "application/xml"},
+        :body => '<gateway><gateway_type>test</gateway_type></gateway>'
+      }
+
+      verify_post("/gateways.xml", opts) do |response|
+        return new response.parsed_response["gateway"]
+      end
+
+      # HTTP 724
+      return nil
+    end
+  end
+end

data/lib/spreedly_core/transactions.rb

@@ -0,0 +1,142 @@
+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", :has_key => "transaction") 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(ip_address=nil)
+      body = {:transaction => {:ip => ip_address}}
+      self.class.verify_post("/transactions/#{token}/void.xml",
+                             :body => body, :has_key => "transaction") 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, ip_address=nil)
+      body = if amount.nil? 
+               {:ip => ip_address}
+             else
+               {:transaction => {:amount => amount, :ip => ip_address}}
+             end
+      self.class.verify_post("/transactions/#{token}/credit.xml",
+                             :body => body, :has_key => "transaction") do |response|
+        CreditTransaction.new(response.parsed_response["transaction"])
+      end
+    end
+  end
+
+  module HasIpAddress
+    attr_reader :ip
+  end
+
+  class AuthorizeTransaction < Transaction
+    include HasIpAddress
+    
+    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, ip_address=nil)
+      body = if amount.nil?
+               {}
+             else
+               {:transaction => {:amount => amount, :ip => ip_address}}
+             end
+      self.class.verify_post("/transactions/#{token}/capture.xml",
+                            :body => body, :has_key => "transaction") do |response|
+        CaptureTransaction.new(response.parsed_response["transaction"])
+      end
+    end
+  end
+
+  class PurchaseTransaction < Transaction
+    include NullifiableTransaction
+    include HasIpAddress
+
+    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
+    include HasIpAddress
+    
+    handles "Capture"
+    attr_reader :reference_token
+  end
+
+  class VoidedTransaction < Transaction
+    include HasIpAddress
+    
+    handles "Void"
+    attr_reader :reference_token
+  end
+
+  class CreditTransaction < Transaction
+    include HasIpAddress
+    
+    handles "Credit"
+    attr_reader :reference_token
+  end
+  
+end

data/lib/spreedly_core/version.rb

@@ -0,0 +1,4 @@
+module SpreedlyCore
+  Version = VERSION = "0.1.0"
+  ApiVersion = API_VERSION = "v1"
+end

data/test/config/spreedly_core.yml.example

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

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