spreedly_core 0.0.3 → 0.0.4

data/lib/spreedly_core/payment_method.rb

@@ -45,13 +45,13 @@ module SpreedlyCore
     end
 
     # Make a purchase against the payment method
-    def purchase(amount, currency="USD", _gateway_token=nil)
-      purchase_or_authorize(:purchase, amount, currency, _gateway_token)
+    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="USD",  _gateway_token=nil)
-      purchase_or_authorize(:authorize, amount, currency, _gateway_token)
+    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.
@@ -85,18 +85,22 @@ module SpreedlyCore
       @errors = @errors.sort
     end
 
-    def purchase_or_authorize(tran_type, amount, currency, _gateway_token)
+    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 => {
-          :amount => amount,
+      data = {
+        :transaction => {
           :transaction_type => transaction_type, 
           :payment_method_token => token,
-          :currency_code => currency }}
-
+          :amount => amount,
+          :currency_code => currency,
+          :ip => ip_address
+        }
+      }
       self.class.verify_post(path, :body => data) do |response|
         klass = SpreedlyCore.const_get("#{transaction_type.capitalize}Transaction")
         klass.new(response.parsed_response["transaction"])

data/lib/spreedly_core/transactions.rb

@@ -46,19 +46,21 @@ module SpreedlyCore
   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|
+    def void(ip_address=nil)
+      body = {:transaction => {:ip => ip_address}}
+      self.class.verify_post("/transactions/#{token}/void.xml",
+                             :body => body) 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)
+    def credit(amount=nil, ip_address=nil)
       body = if amount.nil? 
-               {}
+               {:ip => ip_address}
              else
-               {:transaction => {:amount => amount}}
+               {:transaction => {:amount => amount, :ip => ip_address}}
              end
       self.class.verify_post("/transactions/#{token}/credit.xml",
                              :body => body) do |response|
@@ -67,7 +69,13 @@ module SpreedlyCore
     end
   end
 
+  module HasIpAddress
+    attr_reader :ip
+  end
+
   class AuthorizeTransaction < Transaction
+    include HasIpAddress
+    
     handles "Authorization"
     attr_reader :payment_method
     
@@ -81,11 +89,11 @@ module SpreedlyCore
     # 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)
+    def capture(amount=nil, ip_address=nil)
       body = if amount.nil?
                {}
              else
-               {:transaction => {:amount => amount}}
+               {:transaction => {:amount => amount, :ip => ip_address}}
              end
       self.class.verify_post("/transactions/#{token}/capture.xml",
                             :body => body) do |response|
@@ -96,6 +104,7 @@ module SpreedlyCore
 
   class PurchaseTransaction < Transaction
     include NullifiableTransaction
+    include HasIpAddress
 
     handles "Purchase"
     attr_reader :payment_method
@@ -109,17 +118,22 @@ module SpreedlyCore
 
   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

data/lib/spreedly_core/version.rb

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

data/test/config/spreedly_core.yml

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

data/test/spreedly_core_test.rb

@@ -18,12 +18,13 @@ class SpreedlyCoreTest < Test::Unit::TestCase
     payment_method
   end
 
-  def given_a_purchase(purchase_amount=100)
+  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)
+    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
@@ -46,55 +47,60 @@ class SpreedlyCoreTest < Test::Unit::TestCase
     transaction
   end
 
-  def given_an_authorized_transaction(amount=100)
+  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)
+    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)
-    transaction = given_an_authorized_transaction
-    capture = transaction.capture(amount)
+  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
+  def given_a_purchase_void(ip_address='127.0.0.1')
     purchase = given_a_purchase
-    assert void = purchase.void
+    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
+  def given_a_capture_void(ip_address='127.0.0.1')
     capture = given_a_capture
-    assert void = capture.void
+    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)
-    purchase = given_a_purchase(purchase_amount)
-    given_a_credit(purchase, credit_amount)
+  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)
-    capture = given_a_capture(capture_amount)
-    given_a_credit(capture, credit_amount)
+  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)
-    assert credit = trans.credit(credit_amount)
+  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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: spreedly_core
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - 403 Labs
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-23 00:00:00 -05:00
+date: 2011-09-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency