activemerchant 1.2.1 → 1.3.0

data/script/generator/generators/integration/templates/notification.rb

@@ -1,100 +0,0 @@
-require 'net/http'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module <%= class_name %>
-        class Notification < ActiveMerchant::Billing::Integrations::Notification
-          def complete?
-            params['']
-          end 
-
-          def item_id
-            params['']
-          end
-
-          def transaction_id
-            params['']
-          end
-
-          # When was this payment received by the client. 
-          def received_at
-            params['']
-          end
-
-          def payer_email
-            params['']
-          end
-         
-          def receiver_email
-            params['']
-          end 
-
-          def security_key
-            params['']
-          end
-
-          # the money amount we received in X.2 decimal.
-          def gross
-            params['']
-          end
-
-          # Was this a test transaction?
-          def test?
-            params[''] == 'test'
-          end
-
-          def status
-            params['']
-          end
-
-          # Acknowledge the transaction to <%= class_name %>. This method has to be called after a new 
-          # apc arrives. <%= class_name %> will verify that all the information we received are correct and will return a 
-          # ok or a fail. 
-          # 
-          # Example:
-          # 
-          #   def ipn
-          #     notify = <%= class_name %>Notification.new(request.raw_post)
-          #
-          #     if notify.acknowledge 
-          #       ... process order ... if notify.complete?
-          #     else
-          #       ... log possible hacking attempt ...
-          #     end
-          def acknowledge      
-            payload = raw
-
-            uri = URI.parse(<%= class_name %>.notification_confirmation_url)
-
-            request = Net::HTTP::Post.new(uri.path)
-
-            request['Content-Length'] = "#{payload.size}"
-            request['User-Agent'] = "Active Merchant -- http://home.leetsoft.com/am"
-            request['Content-Type'] = "application/x-www-form-urlencoded" 
-
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.verify_mode    = OpenSSL::SSL::VERIFY_NONE unless @ssl_strict
-            http.use_ssl        = true
-
-            response = http.request(request, payload)
-
-            # Replace with the appropriate codes
-            raise StandardError.new("Faulty <%= class_name %> result: #{response.body}") unless ["AUTHORISED", "DECLINED"].include?(response.body)
-            response.body == "AUTHORISED"
-          end
- private
-
-          # Take the posted data and move the relevant data into a hash
-          def parse(post)
-            @raw = post
-            for line in post.split('&')
-              key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
-              params[key] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/script/generator/generators/integration/templates/notification_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
-
-class <%= class_name %>NotificationTest < Test::Unit::TestCase
-  include ActiveMerchant::Billing::Integrations
-
-  def setup
-    @<%= file_name %> = <%= class_name %>::Notification.new(http_raw_data)
-  end
-
-  def test_accessors
-    assert @<%= file_name %>.complete?
-    assert_equal "", @<%= file_name %>.status
-    assert_equal "", @<%= file_name %>.transaction_id
-    assert_equal "", @<%= file_name %>.item_id
-    assert_equal "", @<%= file_name %>.gross
-    assert_equal "", @<%= file_name %>.currency
-    assert_equal "", @<%= file_name %>.received_at
-    assert @<%= file_name %>.test?
-  end
-
-  def test_compositions
-    assert_equal Money.new(3166, 'USD'), @<%= file_name %>.amount
-  end
-
-  # Replace with real successful acknowledgement code
-  def test_acknowledgement    
-
-  end
-
-  def test_send_acknowledgement
-  end
-
-  def test_respond_to_acknowledge
-    assert @<%= file_name %>.respond_to?(:acknowledge)
-  end
-
-  private
-  def http_raw_data
-    ""
-  end  
-end

data/script/generator/manifest.rb

@@ -1,20 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Generator
-    class Manifest
-      attr_reader :templates, :directories
-
-      def initialize
-        @templates, @directories = [], []
-        yield self if block_given?
-      end
-
-      def template(input, output)
-        @templates << { :input => input, :output => output }
-      end
-
-      def directory(dir)
-        @directories << dir
-      end
-    end
-  end
-end

data/test/remote_tests/remote_authorize_net_test.rb

