Mockerize 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1eac6bf29a2a958983034165f01567f38797a9c9
+  data.tar.gz: c140fd9cde582209c3d9115840d106d1108f2332
+SHA512:
+  metadata.gz: 573766276d04451b6e62bb431d4ff0716a9222a804ae0974b3079e6828fb6b977e6d5c91e541d6a82cfe5eedb3887af524dddf8a99f3fbc5cb741cfc52c95059
+  data.tar.gz: 75462793ecbc1ff971b3814a6251eae622e4a9818b88c5a42006a6e53794d80a29a7791b5e3d0475bdb144fe1d2407c66661d0ce7b2a351e0572f6c659d75858

data/.gitignore

@@ -0,0 +1,47 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea
+*.rbc
+capybara-*.html
+.rspec
+/log
+/db/*.sqlite3
+/public/system
+/coverage/
+/spec/tmp
+**.orig
+rerun.txt
+pickle-email-*.html
+
+# TODO Comment out these rules if you are OK with secrets being uploaded to the repo
+config/initializers/secret_token.rb
+config/secrets.yml
+
+## Environment normalisation:
+/.bundle
+/vendor/bundle
+
+# these should all be checked in to normalise the environment:
+# Gemfile.lock, .ruby-version, .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# if using bower-rails ignore default bower_components path bower.json files
+/vendor/assets/bower_components
+*.bowerrc
+bower.json
+
+bin

data/.ruby-gemset

@@ -0,0 +1 @@
+mockerize

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Mockerize.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Miguel Alonso Jr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Miguel Alonso Jr
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Mockerize.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'Mockerize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'Mockerize'
+  spec.version       = Mockerize::VERSION
+  spec.authors       = ['Miguel Alonso Jr']
+  spec.email         = ['drmiguelalonsojr@gmail.com']
+  spec.summary       = %q{Mockerize is a mock authorize.net customer information management (CIM) class for Rails.}
+  spec.description   = %q{Mockerize is a mock authorize.net customer information management (CIM) class for Rails. It is based on the active-merchant (http://activemerchant.org) authorize.net CIM gateway. It use Redis as a data store to simulate the authorize.net CIM service.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'activemerchant'
+  spec.add_development_dependency 'redis'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'shoulda-matchers'
+  # spec.add_development_dependecy 'null_logger'
+end

data/README.md

@@ -0,0 +1,60 @@
+# Mockerize
+
+Mockerize is a mock authorize.net customer information management (CIM) for Rails. It is based on the active-merchant
+(http://activemerchant.org) authorize.net CIM gateway. It use Redis as a data store to simulate the authorize.net
+CIM service.
+
+
+## Dependencies
+
+1. Redis
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'Mockerize'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install Mockerize
+
+## Usage
+
+### Development
+
+To use the mock server in development mode, add
+
+```ruby
+ENV['MOCK_AUTH_NET'] = 'true'
+```
+
+to your development.rb environment file.
+
+### Test
+
+To use the auth.ent servers in test mode, add
+
+```ruby
+  ENV['FORCE_AUTH_NET'] = 'true'
+```
+
+to your test.rb environment file.
+
+## Attribution
+
+Original idea: http://engineering.harrys.com/2014/04/15/mock-authorize.net-gateway.html
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/Mockerize/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/init.rb

@@ -0,0 +1,22 @@
+# Initializer where we inject the mock gateway into global variable AUTHNET_GATEWAY or setup the real client
+
+if !Rails.env.production?
+  ActiveMerchant::Billing::Base.mode = :test
+end
+
+$using_mock_auth_net_gateway = false
+
+# Use FORCE_AUTH_NET to use the real Auth.net API in tests
+# Use MOCK_AUTH_NET to use the mock Auth.net API even in development (good on a plane!)
+if Rails.env.test? && !ENV.has_key?("FORCE_AUTH_NET") || ENV.has_key?("MOCK_AUTH_NET")
+  MockAuthorizeNetCimGateway::LOGGER.info "Test env: using mock auth net"
+  ::AUTHNET_GATEWAY = MockAuthorizeNetCimGateway.new
+  $using_mock_auth_net_gateway = true
+
+else
+  ::AUTHNET_GATEWAY = ActiveMerchant::Billing::AuthorizeNetCimGateway.new(
+      :login => ENV["AUTH_NET_LOGIN"],
+      :password => ENV["AUTH_NET_API_TOKEN"],
+      :test_requests => false
+  )
+end

data/lib/Mockerize.rb

@@ -0,0 +1,13 @@
+require 'Mockerize/version'
+require 'Mockerize/mock_authorize_net_cim_gateway'
+
+module Mockerize
+  def self.deprecated(message, caller=Kernel.caller[1])
+    warning = caller + ": " + message
+    if(respond_to?(:logger) && logger.present?)
+      logger.warn(warning)
+    else
+      warn(warning)
+    end
+  end
+end

data/lib/Mockerize/mock_authorize_net_cim_gateway.rb

@@ -0,0 +1,480 @@
+# Class that will mock out functionality of the AuthNet test sandbox for their CIM API.
+
+require 'active_merchant'
+# TODO: Setup null_logger for optional logging
+# require 'null_logger'
+
+class MockAuthorizeNetCimGateway < ActiveMerchant::Billing::AuthorizeNetCimGateway
+
+  # attr_accessor :logger
+  # private :logger=, :logger
+
+  ## Special Numbers
+  FAILURE_CREDIT_CARD_NUMBER = "4222222222222"      # If this card is entered, we will reject the payment.
+  EXCEPTION_CREDIT_CARD_NUMBER = "4041378749540103" # if this card is entered, payments will throw exceptions
+  UNVOIDABLE_TRANSACTION_ID = "98712498798247"      # If this transaction is voided, it will fail
+
+  ## Redis key prefixes
+  CUSTOMER_PREFIX = "mockcim__customer__"
+  TRANSACTION_PREFIX = "mockcim__transaction__"
+
+  def initialize(options = {})
+    # self.logger = options[:logger] || Nulllogger.instance
+    @redis_url = ENV["REDISCLOUD_URL"] || ENV["REDISTOGO_URL"] || "localhost:6379"
+  end
+
+  def redis
+    if @redis.nil?
+      if @redis_url.start_with?("redis://")
+        # logger.debug "New Redis from redis://"
+        @redis = Redis.new(url: @redis_url)
+      else
+        # logger.debug "New Redis from host/port"
+        host, port = @redis_url.split(":")
+        @redis = Redis.new(host: host, port: port)
+      end
+    else
+      # Force reconnect to deal with after-fork errors
+      #@redis.client.reconnect
+    end
+    return @redis
+  end
+
+
+  def reset
+    # logger.debug "MOCK: reset MockAuthNetCimGateway"
+    keys =  redis.keys("#{CUSTOMER_PREFIX}*")
+    if !keys.empty?
+      ret = redis.del(keys)
+      # logger.debug("Deleted #{ret} customers")
+    end
+    keys = redis.keys("#{TRANSACTION_PREFIX}*")
+    if !keys.empty?
+      ret = redis.del(keys)
+      # logger.debug("Deleted #{ret} transactions")
+    end
+  end
+
+  # CIM API call
+  def create_customer_profile(options)
+    # logger.debug "MOCK: create_customer_profile #{options[:profile]}"
+    # Copied 'requires' from base class
+    requires!(options, :profile)
+    requires!(options[:profile], :email) unless options[:profile][:merchant_customer_id] || options[:profile][:description]
+    requires!(options[:profile], :description) unless options[:profile][:email] || options[:profile][:merchant_customer_id]
+    requires!(options[:profile], :merchant_customer_id) unless options[:profile][:description] || options[:profile][:email]
+
+    customer_profile_id = generate_profile_id
+    email = options[:profile][:email]
+
+    # Check for duplicate emails
+    if !get_customer_by_email(email).nil?
+      puts "Found duplicate:"
+      puts get_customer_by_email(email).inspect
+      return ActiveMerchant::Billing::Response.new(false, "duplicate record", {})
+    end
+
+    profile = {
+        "customer_profile_id" => customer_profile_id,
+        "email" => options[:profile][:email],
+        "payment_profiles" => {}
+    }
+    set_customer(profile)
+    message = "Customer profile created."
+    return ActiveMerchant::Billing::Response.new(true, message, profile)
+  end
+
+  # CIM API call
+  def get_customer_profile(options)
+    requires!(options, :customer_profile_id)
+    id = options[:customer_profile_id]
+    # logger.debug "MOCK: get_customer_profile: #{id}"
+    customer = get_customer(options[:customer_profile_id])
+
+    # Authnet returns either a hash (if only one profile) or an array of profiles.
+    # Yeah, I'm not fond of that either.
+    payment_profiles = nil
+    if customer["payment_profiles"].keys.length == 1
+      key = customer["payment_profiles"].keys[0]
+      # logger.debug "MOCK: found single payment profile: #{key}"
+      payment_profiles = mask_cc(customer["payment_profiles"][key])
+      payment_profiles["customer_payment_profile_id"] = key
+    elsif customer["payment_profiles"].keys.length > 1
+      # logger.debug "MOCK: found multiple (#{customer["payment_profiles"].keys.length}) payment profiles"
+      payment_profiles = []
+      customer["payment_profiles"].each do |this_id, profile|
+        profile["customer_payment_profile_id"] = this_id
+        payment_profiles << mask_cc(profile)
+      end
+    end
+
+    response = {
+        "profile" => {}
+    }
+    if !payment_profiles.nil?
+      response = {
+          "profile" => {
+              "email" => customer["email"],
+              "payment_profiles" => payment_profiles
+          }
+      }
+    end
+    return ActiveMerchant::Billing::Response.new(true, "", response)
+  end
+
+  # CIM API call
+  def update_customer_profile(options)
+    requires!(options, :profile)
+    requires!(options[:profile], :customer_profile_id)
+    customer_id = options[:profile][:customer_profile_id]
+    # logger.debug "MOCK update_customer_profile: #{customer_id}"
+    customer = get_customer(customer_id)
+    if customer.nil?
+      return ActiveMerchant::Billing::Response.new(false, "customer not found", {})
+    end
+
+    # logger.debug "Trying to update customer profile with #{options[:profile]}"
+    customer["email"] = options[:profile][:email]
+    set_customer(customer)
+    return ActiveMerchant::Billing::Response.new(true, "Customer profile updated.", customer)
+  end
+
+  # CIM API call
+  def delete_customer_profile(options)
+    requires!(options, :customer_profile_id)
+    key = "#{CUSTOMER_PREFIX}#{options[:customer_profile_id]}"
+    if redis.exists(key)
+      redis.del(key)
+      return ActiveMerchant::Billing::Response.new(true, "", {})
+    else
+      return ActiveMerchant::Billing::Response.new(false, "notfound", {})
+    end
+  end
+
+  # CIM API call
+  def create_customer_payment_profile(options)
+    # logger.debug "MOCK: create_customer_payment_profile: #{options.inspect}"
+    requires!(options, :customer_profile_id)
+    requires!(options, :payment_profile)
+    requires!(options[:payment_profile], :payment)
+
+    payment_profile_id = generate_profile_id
+    begin
+      set_payment_profile(options[:customer_profile_id], payment_profile_id, options[:payment_profile])
+      response = {
+          "customer_payment_profile_id" => payment_profile_id
+      }
+      return ActiveMerchant::Billing::Response.new(true, "", response)
+    rescue Exception => e
+      return ActiveMerchant::Billing::Response.new(false,"#{e}", {})
+    end
+  end
+
+  # CIM API call
+  def update_customer_payment_profile(options)
+    requires!(options, :customer_profile_id, :payment_profile)
+    requires!(options[:payment_profile], :customer_payment_profile_id)
+    profile_id = options[:payment_profile][:customer_payment_profile_id].to_s
+    # logger.debug "MOCK: update_customer_payment_profile: #{profile_id}"
+    payment_profile = options[:payment_profile]
+    begin
+      set_payment_profile(options[:customer_profile_id], profile_id, payment_profile)
+      response = {
+          "customer_payment_profile_id" => profile_id
+      }
+      return ActiveMerchant::Billing::Response.new(true, "", response)
+    rescue Exception => e
+      # logger.error "Exception updating billing profile: #{e}"
+      return ActiveMerchant::Billing::Response.new(false, "#{e}", {})
+    end
+  end
+
+  # CIM API call
+  def delete_customer_payment_profile(options)
+    requires!(options, :customer_profile_id)
+    requires!(options, :customer_payment_profile_id)
+    payment_profile_id = options[:customer_payment_profile_id].to_s
+    # logger.debug "MOCK: delete customer payment profile #{payment_profile_id}"
+    customer = get_customer(options[:customer_profile_id])
+    if !customer["payment_profiles"].has_key?(payment_profile_id)
+      return ActiveMerchant::Billing::Response.new(false, "Not found", {})
+    end
+
+    customer["payment_profiles"].delete(payment_profile_id)
+    set_customer(customer)
+    return ActiveMerchant::Billing::Response.new(true, "Successful.", {})
+
+  end
+
+  # CIM API call
+  def create_customer_profile_transaction(options)
+    requires!(options, :transaction)
+    requires!(options[:transaction], :type)
+    case options[:transaction][:type]
+      when :void
+        return void_transaction(options)
+      when :refund
+        return refund_transaction(options)
+      when :prior_auth_capture
+        return prior_auth_capture(options)
+      else
+        return auth_capture(options)
+    end
+  end
+
+  # Method for inspecting the mock
+  def get_transaction_by_invoice_number(invoice_number)
+    redis.keys("#{TRANSACTION_PREFIX}*").each do |key|
+      transaction = JSON.parse(redis.get(key))
+      if transaction["invoice_number"] == invoice_number
+        return transaction
+      end
+    end
+    return nil
+  end
+
+  def get_customer_by_email(email)
+    redis.keys("#{CUSTOMER_PREFIX}*").each do |key|
+      customer = JSON.parse(redis.get(key))
+      if customer["email"] == email
+        return customer
+      end
+    end
+    return nil
+  end
+
+  # Method for getting transaction by transaction id. Only used for testing.
+
+  def get_transaction_by_id(transaction_id)
+    return get_transaction(transaction_id)
+  end
+
+  private
+  # Implement ':void' in customer profile transaction
+  def void_transaction(options)
+    requires!(options[:transaction], :trans_id)
+    id = options[:transaction][:trans_id]
+    # logger.debug "MOCK: voiding transaction #{id}"
+
+    # Verify that transaction exists and is not already voided
+    if id == UNVOIDABLE_TRANSACTION_ID
+      return ActiveMerchant::Billing::Response.new(false, "Forced void failure", {})
+    end
+
+    transaction = get_transaction(id)
+    # Verify that transaction exists and is not already voided
+    if transaction.nil?
+      return ActiveMerchant::Billing::Response.new(false, "Transaction not found", {})
+    end
+
+    if transaction["void"] == true
+      return ActiveMerchant::Billing::Response.new(true, "This transaction has already been voided", {})
+    end
+
+    transaction["void"] = true
+    return ActiveMerchant::Billing::Response.new(true, "This transaction has been voided.", {})
+  end
+
+  # Handle ':refund' in customer profile transaction (not used in our unit tests)
+  def refund_transaction(options)
+    requires!(options[:transaction], :trans_id) && (
+    (options[:transaction][:customer_profile_id] && options[:transaction][:customer_payment_profile_id]) ||
+        options[:transaction][:credit_card_number_masked] ||
+        (options[:transaction][:bank_routing_number_masked] && options[:transaction][:bank_account_number_masked])
+    )
+    # We don't use this in unit tests, because you can only refund after settlement
+    raise "Refunds not implemented"
+  end
+
+  # Handle ':prior_auth_capture' in customer profile transaction (not used in our unit tests)
+  def prior_auth_capture(options)
+    # We don't use this, sorry
+    raise "Prior auth capture not implemented"
+  end
+
+  # Handle ':auth_capture' in customer profile transaction i.e. actually charge user
+  def auth_capture(options)
+    requires!(options[:transaction], :amount, :customer_profile_id, :customer_payment_profile_id)
+    customer_profile_id = options[:transaction][:customer_profile_id]
+    payment_profile_id = options[:transaction][:customer_payment_profile_id].to_s
+    amount = options[:transaction][:amount]
+    if options[:transaction][:order] != nil
+      invoice_number = options[:transaction][:order][:invoice_number]
+      purchase_order_number = options[:transaction][:order][:purchase_order_number]
+    else
+      invoice_number = ''
+      purchase_order_number = ''
+    end
+
+    # logger.debug "MOCK auth_capture transaction for $#{amount}"
+
+    # Check that customer exists
+    customer = get_customer(customer_profile_id)
+    if customer.nil?
+      return ActiveMerchant::Billing::Response.new(false, "Customer not found", {})
+    end
+
+    # Check that billing profile exists
+    payment_profile = customer["payment_profiles"][payment_profile_id]
+    if payment_profile.nil?
+      return ActiveMerchant::Billing::Response.new(false, "Payment profile not found #{payment_profile_id}", {})
+    end
+
+    if payment_profile["payment"]["credit_card"]["card_number"] == FAILURE_CREDIT_CARD_NUMBER
+      # logger.debug "MOCK: failure cc number detected: returning error"
+      return ActiveMerchant::Billing::Response.new(false, "Forced test failure", {})
+    end
+
+
+    # Save transaction
+    transaction_id = generate_profile_id
+    approval_code = generate_profile_id
+    transaction = {
+        "id" => transaction_id,
+        "amount" => amount,
+        "customer_profile_id" => customer_profile_id,
+        "customer_payment_profile_id" => payment_profile_id,
+        "invoice_number" => invoice_number,
+        "purchase_order_number" => purchase_order_number,
+        "void" => false,
+        "approval_code" => approval_code
+    }
+    set_transaction(transaction_id, transaction)
+
+    if payment_profile["payment"]["credit_card"]["card_number"] == EXCEPTION_CREDIT_CARD_NUMBER
+      # logger.debug "MOCK: exception cc number detected: throwing exception"
+      raise Exception.new("FORCED EXCEPTION IN AUTH NET MOCK")
+    end
+
+    params = {
+        "direct_response" => {
+            "transaction_id" => transaction_id,
+            "approval_code" => approval_code,
+            "raw" => "Andy wuz ere"
+        }
+    }
+
+    return ActiveMerchant::Billing::Response.new(true, "", params)
+  end
+
+  # Helper method for finding customers in fake gateway store
+  def get_customer(customer_id)
+    customer = redis.get("#{CUSTOMER_PREFIX}#{customer_id}")
+    if !customer.nil?
+      customer = JSON.parse(customer)
+    end
+    return customer
+  end
+
+  def set_customer(customer)
+    redis.set("#{CUSTOMER_PREFIX}#{customer["customer_profile_id"]}", customer.to_json)
+  end
+
+  def get_transaction(transaction_id)
+    transaction = redis.get("#{TRANSACTION_PREFIX}#{transaction_id}")
+    if !transaction.nil?
+      transaction = JSON.parse(transaction)
+    end
+    return transaction
+  end
+
+  def set_transaction(transaction_id, transaction)
+    redis.set("#{TRANSACTION_PREFIX}#{transaction_id}", transaction.to_json)
+  end
+
+  def find_transaction_by_invoice_number(invoice_number)
+  end
+
+  # Helper method for storing payment profiles
+  def set_payment_profile(customer_id, payment_profile_id, payment_profile)
+    customer = get_customer(customer_id)
+    payment_profile = payment_profile.with_indifferent_access
+    # logger.debug "Setting payment profile #{payment_profile_id}: #{payment_profile.inspect}"
+    if customer["payment_profiles"].has_key?(payment_profile_id)
+      customer["payment_profiles"][payment_profile_id] = update_payment_profile(
+          customer["payment_profiles"][payment_profile_id],
+          payment_profile)
+    else
+
+      customer["payment_profiles"].each do |payment_id|
+        if payment_id != nil && payment_id[1]["payment"]["credit_card"]["card_number"] == payment_profile["payment"]["credit_card"].number
+          raise "A duplicate customer payment profile already exists."
+        end
+      end
+
+      if payment_profile.has_key?("payment")
+        payment_profile["payment"]["credit_card"] = cc_to_hash(payment_profile["payment"]["credit_card"])
+      end
+      customer["payment_profiles"][payment_profile_id] = payment_profile
+    end
+    set_customer(customer)
+  end
+
+  # Helper method for selectively updating payment profiles
+  def update_payment_profile(existing_profile, new_profile)
+    profile = {}
+    if new_profile.has_key?("bill_to")
+      profile["bill_to"] = new_profile["bill_to"]
+    elsif existing_profile.has_key?("bill_to")
+      profile["bill_to"] = existing_profile["bill_to"]
+    end
+
+    # If the user included the credit card, we'll set it
+    if new_profile.has_key?("payment")
+      new_profile["payment"]["credit_card"] = cc_to_hash(new_profile["payment"]["credit_card"])
+      profile["payment"] = new_profile["payment"]
+      new_number =  new_profile["payment"]["credit_card"]["card_number"]
+      existing_number = existing_profile["payment"]["credit_card"]["card_number"]
+      # But if the user send a masked credit card, we'll check it's correct, then keep the existing one.
+      if new_number[0] == "X"
+        # logger.debug "Found blanked CC"
+        if existing_number[-4..-1] != new_number[-4..-1]
+          raise "does not match the original value"
+        end
+        profile["payment"]["credit_card"]["card_number"] = existing_number
+      end
+    elsif existing_profile.has_key?("payment")
+      profile["payment"] = existing_profile["payment"]
+    end
+    return profile
+  end
+
+  # Convert a ActiveMervchant credit card object to a hash (which is what we store and return)
+  def cc_to_hash(credit_card)
+    if credit_card.is_a?(Hash)
+      return credit_card
+    end
+    if credit_card.nil?
+      return nil
+    end
+    # logger.debug "Converting CC to hash: #{credit_card.inspect}"
+    hash = {
+        "card_number" => credit_card.number,
+        "expiration_date" => credit_card.year.to_s + credit_card.month.to_s
+    }
+    return hash
+  end
+
+  # When returning the credit card, we mask the number and expiration
+  def mask_cc(payment_profile)
+    payment_profile = payment_profile.with_indifferent_access
+    masked = payment_profile.deep_dup
+    if masked["payment"].nil?
+      return masked
+    end
+    cc = cc_to_hash(masked["payment"]["credit_card"])
+    if !cc.nil?
+      masked["payment"]["credit_card"] = {
+          "card_number" => "XXXX" + cc["card_number"][-4..-1],
+          "expiration_date" => "XXXX" }
+    end
+    return masked
+  end
+
+  # Generate realistic-looking auth.net customer profile ids
+  def generate_profile_id(length=9)
+    num = SecureRandom.random_number(10**length - 1)
+    return (num + 1).to_s
+  end
+
+end

data/lib/Mockerize/version.rb

@@ -0,0 +1,3 @@
+module Mockerize
+  VERSION = '0.0.1'
+end

data/spec/mock_authorize_net_cim_gateway_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MockAuthorizeNetCimGateway do
+  it 'has a version number' do
+    expect(Mockerize::VERSION).not_to be nil
+  end
+
+  it 'does something useful' do
+    expect(true).to eq(true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'Mockerize'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+
+  config.before(:each) do
+    # Wipe the auth.net mock data to avoid O(N) slowdown looking for existing email addresses
+    ::AUTHNET_GATEWAY.reset if $using_mock_auth_net_gateway
+  end
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: Mockerize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Miguel Alonso Jr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activemerchant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Mockerize is a mock authorize.net customer information management (CIM)
+  class for Rails. It is based on the active-merchant (http://activemerchant.org)
+  authorize.net CIM gateway. It use Redis as a data store to simulate the authorize.net
+  CIM service.
+email:
+- drmiguelalonsojr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- Mockerize.gemspec
+- README.md
+- Rakefile
+- init.rb
+- lib/Mockerize.rb
+- lib/Mockerize/mock_authorize_net_cim_gateway.rb
+- lib/Mockerize/version.rb
+- spec/mock_authorize_net_cim_gateway_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Mockerize is a mock authorize.net customer information management (CIM) class
+  for Rails.
+test_files:
+- spec/mock_authorize_net_cim_gateway_spec.rb
+- spec/spec_helper.rb