ActiveMerchant-FatZebra 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/ActiveMerchant-FatZebra.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "ActiveMerchant-FatZebra"
+  s.version     = "1.0.0"
+  s.authors     = ["Matthew Savage"]
+  s.email       = ["matthew.savage@fatzebra.com.au"]
+  s.homepage    = "https://www.fatzebra.com.au"
+  s.summary     = %q{Fat Zebra support for Active Merchant, as a gem}
+  s.description = %q{Fat Zebra support for Active Merchant - temporary gem until support is combined into active_merchant core.}
+
+  s.rubyforge_project = "ActiveMerchant-FatZebra"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "activemerchant"
+  s.add_development_dependency "rake"
+  s.add_development_dependency('mocha', '~> 0.11.3')
+  s.add_development_dependency('rails', '>= 2.3.11')
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ActiveMerchant-FatZebra.gemspec
+gemspec

data/README.md

@@ -0,0 +1,62 @@
+FatZebra ActiveMerchant integration
+===================================
+
+The quick 30-second rundown
+---------------------------
+
+1. Install the gem in your Gemfile
+
+    gem "active_merchant_fat_zebra"
+
+Then `bundle install`
+
+2. Setup the gateway in your app:
+
+```ruby
+
+options = {
+  :login => "test",
+  :token => "test_token"
+}
+gateway = ActiveMerchant::Billing::FatZebraGateway.new(options)
+
+# If you are testing, uncomment the following line
+# ActiveMerchant::Billing::Base.gateway_mode = :test
+```
+
+3. Setup the transaction data and then... transact!
+
+```ruby
+cc = ActiveMerchant::Billing::CreditCard.new(:first_name => "Joe", 
+										:last_name => "Smith",
+										:number => "4444333322221111",
+										:month => 12,
+										:year => 2013,
+										:verification_value => 123)
+
+amount = 10000 # 100.00 in cents
+
+result = gateway.purchase(amount, cc, { :order_id => "ORD18239", :ip => request.ip }) # If you are using rails you would use request.remote_ip
+```
+
+4. Handle the response - the data you get back is:
+
+```ruby
+result.success? # True or False depending on if the txn was successful
+result.message # e.g. "Approved" or "Declined"
+result.id # The transaction ID
+result.test? # Indicates if this was a test transaction
+result.params # Parameters passed by the gateway (e.g. may be additional info like fraud review score.)
+result.params["result"]["id"] # The transaction ID
+result.params["result"]["token"] # The card token (when storing a card)
+```
+
+
+Refunds
+-------
+```ruby
+# Refunding the amount of $100.00, for the original transaction ID of "AB12887Z"
+response = gateway.refund(10000, "AB12887Z", "REFUND1")
+
+response.success? # true or false
+```

data/Rakefile

@@ -0,0 +1,37 @@
+require "bundler/gem_tasks"
+
+$:.unshift File.expand_path('../lib', __FILE__)
+
+begin
+  require 'bundler'
+  Bundler.setup
+rescue LoadError => e
+  puts "Error loading bundler (#{e.message}): \"gem install bundler\" for bundler support."
+  require 'rubygems'
+end
+
+require 'rake'
+require 'rake/testtask'
+
+desc "Run the unit test suite"
+task :default => 'test:all'
+
+namespace :test do
+
+  Rake::TestTask.new(:units) do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.ruby_opts << '-rubygems'
+    t.libs << 'test'
+    t.verbose = true
+  end
+
+  Rake::TestTask.new(:remote) do |t|
+    t.pattern = 'test/remote/**/*_test.rb'
+    t.ruby_opts << '-rubygems'
+    t.libs << 'test'
+    t.verbose = true
+  end
+
+  desc "Test all"
+  task :all => [:units, :remote]
+end

data/lib/ActiveMerchant-FatZebra.rb

@@ -0,0 +1,2 @@
+require 'active_merchant'
+require "active_merchant/billing/gateways/fat_zebra"

data/lib/active_merchant/billing/gateways/fat_zebra.rb