@@ -1,113 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class AuthorizeNetTest < Test::Unit::TestCase
-  def setup
-    Base.mode = :test
-    
-    @gateway = AuthorizeNetGateway.new(fixtures(:authorize_net))
-
-    @creditcard = credit_card('4242424242424242')
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(100, @creditcard,
-      :order_id => generate_order_id,
-      :description => 'Store purchase'
-    )
-    assert_success response
-    assert response.test?
-    assert_equal 'This transaction has been approved', response.message
-    assert response.authorization
-  end
-  
-  def test_expired_credit_card
-    @creditcard.year = 2004 
-    assert response = @gateway.purchase(100, @creditcard, :order_id => generate_order_id)
-    assert_failure response
-    assert response.test?
-    assert_equal 'The credit card has expired', response.message
-  end
-  
-  def test_forced_test_mode_purchase
-    gateway = AuthorizeNetGateway.new(
-      :login => @login,
-      :password => @password,
-      :test => true
-    )
-    assert response = gateway.purchase(100, @creditcard, :order_id => generate_order_id)
-    assert_success response
-    assert response.test?
-    assert_match /TESTMODE/, response.message
-    assert response.authorization
-  end
-  
-  def test_successful_authorization
-    assert response = @gateway.authorize(100, @creditcard, :order_id => generate_order_id)
-    assert_success response
-    assert_equal 'This transaction has been approved', response.message
-    assert response.authorization
-  end
-  
-  def test_authorization_and_capture
-    assert authorization = @gateway.authorize(100, @creditcard, :order_id => generate_order_id)
-    assert_success authorization
-    assert authorization
-    assert capture = @gateway.capture(100, authorization.authorization)
-    assert_success capture
-    assert_equal 'This transaction has been approved', capture.message
-  end
-  
-  def test_authorization_and_void
-    assert authorization = @gateway.authorize(100, @creditcard, :order_id => generate_order_id)
-    assert_success authorization
-    assert authorization
-    assert void = @gateway.void(authorization.authorization)
-    assert_success void
-    assert_equal 'This transaction has been approved', void.message
-  end
-  
-  def test_bad_login
-    gateway = AuthorizeNetGateway.new(
-      :login => 'X',
-      :password => 'Y'
-    )
-    
-    
-    assert response = gateway.purchase(100, @creditcard)
-        
-    assert_equal Response, response.class
-    assert_equal ["avs_message",
-                  "avs_result_code",
-                  "card_code",
-                  "response_code",
-                  "response_reason_code",
-                  "response_reason_text",
-                  "transaction_id"], response.params.keys.sort
-
-    assert_match /The merchant login ID or password is invalid/, response.message
-    
-    assert_equal false, response.success?
-  end
-  
-  def test_using_test_request
-    gateway = AuthorizeNetGateway.new(
-      :login => 'X',
-      :password => 'Y'
-    )
-    
-    assert response = gateway.purchase(100, @creditcard)
-        
-    assert_equal Response, response.class
-    assert_equal ["avs_message", 
-                  "avs_result_code",
-                  "card_code",
-                  "response_code",
-                  "response_reason_code",
-                  "response_reason_text",
-                  "transaction_id"], response.params.keys.sort
-  
-    assert_match /The merchant login ID or password is invalid/, response.message
-    
-    assert_equal false, response.success?    
-  end
-end

