gimme_gimme 0.2.2

data/lib/generators/gimme_gimme/test_support/templates/testing/fake_cim_server.rb

@@ -0,0 +1,329 @@
+require 'nokogiri'
+
+module GimmeGimme
+  class FakeCimServer
+
+    attr_accessor :customer_profiles, :customer_payment_profiles, :transactions
+
+    def initialize
+      @customer_profiles = ActiveSupport::OrderedHash.new
+      @customer_payment_profiles = ActiveSupport::OrderedHash.new
+      @transactions = []
+      @errors = {}
+    end
+
+    def reset
+      @customer_payment_profiles.clear
+      @customer_profiles.clear
+      @transactions.clear
+      @errors.clear
+    end
+
+    def last_customer_profile
+      @customer_profiles.values.last
+    end
+
+    def last_transaction
+      @transactions.last
+    end
+
+    def last_customer_payment_profile
+      @customer_payment_profiles.values.last
+    end
+
+    def register_error_for(request, message, type = nil)
+      @errors[request] = {
+        :type    => type,
+        :message => message
+      }
+    end
+
+    def request(method, url, data, headers)
+      Rails.logger.debug "[CIM Request] #{method} #{url}\n#{data}"
+      document = Nokogiri::XML.parse(data)
+      request_type = document.root.name
+      response = process_request(request_type, document)
+      Rails.logger.debug "[CIM Response]\n#{response}"
+      response
+    end
+
+    def customer_profile_exists?(customer_profile_id)
+      customer_profiles.key?(customer_profile_id)
+    end
+
+    def customer_payment_profile_exists?(payment_profile_id)
+      customer_payment_profiles.key?(payment_profile_id)
+    end
+
+    private
+
+    def process_request(request_type, document)
+      error     = @errors[request_type]
+      auth_type = document.at('profileTransAuthOnly').present? ? :auth_only : :capture_only
+
+      if error && (error[:type].nil? || error[:type] == auth_type)
+        response_type = request_type.sub('Request', 'Response')
+        response(response_type, :message_text => error, :result_code => 'Failure')
+      else
+        case request_type
+        when 'createCustomerProfileRequest'
+          create_customer_profile(document)
+        when 'createCustomerProfileTransactionRequest'
+          create_transaction(document)
+        when 'getCustomerProfileRequest'
+          get_customer_profile(document)
+        when 'deleteCustomerProfileRequest'
+          delete_customer_profile(document)
+        when 'createCustomerPaymentProfileRequest'
+          create_customer_payment_profile(document)
+        when 'deleteCustomerPaymentProfileRequest'
+          delete_customer_payment_profile(document)
+        when 'updateCustomerPaymentProfileRequest'
+          update_customer_payment_profile(document)
+        else
+          raise "No such request type: #{request_type}"
+        end
+      end
+    end
+
+    def create_customer_profile(document)
+      customer_profile_id = next_id
+      profile = CustomerProfile.new(customer_profile_id, document)
+      @customer_profiles[customer_profile_id] = profile
+      response('createCustomerProfileResponse', :customerProfileId => profile.customer_profile_id)
+    end
+
+    def create_customer_payment_profile(document)
+      customer_payment_profile_id = next_id
+      profile = CustomerPaymentProfile.new(customer_payment_profile_id, document)
+      @customer_profiles[profile.customer_profile_id].customer_payment_profile_id = profile.customer_payment_profile_id
+      @customer_payment_profiles[customer_payment_profile_id] = profile
+      response('createCustomerPaymentProfileResponse', :customerPaymentProfileId => profile.customer_payment_profile_id)
+    end
+
+    def create_transaction(document)
+      xml_root = 'createCustomerProfileTransactionResponse'
+      transaction = Transaction.create(customer_profiles, customer_payment_profiles, document, transactions)
+
+      if transaction.success?
+        @transactions << transaction
+        response(xml_root, transaction.extra_response_opts)
+      else
+        response(xml_root, :result_code => 'Failure')
+      end
+    end
+
+    def get_customer_profile(document)
+      id = document.at("customerProfileId").text.to_i
+      profile = customer_profiles[id]
+      response('getCustomerProfileResponse', profile.to_hash)
+    end
+
+    def delete_customer_profile(document)
+      id = document.at("customerProfileId").text.to_i
+      customer_profiles.delete(id)
+      response('deleteCustomerProfileResponse', {})
+    end
+
+    def delete_customer_payment_profile(document)
+      customer_profile_id = document.at("customerProfileId").text.to_i
+      customer_payment_profile_id  = document.at("customerPaymentProfileId").text.to_i
+      customer_payment_profiles.delete(customer_payment_profile_id)
+      response('deleteCustomerPaymentProfileResponse', {})
+    end
+
+    def update_customer_payment_profile(document)
+      customer_payment_profile_id = document.at("customerPaymentProfileId").text.to_i
+      profile = CustomerPaymentProfile.new(customer_payment_profile_id, document)
+      @customer_profiles[profile.customer_profile_id].customer_payment_profile_id = profile.customer_payment_profile_id
+      @customer_payment_profiles[customer_payment_profile_id] = profile
+      response('updateCustomerPaymentProfileResponse', :customerPaymentProfileId => profile.customer_payment_profile_id)
+    end
+
+    def response(root, options)
+      options = {
+        :refId => options.delete(:ref_id) || next_id,
+        :messages => {
+          :resultCode => options.delete(:result_code) || 'Ok',
+          :message    => {
+            :code => options.delete(:message_code) || 'I00001',
+            :text => options.delete(:message_text) || 'Successful.'
+          }
+        }
+      }.update(options)
+      options.to_xml(:root => root)
+    end
+
+    def next_id
+      Sequencer.next_id
+    end
+
+    module RequestParser
+      def at(xpath)
+        @document.at(xpath).try(:text)
+      end
+    end
+
+    class CustomerProfile
+      attr_reader :customer_profile_id,
+        :customer_type, :first_name, :last_name, :expiration_date, :card_number,
+        :merchant_customer_id, :city, :zip, :phone_number, :address, :state
+      attr_accessor :customer_payment_profile_id
+
+      def initialize(customer_profile_id, document)
+        @document = document
+
+        @customer_profile_id = customer_profile_id
+
+        @customer_type        = at("customerType")
+        @merchant_customer_id = at("merchantCustomerId")
+      end
+
+      include RequestParser
+
+      def to_hash
+        {
+          :profile => {
+            :customerProfileId => customer_profile_id,
+            :paymentProfiles   => { :customerPaymentProfileId => customer_payment_profile_id }
+          }
+        }
+      end
+    end
+
+    class CustomerPaymentProfile
+      include RequestParser
+
+      attr_reader :customer_profile_id, :customer_payment_profile_id, :expiration_date,
+        :card_number, :city, :zip, :address, :state, :first_name, :last_name
+
+      def initialize(customer_payment_profile_id, document)
+        @document = document
+        @customer_payment_profile_id  = customer_payment_profile_id
+
+        @customer_profile_id  = at("customerProfileId").to_i
+        @card_number          = at("cardNumber")
+        @expiration_date      = at("expirationDate")
+        @address              = at("address")
+        @city                 = at("city")
+        @state                = at("state")
+        @zip                  = at("zip")
+        @first_name           = at("firstName")
+        @last_name            = at("lastName")
+      end
+
+      def expiration_month
+        expiration.month
+      end
+
+      def expiration_year
+        expiration.year
+      end
+
+      def expiration
+        year, month = expiration_date.split('-')
+        ActiveMerchant::Billing::CreditCard::ExpiryDate.new(month, year).expiration
+      end
+      private :expiration
+
+      def to_hash
+      end
+    end
+
+    class Transaction
+      class NotImplementedError < StandardError; end
+      include RequestParser
+
+      attr_reader :amount, :customer_profile_id, :customer_profile, :customer_payment_profile, :transactions
+
+      def self.create(customer_profiles, customer_payment_profiles, document, transactions)
+        if document.at("profileTransAuthOnly").present?
+          AuthOnlyTransaction.new(customer_profiles, customer_payment_profiles, document, transactions)
+        elsif document.at("profileTransCaptureOnly").present?
+          CaptureOnlyTransaction.new(customer_profiles, customer_payment_profiles, document, transactions)
+        end
+      end
+
+      def initialize(customer_profiles, customer_payment_profiles, document, transactions)
+        @document = document
+        @amount                      = at("amount").to_f
+        @customer_profile_id         = at("customerProfileId")
+        @customer_profile_payment_id = at("customerPaymentProfileId")
+        @customer_profile            = customer_profiles[@customer_profile_id.to_i]
+        @customer_payment_profile    = customer_payment_profiles[@customer_profile_payment_id.to_i]
+      end
+
+      def card_number
+        customer_payment_profile.card_number
+      end
+
+      def success?
+        !customer_profile.nil? &&
+          customer_profile.customer_payment_profile_id == @customer_profile_payment_id.to_i
+      end
+
+      def extra_response_opts
+        raise NotImplementedError
+      end
+    end
+
+    class AuthOnlyTransaction < Transaction
+      attr_accessor :authorization_code
+
+      def initialize(customer_profiles, customer_payment_profiles, document, transactions)
+        super
+        @authorization_code = Sequencer.next_id
+      end
+
+      def extra_response_opts
+        success = success? ? 1 : 0
+        {
+          :directResponse => "#{success},,,,#{@authorization_code},,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"
+        }
+      end
+    end
+
+    class CaptureOnlyTransaction < Transaction
+      attr_accessor :transaction_id
+
+      def initialize(customer_profiles, customer_payment_profiles, document, transactions)
+        super
+        @transaction_id = Sequencer.next_id
+        @document = document
+        @authorize_transaction =
+          transactions.detect do |transaction|
+            transaction.customer_payment_profile == customer_payment_profile &&
+              transaction.amount == amount &&
+              transaction.authorization_code.to_s == authorization_code.to_s
+          end
+      end
+
+      def extra_response_opts
+        success = success? ? 1 : 0
+        {
+          :directResponse => "#{success},,,,,,#{@transaction_id},,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"
+        }
+        #{:direct_response => { :transaction_id => @transaction_id} }
+      end
+
+      def success?
+        super && !@authorize_transaction.nil?
+      end
+
+      def authorization_code
+        at("approvalCode")
+      end
+
+    end
+
+  end
+
+  module Sequencer
+    extend self
+    @@next_id = 0
+
+    def self.next_id
+      @@next_id += 1
+    end
+  end
+end