@@ -0,0 +1,153 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FatZebraGateway < Gateway
+      LIVE_URL    = "https://gateway.fatzebra.com.au/v1.0"
+      SANDBOX_URL = "https://gateway.sandbox.fatzebra.com.au/v1.0"
+
+      self.supported_countries = ['AU']
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb]
+
+      self.homepage_url = 'https://www.fatzebra.com.au/'
+      self.display_name = 'Fat Zebra'
+    
+      # Setup a new instance of the gateway.
+      #
+      # The options hash should include :username and :token
+      # You can find your username and token at https://dashboard.fatzebra.com.au
+      # Under the Your Account section
+      def initialize(options = {})
+        requires!(options, :username)
+        requires!(options, :token)
+        @username = options[:username]
+        @token    = options[:token]
+        super
+      end
+
+      # To create a purchase on a credit card use:
+      #
+      #   purchase(money, creditcard , { ... })
+      #
+      # To charge a tokenized card
+      #
+      #   purchase(money, {:token => "abzy87u", :cvv => "123"}, { ... }})
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        post[:reference] = options[:order_id]
+        post[:customer_ip] = options[:ip]
+
+        commit(:post, 'purchases', post)
+      end
+
+      # Refund a transaction
+      #
+      # amount - Integer - the amount to refund
+      # txn_id - String - the original transaction to be refunded
+      # reference - String - your transaction reference
+      def refund(money, txn_id, reference)
+        post = {}
+
+        post[:amount] = money
+        post[:transaction_id] = txn_id
+        post[:reference] = reference
+
+        commit(:post, "refunds", post)
+      end
+
+      # Tokenize a credit card
+      def store(creditcard)
+        post = {}
+        add_creditcard(post, creditcard)
+
+        commit(:post, "credit_cards", post)
+      end
+
+      private
+      # Add the money details to the request
+      def add_amount(post, money, options)
+        post[:amount] = money
+      end
+
+      # Add the credit card details to the request
+      def add_creditcard(post, creditcard, options = {})
+        if creditcard.respond_to?(:number)
+          post[:card_number] = creditcard.number
+          post[:card_expiry] = "#{creditcard.month}/#{creditcard.year}"
+          post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+          post[:card_holder] = creditcard.name if creditcard.name
+        else
+            post[:card_token] = creditcard[:token]
+            post[:cvv] = creditcard[:cvv]
+        end
+      end
+
+      # Post the data to the gateway
+      def commit(method, uri, parameters=nil)
+        raw_response = response = nil
+        success = false
+        begin
+          raw_response = ssl_request(method, get_url(uri), parameters.to_json, headers)
+          response = parse(raw_response)
+          success = response["successful"] && (response["response"]["successful"] || response["response"]["token"])
+        rescue ResponseError => e
+          if e.response.code == "401"
+            return Response.new(false, "Invalid Login")
+          end
+
+          raw_response = e.response.body
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        message = response["response"]["message"]
+        unless response["successful"]
+          # There is an error, so we will show that instead
+          message = response["errors"].empty? ? "Unknown Error" : response["errors"].join(", ")
+        end
+
+        Response.new(success,
+          message,
+          response,
+          :test => response.has_key?("test") ? response["test"] : false,
+          :authorization => response["response"]["authorization"],
+          :id => response["response"]["id"])
+      end
+
+      # Parse the returned JSON, if parse errors are raised then return a detailed error.
+      def parse(response)
+        begin
+          JSON.parse(response)
+        rescue JSON::ParserError
+          msg = 'Invalid JSON response received from Fat Zebra. Please contact support@fatzebra.com.au if you continue to receive this message.'
+          msg += "  (The raw response returned by the API was #{response.inspect})"
+          {
+            "successful" => false,
+            "response" => {},
+            "errors" => [msg]
+          }
+        end
+      end
+
+      # Build the URL based on the AM mode and the URI
+      def get_url(uri)
+        base = test? ? SANDBOX_URL : LIVE_URL
+        base + "/" + uri
+      end
+
+      # Builds the auth and U-A headers for the request
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.encode64(@username.to_s + ":" + @token.to_s).strip,
+          "User-Agent" => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
+        }
+      end 
+    end
+  end
+end

data/test/comm_stub.rb

