spreedly-core-ruby 0.1.0

data/test/spreedly_core_test.rb

@@ -0,0 +1,204 @@
+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
+module SpreedlyCore
+  class SpreedlyCoreTest < 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_mocked_500_error
+      with_disabled_network do
+        stub_request(:put, "#{mocked_base_uri_string}/payment_methods/FAKE.xml").
+          to_return(:body => '', :status => 500)
+        assert_raises InvalidResponse do
+          Base.verify_put('/payment_methods/FAKE.xml', :has_key => "test") {}
+        end
+      end
+    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_find_payment_method
+      payment_method = given_a_payment_method
+      assert PaymentMethod.find(payment_method.token)
+    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
+  
+    # 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

@@ -0,0 +1,33 @@
+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'
+require 'test_factory'
+
+require 'webmock/test_unit'
+# Allow real connections, see https://github.com/bblimke/webmock for more info
+WebMock.allow_net_connect!
+
+require 'webmock'
+
+class Test::Unit::TestCase
+  def assert_false(test, failure_message=nil)
+    assert(!test, failure_message)
+  end
+
+  def with_disabled_network(&block)
+    WebMock.disable_net_connect!
+    block.call
+  ensure
+    WebMock.allow_net_connect!
+  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

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: spreedly-core-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Spreedly
+- 403 Labs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &70176154487420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176154487420
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &70176154486600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70176154486600
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70176154411740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *70176154411740
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70176154410180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: *70176154410180
+description: 
+email: support@spreedly.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/test_gateway.rb
+- lib/spreedly_core/transactions.rb
+- lib/spreedly_core/version.rb
+- lib/spreedly_core.rb
+- 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
+- test/transaction_test.rb
+homepage: http://github.com/spreedly/spreedly-core-ruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2785672719963464473
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2785672719963464473
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Ruby API for Spreedly Core
+test_files: []