data/lib/generators/gimme_gimme/test_support/templates/testing/fake_cim_spec_helpers.rb

@@ -0,0 +1,21 @@
+module GimmeGimme
+  module FakeCimHelpers
+    def with_gateway(new_gateway)
+      old_gateway = CimGateway.instance.gateway
+      CimGateway.instance.gateway = new_gateway
+      begin
+        yield
+      ensure
+        CimGateway.instance.gateway = old_gateway
+      end
+    end
+
+    def fake_cim(&block)
+      FakeCimServer.new.tap do |server|
+        with_gateway(FakeCimGateway.new(:server => server)) do
+          yield(server)
+        end
+      end
+    end
+  end
+end

data/lib/generators/gimme_gimme/test_support/test_support_generator.rb

@@ -0,0 +1,23 @@
+require 'generators/gimme_gimme/base'
+
+module GimmeGimme
+  module Generators
+    class TestSupportGenerator < Base
+
+      desc <<DESC
+Description:
+    Copy gimme_gimme fake server and spec helper files to your application.
+DESC
+
+      def copy_support_files
+        empty_directory 'lib/gimme_gimme/testing'
+        empty_directory 'features/support'
+        empty_directory 'spec/factories'
+        directory 'testing',  'lib/gimme_gimme/testing'
+        directory 'support',  'features/support'
+        directory 'factories', 'spec/factories'
+      end
+
+    end
+  end
+end