@@ -0,0 +1,39 @@
+module CommStub
+  class Stub
+    def initialize(gateway, action)
+      @gateway = gateway
+      @action = action
+      @complete = false
+    end
+
+    def check_request(&block)
+      @check = block
+      self
+    end
+
+    def respond_with(*responses)
+      @complete = true
+      check = @check
+      (class << @gateway; self; end).send(:define_method, :ssl_post) do |*args|
+        check.call(*args) if check
+        (responses.size == 1 ? responses.last : responses.shift)
+      end
+      @action.call
+    end
+
+    def complete?
+      @complete
+    end
+  end
+
+  def stub_comms(gateway=@gateway, &action)
+    if @last_comm_stub
+      assert @last_comm_stub.complete?, "Tried to stub communications when there's a stub already in progress."
+    end
+    @last_comm_stub = Stub.new(gateway, action)
+  end
+
+  def teardown
+    assert(@last_comm_stub.complete?) if @last_comm_stub
+  end
+end

data/test/fixtures.yml

@@ -0,0 +1,3 @@
+fat_zebra:
+  username: TEST
+  token: TEST

data/test/remote/gateways/remote_fat_zebra_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class RemoteFatZebraTest < Test::Unit::TestCase
+
+
+  def setup
+    @gateway = FatZebraGateway.new(fixtures(:fat_zebra))
+
+    @amount = 100
+    @credit_card = credit_card('5123456789012346')
+    @declined_card = credit_card('4557012345678902')
+
+    @options = {
+      :order_id => rand(100000).to_s,
+      :ip => "123.1.2.3"
+    }
+  end
+
+  def test_successful_purchase
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_success response
+    assert_equal 'Approved', response.message
+  end
+
+  def test_unsuccessful_purchase
+    assert response = @gateway.purchase(@amount, @declined_card, @options)
+    assert_failure response
+    assert_equal 'Declined', response.message
+  end
+
+  def test_invalid_data
+    @options.delete(:ip)
+    assert response = @gateway.purchase(@amount, @declined_card, @options)
+    assert_failure response
+    assert_equal "Customer ip can't be blank", response.message
+  end
+
+  def test_refund
+    purchase = @gateway.purchase(@amount, @credit_card, @options)
+    
+    assert response = @gateway.refund(@amount, purchase.params["response"]["id"], rand(1000000).to_s)
+    assert_success response
+    assert_match /Approved/, response.message
+  end
+
+  def test_invalid_refund
+    purchase = @gateway.purchase(@amount, @credit_card, @options)
+
+    assert response = @gateway.refund(@amount, nil, rand(1000000).to_s)
+    assert_failure response
+    assert_match /Original transaction is required/, response.message
+  end
+
+  def test_store
+    assert card = @gateway.store(@credit_card)
+
+    assert_success card
+    assert_false card.params["response"]["token"].nil?
+  end
+
+  def test_purchase_with_token
+    assert card = @gateway.store(@credit_card)
+    assert purchase = @gateway.purchase(@amount, {:cvv => 123, :token => card.params["response"]["token"]}, @options)
+    assert_success purchase
+  end
+
+  def test_invalid_login
+    gateway = FatZebraGateway.new(
+                :username => 'invalid',
+                :token => 'wrongtoken'
+              )
+    assert response = gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert_equal 'Invalid Login', response.message
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+begin
+  require 'rubygems'
+  require 'bundler'
+  Bundler.setup
+rescue LoadError => e
+  puts "Error loading bundler (#{e.message}): \"gem install bundler\" for bundler support."
+end
+
+require 'test/unit'
+require 'money'
+require 'mocha'
+require 'yaml'
+require 'active_merchant'
+require 'active_merchant/billing/gateways/fat_zebra'
+require 'comm_stub'
+
+require 'active_support/core_ext/integer/time'
+require 'active_support/core_ext/numeric/time'
+
+
+
+begin
+  require 'active_support/core_ext/time/acts_like'
+rescue LoadError
+end
+
+begin
+  gem 'actionpack'
+rescue LoadError
+  raise StandardError, "The view tests need ActionPack installed as gem to run"
+end
+
+require 'action_controller'
+require "action_view/template"
+begin
+  require 'active_support/core_ext/module/deprecation'
+  require 'action_dispatch/testing/test_process'
+rescue LoadError
+  require 'action_controller/test_process'
+end
+require 'active_merchant/billing/integrations/action_view_helper'
+
+ActiveMerchant::Billing::Base.mode = :test
+
+if ENV['DEBUG_ACTIVE_MERCHANT'] == 'true'
+  require 'logger'
+  ActiveMerchant::Billing::Gateway.logger = Logger.new(STDOUT)
+  ActiveMerchant::Billing::Gateway.wiredump_device = STDOUT
+end
+
+# Test gateways
+class SimpleTestGateway < ActiveMerchant::Billing::Gateway
+end
+
+class SubclassGateway < SimpleTestGateway
+end
+
+
+module ActiveMerchant
+  module Assertions
+    AssertionClass = RUBY_VERSION > '1.9' ? MiniTest::Assertion : Test::Unit::AssertionFailedError
+    
+    def assert_field(field, value)
+      clean_backtrace do 
+        assert_equal value, @helper.fields[field]
+      end
+    end
+    
+    # Allows the testing of you to check for negative assertions: 
+    # 
+    #   # Instead of
+    #   assert !something_that_is_false
+    # 
+    #   # Do this
+    #   assert_false something_that_should_be_false
+    # 
+    # An optional +msg+ parameter is available to help you debug.
+    def assert_false(boolean, message = nil)
+      message = build_message message, '<?> is not false or nil.', boolean
+    
+      clean_backtrace do
+        assert_block message do
+          not boolean
+        end
+      end
+    end
+    
+    # A handy little assertion to check for a successful response: 
+    # 
+    #   # Instead of
+    #   assert_success response
+    # 
+    #   # DRY that up with
+    #   assert_success response
+    # 
+    # A message will automatically show the inspection of the response 
+    # object if things go afoul.
+    def assert_success(response)
+      clean_backtrace do
+        assert response.success?, "Response failed: #{response.inspect}"
+      end
+    end
+    
+    # The negative of +assert_success+
+    def assert_failure(response)
+      clean_backtrace do
+        assert_false response.success?, "Response expected to fail: #{response.inspect}"
+      end
+    end
+    
+    def assert_valid(validateable)
+      clean_backtrace do
+        assert validateable.valid?, "Expected to be valid"
+      end
+    end
+    
+    def assert_not_valid(validateable)
+      clean_backtrace do
+        assert_false validateable.valid?, "Expected to not be valid"
+      end
+    end
+
+    def assert_deprecation_warning(message, target)
+      target.expects(:deprecated).with(message)
+      yield
+    end
+    
+    private
+    def clean_backtrace(&block)
+      yield    
+    rescue AssertionClass => e
+      path = File.expand_path(__FILE__)
+      raise AssertionClass, e.message, e.backtrace.reject { |line| File.expand_path(line) =~ /#{path}/ }
+    end
+  end
+  
+  module Fixtures
+    HOME_DIR = RUBY_PLATFORM =~ /mswin32/ ? ENV['HOMEPATH'] : ENV['HOME'] unless defined?(HOME_DIR)
+    LOCAL_CREDENTIALS = File.join(HOME_DIR.to_s, '.active_merchant/fixtures.yml') unless defined?(LOCAL_CREDENTIALS)
+    DEFAULT_CREDENTIALS = File.join(File.dirname(__FILE__), 'fixtures.yml') unless defined?(DEFAULT_CREDENTIALS)
+    
+    private
+    def credit_card(number = '4242424242424242', options = {})
+      defaults = {
+        :number => number,
+        :month => 9,
+        :year => Time.now.year + 1,
+        :first_name => 'Longbob',
+        :last_name => 'Longsen',
+        :verification_value => '123',
+        :brand => 'visa'
+      }.update(options)
+
+      Billing::CreditCard.new(defaults)
+    end
+    
+    def check(options = {})
+      defaults = {
+        :name => 'Jim Smith',
+        :routing_number => '244183602', 
+        :account_number => '15378535', 
+        :account_holder_type => 'personal', 
+        :account_type => 'checking', 
+        :number => '1'
+      }.update(options)
+      
+      Billing::Check.new(defaults)
+    end
+    
+    def address(options = {})
+      { 
+        :name     => 'Jim Smith',
+        :address1 => '1234 My Street',
+        :address2 => 'Apt 1',
+        :company  => 'Widgets Inc',
+        :city     => 'Ottawa',
+        :state    => 'ON',
+        :zip      => 'K1C2N6',
+        :country  => 'CA',
+        :phone    => '(555)555-5555',
+        :fax      => '(555)555-6666'
+      }.update(options)
+    end
+    
+    def all_fixtures
+      @@fixtures ||= load_fixtures
+    end
+    
+    def fixtures(key)
+      data = all_fixtures[key] || raise(StandardError, "No fixture data was found for '#{key}'")
+      
+      data.dup
+    end
+        
+    def load_fixtures
+      [DEFAULT_CREDENTIALS, LOCAL_CREDENTIALS].inject({}) do |credentials, file_name|
+        if File.exists?(file_name)
+          yaml_data = YAML.load(File.read(file_name))
+          credentials.merge!(symbolize_keys(yaml_data))
+        end
+        credentials
+      end
+    end
+    
+    def symbolize_keys(hash)
+      return unless hash.is_a?(Hash)
+      
+      hash.symbolize_keys!
+      hash.each{|k,v| symbolize_keys(v)}
+    end
+  end
+end
+
+Test::Unit::TestCase.class_eval do
+  include ActiveMerchant::Billing
+  include ActiveMerchant::Assertions
+  include ActiveMerchant::Utils
+  include ActiveMerchant::Fixtures
+end
+
+module ActionViewHelperTestHelper
+
+  def self.included(base)
+    base.send(:include, ActiveMerchant::Billing::Integrations::ActionViewHelper)
+    base.send(:include, ActionView::Helpers::FormHelper)
+    base.send(:include, ActionView::Helpers::FormTagHelper)
+    base.send(:include, ActionView::Helpers::UrlHelper)
+    base.send(:include, ActionView::Helpers::TagHelper)
+    base.send(:include, ActionView::Helpers::CaptureHelper)
+    base.send(:include, ActionView::Helpers::TextHelper)
+    base.send(:attr_accessor, :output_buffer)
+  end
+
+  def setup
+    @controller = Class.new do
+      attr_reader :url_for_options
+      def url_for(options, *parameters_for_method_reference)
+        @url_for_options = options
+      end
+    end
+    @controller = @controller.new
+    @output_buffer = ''
+  end
+
+  protected
+  def protect_against_forgery?
+    false
+  end
+end

data/test/unit/gateways/fat_zebra_test.rb

@@ -0,0 +1,172 @@
+require 'test_helper'
+
+class FatZebraTest < Test::Unit::TestCase
+  def setup
+    @gateway = FatZebraGateway.new(
+                 :username => 'TEST',
+                 :token    => 'TEST'
+               )
+
+    @credit_card = credit_card
+    @amount = 100
+
+    @options = {
+      :order_id => rand(10000),
+      :billing_address => address,
+      :description => 'Store Purchase'
+    }
+  end
+
+  def test_successful_purchase
+    @gateway.expects(:ssl_request).returns(successful_purchase_response)
+
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_success response
+
+    # Replace with authorization number from the successful response
+    assert_equal '55355', response.authorization
+    assert response.test?
+  end
+
+  def test_unsuccessful_request
+    @gateway.expects(:ssl_request).returns(failed_purchase_response)
+
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert response.test?
+    assert_match /Invalid Card Number/, response.message
+  end
+
+  def test_declined_purchase
+    @gateway.expects(:ssl_request).returns(declined_purchase_response)
+
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert response.test?
+    assert_match /Card Declined/, response.message
+  end
+
+  def test_parse_error
+    @gateway.expects(:ssl_request).returns("{") # Some invalid JSON
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert_match /Invalid JSON response/, response.message
+  end
+
+  def test_request_error
+    @gateway.expects(:ssl_request).returns(missing_data_response)
+
+    assert response = @gateway.purchase(@amount, @credit_card, @options)
+    assert_failure response
+    assert_match /Card Number is required/, response.message
+  end
+
+  def test_successful_tokenization
+    @gateway.expects(:ssl_request).returns(successful_tokenize_response)
+
+    assert response = @gateway.store(@credit_card)
+    assert_success response
+  end
+
+  def test_unsuccessful_tokenization
+    @gateway.expects(:ssl_request).returns(failed_tokenize_response)
+
+    assert response = @gateway.store(@credit_card)
+    assert_failure response
+  end
+
+  private
+
+  # Place raw successful response from gateway here
+  def successful_purchase_response
+    {
+      :successful => true,
+      :response => {
+        :authorization => "55355",
+        :id => "001-P-12345AA",
+        :card_number => "XXXXXXXXXXXX1111",
+        :card_holder => "John Smith",
+        :card_expiry => "10/2011",
+        :card_token => "a1bhj98j",
+        :amount => 349,
+        :successful => true,
+        :reference => "ABC123",
+        :message => "Approved",
+      },
+      :test => true,
+      :errors => []
+    }.to_json
+  end
+
+  def declined_purchase_response
+    {
+      :successful => true,
+      :response => {
+          :authorization_id => nil,
+          :id => nil,
+          :card_number => "XXXXXXXXXXXX1111",
+          :card_holder => "John Smith",
+          :card_expiry => "10/2011",
+          :amount => 100,
+          :authorized => false,
+          :reference => "ABC123",
+          :message => "Card Declined - check with issuer",
+      },
+      :test => true,
+      :errors => [] 
+    }.to_json
+  end
+
+  def successful_tokenize_response
+    {
+      :successful => true,
+      :response => {
+        :token => "e1q7dbj2",
+        :card_holder => "Bob Smith",
+        :card_number => "XXXXXXXXXXXX2346",
+        :card_expiry => "2013-05-31T23:59:59+10:00",
+        :authorized => true,
+        :transaction_count => 0
+      },
+      :errors => [],
+      :test => true
+    }.to_json
+  end
+
+  def failed_tokenize_response
+    {
+      :successful => false,
+      :response => {
+        :token => nil,
+        :card_holder => "Bob ",
+        :card_number => "512345XXXXXX2346",
+        :card_expiry => nil,
+        :authorized => false,
+        :transaction_count => 10
+      },
+      :errors => [
+        "Expiry date can't be blank"
+      ],
+      :test => false
+    }.to_json
+  end
+
+  # Place raw failed response from gateway here
+  def failed_purchase_response
+    {
+      :successful => false,
+      :response => {},
+      :test => true,
+      :errors => ["Invalid Card Number"]
+    }.to_json
+  end
+
+  def missing_data_response
+    {
+      :successful => false,
+      :response => {},
+      :test => true,
+      :errors => ["Card Number is required"]
+    }.to_json
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: ActiveMerchant-FatZebra
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Savage
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemerchant
+  requirement: &70121469611100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70121469611100
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70121469610340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70121469610340
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70121469608900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: *70121469608900
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70121469645180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.11
+  type: :development
+  prerelease: false
+  version_requirements: *70121469645180
+description: Fat Zebra support for Active Merchant - temporary gem until support is
+  combined into active_merchant core.
+email:
+- matthew.savage@fatzebra.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- ActiveMerchant-FatZebra.gemspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/ActiveMerchant-FatZebra.rb
+- lib/active_merchant/billing/gateways/fat_zebra.rb
+- test/comm_stub.rb
+- test/fixtures.yml
+- test/remote/gateways/remote_fat_zebra_test.rb
+- test/test_helper.rb
+- test/unit/gateways/fat_zebra_test.rb
+homepage: https://www.fatzebra.com.au
+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: 3400427441090863407
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3400427441090863407
+requirements: []
+rubyforge_project: ActiveMerchant-FatZebra
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Fat Zebra support for Active Merchant, as a gem
+test_files:
+- test/comm_stub.rb
+- test/fixtures.yml
+- test/remote/gateways/remote_fat_zebra_test.rb
+- test/test_helper.rb
+- test/unit/gateways/fat_zebra_test.rb