data/test/remote_tests/remote_brain_tree_test.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class RemoteBrainTreeTest < Test::Unit::TestCase
-  AMOUNT = 10000
-
-  def setup
-    @gateway = BrainTreeGateway.new(fixtures(:brain_tree))
-
-    @creditcard = credit_card('4111111111111111')
-
-    @declined_amount = rand(99)
-    @amount = rand(10000)+1001
-
-    @options = {  :order_id => generate_order_id,
-                  :address => { :address1 => '1234 Shady Brook Lane',
-                                :zip => '90210'
-                              }
-               }
-  end
-  
-  def test_successful_purchase
-    assert response = @gateway.purchase(@amount, @creditcard, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-  end
-  
-  def test_successful_add_to_vault
-    @options[:store] = true
-    assert response = @gateway.purchase(@amount, @creditcard, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-    assert_not_nil response.params["customer_vault_id"]
-  end
-
-  def test_successful_add_to_vault_and_use
-    @options[:store] = true
-    assert response = @gateway.purchase(@amount, @creditcard, @options)
-    assert_equal 'This transaction has been approved', response.message
-    assert_success response
-    assert_not_nil customer_id = response.params["customer_vault_id"]
-    
-    assert second_response = @gateway.purchase(@amount*2, customer_id, @options)
-    assert_equal 'This transaction has been approved', second_response.message
-    assert second_response.success?  
-  end
-
-  def test_declined_purchase
-    assert response = @gateway.purchase(@declined_amount, @creditcard, @options)
-    assert_equal 'This transaction has been declined', response.message
-    assert_failure response
-  end
-
-  def test_authorize_and_capture
-    assert auth = @gateway.authorize(@amount, @creditcard, @options)
-    assert_success auth
-    assert_equal 'This transaction has been approved', auth.message
-    assert auth.authorization
-    assert capture = @gateway.capture(@amount, auth.authorization)
-    assert_equal 'This transaction has been approved', capture.message
-    assert_success capture
-  end
-
-  def test_failed_capture
-    assert response = @gateway.capture(@amount, '')
-    assert_failure response
-    assert  response.message.match(/Invalid Transaction ID \/ Object ID specified:/)
-  end
-
-  def test_invalid_login
-    gateway = BrainTreeGateway.new(
-        :login => '',
-        :password => ''
-    )
-    assert response = gateway.purchase(@amount, @creditcard, @options)
-    assert_equal 'Invalid Username', response.message
-    assert_failure response
-  end
-end

data/test/remote_tests/remote_moneris_test.rb

@@ -1,110 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class MonerisRemoteTest < Test::Unit::TestCase
-  def setup
-    Base.gateway_mode = :test
-
-    @gateway = MonerisGateway.new(fixtures(:moneris))
-    @creditcard = credit_card('4242424242424242')
-    @expected_response_headers = [
-      "auth_code",
-      "bank_totals",
-      "card_type",
-      "complete",
-      "iso",
-      "message",
-      "receipt_id",
-      "reference_num",
-      "response_code",
-      "ticket",
-      "timed_out",
-      "trans_amount",
-      "trans_date",
-      "trans_id",
-      "trans_time",
-      "trans_type"
-     ]
-  end
-  
-  def test_should_be_a_successful_remote_purchase
-    order_id = generate_order_id
-    assert response = @gateway.purchase(100, @creditcard, :order_id => order_id)
-    assert_equal Response, response.class
-    assert_equal @expected_response_headers, response.params.keys.sort
-    assert_match /APPROVED/, response.params['message']
-    assert_equal 'Approved', response.message
-    assert_equal true, response.params['complete']
-    assert_equal true, response.success? # Checking for type-casting of XML, not actual success
-    assert_equal order_id, response.params['receipt_id']
-    assert_equal "#{response.params['trans_id']};#{response.params['receipt_id']}", response.authorization
-  end
-  
-  def test_should_be_a_successful_authorization
-    response = @gateway.authorize(100, @creditcard, :order_id => generate_order_id)
-    assert_success response
-    assert response.authorization
-  end
-
-  def test_should_not_be_a_successful_authorization
-    response = @gateway.authorize(105, @creditcard, :order_id => generate_order_id)
-    assert_failure response
-  end
-
-  def test_should_be_a_successful_authorization_and_capture
-    response = @gateway.authorize(100, @creditcard, :order_id => generate_order_id)
-    assert_success response
-    assert response.authorization
-
-    response = @gateway.capture(100, response.authorization)
-    assert_success response
-  end
-  
-  def test_should_be_a_successful_capture_and_void
-    # First perform a successful authorization and capture
-    response = @gateway.authorize(100, @creditcard, :order_id => generate_order_id)
-    assert_success response
-    assert response.authorization
-    
-    capture = @gateway.capture(100, response.authorization)
-    assert_success capture
-    assert capture.authorization
-    
-    # Now void it
-    void = @gateway.void(capture.authorization)
-    assert_success void
-  end
-  
-  def test_should_be_a_successful_purchase_and_void
-    purchase = @gateway.purchase(100, @creditcard, :order_id => generate_order_id)
-    assert_success purchase
-    
-    void = @gateway.void(purchase.authorization)
-    assert_success void
-  end
-  
-  def test_should_not_be_a_successful_purchase_and_void
-    purchase = @gateway.purchase(101, @creditcard, :order_id => generate_order_id)
-    assert_failure purchase
-    
-    void = @gateway.void(purchase.authorization)
-    assert_failure void
-  end
-  
-  def test_should_be_a_successful_purchase_and_refund
-    purchase = @gateway.purchase(100, @creditcard, :order_id => generate_order_id)
-    assert_success purchase
-    
-    credit = @gateway.credit(100, purchase.authorization)
-    assert_success credit
-  end
-
-  def test_should_be_a_remote_error
-    assert response = @gateway.purchase(150, @creditcard, :order_id => generate_order_id)
-    assert_equal Response, response.class
-    assert_equal @expected_response_headers, response.params.keys.sort
-    assert_match /DECLINED/, response.params['message']
-    assert_equal 'Declined', response.message
-    assert_equal true, response.params['complete']
-    assert_equal false, response.success? # Checking for XML type-casting, not failure
-  end
-end