data/lib/gimme_gimme.rb

@@ -0,0 +1,7 @@
+require 'activemerchant'
+require 'gimme_gimme/version'
+require 'gimme_gimme/engine'
+require 'gimme_gimme/credit_cards_controller'
+require 'gimme_gimme/cim_gateway'
+require 'gimme_gimme/credit_card'
+require 'gimme_gimme/user'

data/lib/gimme_gimme/cim_gateway.rb

@@ -0,0 +1,16 @@
+require 'singleton'
+
+module GimmeGimme
+  class CimGateway
+    include Singleton
+
+    attr_accessor :gateway
+
+    def initialize
+      @gateway = ActiveMerchant::Billing::AuthorizeNetCimGateway.new(
+        :login    => AUTHORIZE_NET_API_LOGIN_ID,
+        :password => AUTHORIZE_NET_TRANSACTION_KEY
+      )
+    end
+  end
+end

data/lib/gimme_gimme/credit_card.rb

@@ -0,0 +1,125 @@
+module GimmeGimme
+  module CreditCard
+    extend ActiveSupport::Concern
+    class ChargeError < StandardError; end
+    class AuthorizationError < StandardError; end
+    class InvalidCreditCard < StandardError; end
+
+    included do
+      CARD_TYPES = ['Visa', 'Master Card', 'American Express', 'Discover'].freeze
+      attr_accessor :card_number, :security_code, :store_card
+
+      belongs_to :user
+
+      validates_presence_of :card_number, :security_code
+      validates_presence_of :expiration_month, :expiration_year, :card_type
+      validates_inclusion_of :card_type,        :in => CARD_TYPES
+      validates_inclusion_of :expiration_month, :in => (1..12)
+      before_save :store_last_four_digits
+      before_create :create_customer_payment_profile
+      before_update :update_customer_payment_profile
+      after_destroy :delete_customer_payment_profile
+    end
+
+    module InstanceMethods
+      def authorize(opts)
+        amount = opts[:amount]
+        amount = amount.round(2) unless amount.kind_of?(Integer)
+        response = self.class.gateway.create_customer_profile_transaction(
+            :transaction => {
+            :customer_profile_id         => self.user.remote_customer_profile_id,
+            :customer_payment_profile_id => self.remote_customer_payment_profile_id,
+            :type                        => :auth_only,
+            :amount                      => amount
+          }
+        )
+
+        if response.success?
+          response.params['direct_response']['approval_code']
+        else
+          raise AuthorizationError
+        end
+      end
+
+      def charge(opts)
+        amount = opts[:amount]
+        amount = amount.round(2) unless amount.kind_of?(Integer)
+        opts[:amount] = amount
+        response = self.class.gateway.create_customer_profile_transaction(
+            :transaction => {
+            :customer_profile_id         => self.user.remote_customer_profile_id,
+            :customer_payment_profile_id => self.remote_customer_payment_profile_id,
+            :type                        => :capture_only
+          }.merge(opts)
+        )
+
+        if response.success?
+          response.params['direct_response']['transaction_id']
+        else
+          raise ChargeError
+        end
+      end
+
+      def store_card?
+        !!store_card
+      end
+
+      def create_customer_payment_profile
+        response = self.class.gateway.create_customer_payment_profile(:customer_profile_id => user.remote_customer_profile_id,
+                                                                      :payment_profile => {
+          :payment => { :credit_card => credit_card_object },
+          :bill_to => { :first_name  => first_name, :last_name => last_name }
+        })
+        if response.success?
+          self.remote_customer_payment_profile_id = response.params['customer_payment_profile_id']
+        else
+          raise InvalidCreditCard
+        end
+      end
+      private :create_customer_payment_profile
+
+      def update_customer_payment_profile
+        response = self.class.gateway.update_customer_payment_profile(:customer_profile_id => user.remote_customer_profile_id,
+                                                                      :payment_profile => {
+          :payment => { :credit_card => credit_card_object },
+          :bill_to => { :first_name  => first_name, :last_name => last_name },
+          :customer_payment_profile_id => remote_customer_payment_profile_id
+        })
+        unless response.success?
+          raise InvalidCreditCard
+        end
+      end
+      private :update_customer_payment_profile
+
+      def credit_card_object
+        ActiveMerchant::Billing::CreditCard.new(
+          :first_name         => self.first_name.try(:dup),
+          :last_name          => self.last_name.try(:dup),
+          :number             => self.card_number.try(:dup),
+          :month              => self.expiration_month.to_s.try(:dup),
+          :year               => self.expiration_year.to_s.try(:dup),
+          :type               => self.card_type.try(:dup),
+          :verification_value => self.security_code.try(:dup)
+        )
+      end
+      private :credit_card_object
+
+      def store_last_four_digits
+        self.last_four_digits = self.card_number.strip.last(4)
+      end
+      private :store_last_four_digits
+
+      def delete_customer_payment_profile
+        self.class.gateway.delete_customer_payment_profile(:customer_profile_id         => self.user.remote_customer_profile_id,
+                                                           :customer_payment_profile_id => self.remote_customer_payment_profile_id)
+      end
+      private :delete_customer_payment_profile
+    end
+
+    module ClassMethods
+      def gateway
+        ::GimmeGimme::CimGateway.instance.gateway
+      end
+    end
+  end
+end