fat_zebra 1.1.3 → 1.1.4

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmU1MzgwMjdkYTJlMDM2OTc2MDEzZWVlODI3OTMzN2Y0MzAyZjRmZA==
+  data.tar.gz: !binary |-
+    ODBlZTlmNzY2MGQ2ZTY0MTI4MTJmOTcyY2VjMmFkMWYwMjM4ZWNjMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTA3ZDc2ZWIyZTcxNGZmMTg0ZDViMWRkNmI0NTQyNzdhODExNzdkMmI5NDg4
+    NzY1M2JiNGNlODNjNDk1YzE4ZTQzZDIxNWVhZWQ2ZTMxZGUwOGRkZTg1NTUy
+    OTI1Y2U5ODEzYmQzYWIyODNlNTA0MzlmMDY5NjBiN2Q1ZDQyYWY=
+  data.tar.gz: !binary |-
+    NjQ4NjIxOWJjMmQ0OWEwYzE4MzBiMTY0Y2ExZWUzNGQ0ZjFlNTIwZmQyMjlm
+    NjY0ZjExYTE0Y2MwZWExZGY3NWJiMWZlMTQxY2E4NDJlOTVkNDE2NDY2ZTA4
+    NDMxZjg5MDFlMTk2YTkyZDhjZjE5MjA2NDA4OTE4YzQwMWE2NjY=

data/README.markdown

@@ -1,7 +1,7 @@
 Ruby API Library for Fat Zebra
 ==============================
 
-Release 1.1.3 for API version 1.0
+Release 1.1.4 for API version 1.0
 
 A Ruby client for the [Fat Zebra](https://www.fatzebra.com.au) Online Payment Gateway (for Australian Merchants)
 

data/lib/fat_zebra/config.rb

@@ -0,0 +1,39 @@
+module FatZebra
+	class Config
+
+    # Returns the config values in a hash
+    def config
+      @config ||= {}
+    end
+
+    [:username, :token, :test_mode, :sandbox, :options, :gateway].each do |attr|
+      define_method "#{attr}" do |value = nil|
+        if value.nil?
+          config[attr.to_s]
+        else
+          config[attr.to_s] = value
+        end
+      end
+    end
+
+    # Validates the configuration
+    def validate!
+      @errors = []
+
+      @errors << "Username is required" if self.username.nil?
+      @errors << "Username must begin with TEST when using Sandbox Mode" if self.sandbox && !self.username.match(/\ATEST/)
+      @errors << "Token is required" if self.token.nil?
+
+      raise "The following errors were raised during configuration: #{@errors.join(", ")}}" unless @errors.empty?
+    end
+
+    def self.from_hash(hash)
+      c = new
+      hash.each do |key, value|
+        c.send key, value
+      end
+
+      c
+    end
+	end
+end

data/lib/fat_zebra/errors.rb

@@ -1,4 +1,5 @@
 module FatZebra
 	class InvalidArgumentError < StandardError; end
 	class RequestError < StandardError; end
+  class GatewayError < StandardError; end
 end

data/lib/fat_zebra/gateway.rb

@@ -4,14 +4,25 @@ module FatZebra
 		
 		DEFAULT_OPTIONS = {:secure => true, :version => API_VERSION}
 
-		# Public: initializes a new gateway object
+		class << self
+			def configure(config)
+				g = Gateway.new(config.username, config.token, config.gateway || GATEWAY_SERVER)
+				g.options ||= {}
+				g.options[:test_mode] = config.test_mode
+				g.options.merge!(config.options || {})
+
+				g
+			end
+		end
+
+		# Initializes a new gateway object
 		#
-		# username - merchants username
-		# token - merchants token for authentication
-		# gateway_server - the server for the gateway, defaults to 'gateway.fatzebra.com.au'
-		# options - the options for the gateway connection (e.g. secure, version etc)
+		# @param [String] merchants username
+		# @param [String] merchants token for authentication
+		# @param [String] the server for the gateway, defaults to 'gateway.fatzebra.com.au'
+		# @param [Hash] the options for the gateway connection (e.g. secure, version etc)
 		#
-		# Returns a new FatZebra::Gateway instance
+		# @return FatZebra::Gateway instance
 		def initialize(username, token, gateway_server = GATEWAY_SERVER, options = {})
 			self.username = username
 			self.token = token
@@ -21,7 +32,7 @@ module FatZebra
 			require_field :username, :token, :gateway_server
 		end
 
-		# Public: Performs a purchase transaction against the gateway
+		# Performs a purchase transaction against the gateway
 		#
 		# amount - the amount as an integer e.g. (1.00 * 100).to_i
 		# card_data - a hash of the card data (example: {:card_holder => "John Smith", :number => "...", :expiry => "...", :cvv => "123"} or {:token => "abcdefg1"})
@@ -35,38 +46,8 @@ module FatZebra
 		#
 		# Returns a new FatZebra::Models::Response (purchase) object
 		def purchase(amount, card_data, reference, customer_ip, currency = "AUD")
-		
-			if card_data.keys.include?(:token)
-				warn "[DEPRECATED] please use {:card_token => \".....\"} instead of {:token => \".....\"}"
-				card_data[:card_token] ||= card_data.delete(:token)
-			end
-
-			if card_data.keys.include?(:number)
-				warn "[DEPRECATED] please use :card_number instead of :number"
-				card_data[:card_number] ||= card_data.delete(:number)
-			end
-
-			if card_data.keys.include?(:expiry)
-				warn "[DEPRECATED] please use :card_expiry instead of :expiry"
-				card_data[:card_expiry] ||= card_data.delete(:expiry)
-			end
-
-			params = {
-				:amount => amount,
-				:card_holder => card_data.delete(:card_holder),
-				:card_number => card_data.delete(:card_number),
-				:card_expiry => extract_date(card_data.delete(:card_expiry)),
-				:cvv => card_data.delete(:cvv),
-				:card_token => card_data.delete(:card_token),
-				:reference => reference,
-				:customer_ip => customer_ip,
-				:currency => currency
-			}
-
-			params.delete_if {|key, value| value.nil? } # If token is nil, remove, otherwise, remove card values
-
-			response = make_request(:post, "purchases", params)
-			FatZebra::Models::Response.new(response)
+			warn "[DEPRECATED] Gateway#purchase is deprecated, please use Purchase.create instead" unless options[:silence]
+			Models::Purchase.create(amount, card_data, reference, customer_ip, currency)
 		end
 
 		# Retrieves purchases specified by the options hash
@@ -80,36 +61,10 @@ module FatZebra
 		#                 - offset (defaults to 0) - for pagination
 		#                 - limit (defaults to 10) for pagination
 		# @return [Array<Purchase>] array of purchases
+		# @deprecated Please use Purchase.find(options) instead
 		def purchases(options = {})
-			id = options.delete(:id)
-			options.merge!({:offets => 0, :limit => 10})
-
-			# Format dates for the request
-			options[:from] = options[:from].strftime("%Y%m%dT%H%M") if options[:from]
-			options[:to] = options[:to].strftime("%Y%m%dT%H%M") if options[:to]
-
-
-			if id.nil?
-				response = make_request(:get, "purchases", options)
-				if response["successful"]
-					purchases = []
-					response["response"].each do |purchase|
-						purchases << FatZebra::Models::Purchase.new(purchase)
-					end
-
-					purchases.size == 1 ? purchases.first : purchases
-				else
-					# TODO: This should raise a defined exception
-					raise StandardError, "Unable to query purchases, #{response["errors"].inspect}"
-				end
-			else
-				response = make_request(:get, "purchases/#{id}.json")
-				if response["successful"]
-					FatZebra::Models::Purchase.new(response["response"])
-				else
-					raise StandardError, "Unable to query purchases, #{response["errors"].inspect}"
-				end
-			end
+			warn "[DEPRECATED] Gateway#purchases is deprecated, please use Purchase.find instead" unless options[:silence]
+			Models::Purchase.find(options)
 		end
 
 		# Public: Performs an authorization transaction against the gateway
@@ -137,29 +92,24 @@ module FatZebra
 			raise "Sorry we haven't compelted this functionality yet."
 		end
 
-		# Public: Refunds a transaction
+		# Refunds a transaction
 		#
-		# transaction_id - the ID of the original transaction to be refunded
-		# amount - the amount to be refunded, as an integer
-		# reference - the reference for the refund
+		# @param [String] the ID of the original transaction to be refunded
+		# @param [Integer] the amount to be refunded, as an integer
+		# @param [String] the reference for the refund
 		#
-		# Returns a new FatZebra::Models::Refund object
+		# @return [Refund] refund result object
+		# @deprecated Please use Refund.create or Purchase#refund instead
 		def refund(transaction_id, amount, reference)
-			params = {
-				:transaction_id => transaction_id,
-				:amount => amount,
-				:reference => reference
-			}
-
-			response = make_request(:post, "refunds", params)
-			FatZebra::Models::Response.new(response, :refund)
+			warn "[DEPRECATED] Gateway#refund is deprecated, please use Refund.create or Purchase#refund instead`" unless options[:silence]
+			Models::Refund.create(transaction_id, amount, reference)
 		end
 
-		# Public: Pings the Fat Zebra service
+		# Pings the Fat Zebra service
 		# 
-		# nonce - the data to be echoed back
+		# @param [String] the data to be echoed back
 		#
-		# Returns true if reply is valid, false if times out or otherwise
+		# @return true if reply is valid, false if the request times out, or otherwise
 		def ping(nonce = SecureRandom.hex)	
 			begin
 				response = RestClient.get(build_url("ping") + "?echo=#{nonce}")
@@ -171,52 +121,48 @@ module FatZebra
 			end
 		end
 
-		# Public: Tokenizes a credit card
+		# Tokenizes a credit card
 		# 
-		# card_holder - the credit card holder name
-		# card_number - the card number
-		# expiry - the credit card expiry date (mm/yyyy)
-		# cvv - the card CVV
+		# @param [String] the credit card holder name
+		# @param [String] the card number
+		# @param [String] the credit card expiry date (mm/yyyy)
+		# @param [String] the card CVV
 		#
-		# Returns FatZebra::Models::Response
+		# @return Response
+		# @deprecated Please use Card.create instead
 		def tokenize(card_holder, card_number, expiry, cvv)
-			params = {
-				:card_holder => card_holder,
-				:card_number => card_number,
-				:card_expiry => expiry,
-				:cvv => cvv
-			}
-
-			response = make_request(:post, "credit_cards", params)
-			FatZebra::Models::Response.new(response, :card)
+			warn "[DEPRECATED] Gateway#tokenize is deprecated, please use Card.create instead" unless options[:silence]
+			Models::Card.create(card_holder, card_number, expiry, cvv)
 		end
 
-		# Public: Fetch a previously tokenized card
+		# Public: Performs the HTTP(s) request and returns a response object, handing errors etc
 		#
-		# token - the card token
+		# method - the request method (:post or :get)
+		# resource - the resource for the request
+		# data - a hash of the data for the request
 		#
-		# Returns FatZebra::Models::Response (Card)
-		def tokenized_card(token)
-			response = make_request(:get, "credit_cards/#{token}.json")
-			FatZebra::Models::Response.new(response, :card)
-		end
+		# Returns hash of response data
+		def make_request(method, resource, data = nil)
+			resource = get_resource(resource, method, data)
 
-		def tokenized_cards
-			records = []
-			options = {:offets => 0, :limit => 10}
+			if method == :post
+				data[:test] = options[:test_mode] if options[:test_mode]
+				payload = data.to_json
+			else
+				payload = {}
+			end
 
-			# Format dates for the request
-			options[:from] = options[:from].strftime("%Y%m%dT%H%M") if options[:from]
-			options[:to] = options[:to].strftime("%Y%m%dT%H%M") if options[:to]
+			headers = options[:headers] || {}
 
-			response = make_request(:get, "credit_cards.json", options)
-			if response["successful"]
-				response["response"].each do |record|
-					records << FatZebra::Models::Card.new(record)
+			if method == :get
+				resource.send(method, headers) do |response, request, result, &block|
+					handle_response(response)
 				end
-				records
 			else
-				raise StandardError, "Unable to query credit cards, #{response["errors"].inspect}"
+				# Add in test flag is test mode...
+				resource.send(method, payload, headers) do |response, request, result, &block|
+					handle_response(response)
+				end
 			end
 		end
 
@@ -304,30 +250,6 @@ module FatZebra
 			RestClient::Resource.new(url, opts.merge(ssl_options))
 		end
 
-		# Public: Performs the HTTP(s) request and returns a response object, handing errors etc
-		#
-		# method - the request method (:post or :get)
-		# resource - the resource for the request
-		# data - a hash of the data for the request
-		#
-		# Returns hash of response data
-		def make_request(method, resource, data = nil)
-			resource = get_resource(resource, method, data)
-
-			payload = (method == :post) ? data.to_json : {}
-			headers = options[:headers] || {}
-
-			if method == :get
-				resource.send(method, headers) do |response, request, result, &block|
-					handle_response(response)
-				end
-			else
-				resource.send(method, payload, headers) do |response, request, result, &block|
-					handle_response(response)
-				end
-			end
-		end
-
 		def handle_response(response)
 			case response.code
 			when 201

data/lib/fat_zebra/models/card.rb

@@ -3,9 +3,7 @@ module FatZebra
 		class Card < Base
 			attribute :token, :card_holder, :card_number, :card_expiry, :transaction_count, :raw
 
-      def charge!()
-
-      end
+      def successful; true; end
 
       class << self
         # Tokenizes a credit card

data/lib/fat_zebra/models/purchase.rb

@@ -1,19 +1,112 @@
 module FatZebra
-	module Models
-		class Purchase < Base
-			attribute :id, :amount, :reference, :message, :authorization, :transaction_id, :card_number,
-					  :card_holder, :card_expiry, :authorized, :successful, :card_token, :raw, :currency
-
-      def approved?
-        self.successful
+  module Models
+  	class Purchase < Base
+  		attribute :id, :amount, :reference, :message, :authorization, :transaction_id, :card_number,
+  				  :card_holder, :card_expiry, :authorized, :successful, :card_token, :currency, :raw
+  	
+      # Refunds the current transaction
+      #
+      # @param [Integer] the amount to be refunded
+      # @param [String] the refund reference
+      #
+      # @return Response (Refund) object
+      def refund(amount, reference)
+        Refund.create(self.id, amount, reference)
       end
 
-      def card_type
-        cards = []
-        cards[4] = "VISA"
-        cards[5] = "MasterCard"
-        cards[3] = "AMEX/JCB"
+      class << self
+        # Performs a purchase transaction against the gateway
+        #
+        # @param [Integer] the amount as an integer e.g. (1.00 * 100).to_i
+        # @param [Hash] a hash of the card data (example: {:card_holder => "John Smith", :number => "...", :expiry => "...", :cvv => "123"} or {:token => "abcdefg1"})
+        # @param [String] the card holders name
+        # @param [String] the customers credit card number
+        # @param [Date] the customers card expiry date (as Date or string [mm/yyyy])
+        # @param [String] the credit card verification value (cvv, cav, csc etc)
+        # @param [String] a reference for the purchase
+        # @param [String] the customers IP address (for fraud prevention)
+        # @param [String] currency code ("AUD", "USD", etc)
+        #
+        # @return [Response] response (purchase) object
+        def create(amount, card_data, reference, customer_ip, currency = "AUD")
+          params = {
+            :amount => amount,
+            :card_holder => card_data.delete(:card_holder),
+            :card_number => card_data.delete(:number),
+            :card_expiry => extract_date(card_data.delete(:expiry)),
+            :cvv => card_data.delete(:cvv),
+            :card_token => card_data.delete(:token),
+            :reference => reference,
+            :customer_ip => customer_ip,
+            :currency => currency
+          }
+
+          params.delete_if {|key, value| value.nil? } # If token is nil, remove, otherwise, remove card values
+
+          response = FatZebra.gateway.make_request(:post, "purchases", params)
+          Response.new(response)
+        end
+
+        # Retrieves purchases specified by the options hash
+        #
+        # @param [Hash] options for lookup
+        #               includes: 
+        #                 - id (unique purchase ID)
+        #                 - reference (merchant reference)
+        #           - from (Date)
+        #           - to (Date)
+        #                 - offset (defaults to 0) - for pagination
+        #                 - limit (defaults to 10) for pagination
+        # @return [Array<Purchase>] array of purchases
+        def find(options = {})
+          id = options.delete(:id)
+          options.merge!({:offets => 0, :limit => 10})
+
+          # Format dates for the request
+          options[:from] = options[:from].strftime("%Y%m%dT%H%M") if options[:from]
+          options[:to] = options[:to].strftime("%Y%m%dT%H%M") if options[:to]
+
+
+          if id.nil?
+            response = FatZebra.gateway.make_request(:get, "purchases", options)
+            if response["successful"]
+              purchases = []
+              response["response"].each do |purchase|
+                purchases << Purchase.new(purchase)
+              end
+
+              purchases.size == 1 ? purchases.first : purchases
+            else
+              # TODO: This should raise a defined exception
+              raise StandardError, "Unable to query purchases, #{response["errors"].inspect}"
+            end
+          else
+            response = FatZebra.gateway.make_request(:get, "purchases/#{id}.json")
+            if response["successful"]
+              Purchase.new(response["response"])
+            else
+              raise StandardError, "Unable to query purchases, #{response["errors"].inspect}"
+            end
+          end
+        end
+
+        private
+        # Private: Extracts the date value from a Date/DateTime value
+        #
+        # value - the string or date value to extract the value from
+        #
+        # Returns date string as MM/YYYY
+        def extract_date(value)
+          return nil if value.nil?
+
+          if value.is_a?(String)
+            return value
+          elsif value.respond_to?(:strftime)
+            return value.strftime("%m/%Y")
+          end
+        end
+
       end
-		end
-	end
+  	end
+  end
 end

data/lib/fat_zebra/models/refund.rb

@@ -3,14 +3,40 @@ module FatZebra
 		class Refund < Base
 			attribute :amount, :reference, :refunded, :id, :message, :transaction_id, :original_transaction_id, :raw
 
+			# Returns the original transaction for this refund
+			#
+			# @return Purchase
 			def original_transaction
 				@original_transaction ||= Purchase.find(self.original_transaction_id)
 			end
 
+			# Indicates if the refund was successful or not
+			#
+			# @return Boolean
 			def successful
 				self.refunded == "Approved"
 			end
 			alias successful? successful
+
+			class << self
+				# Refunds a transaction
+				#
+				# @param [String] the ID of the original transaction to be refunded
+				# @param [Integer] the amount to be refunded, as an integer
+				# @param [String] the reference for the refund
+				#
+				# @return [Refund] refund result object
+				def create(transaction_id, amount, reference)
+					params = {
+						:transaction_id => transaction_id,
+						:amount => amount,
+						:reference => reference
+					}
+
+					response = FatZebra.gateway.make_request(:post, "refunds", params)
+					Response.new(response, :refund)
+				end
+			end
 		end
 	end
 end

data/lib/fat_zebra/version.rb

@@ -1,3 +1,3 @@
 module FatZebra
-  VERSION = "1.1.3"
+  VERSION = "1.1.4"
 end

data/lib/fat_zebra.rb

@@ -1,6 +1,7 @@
 require 'securerandom'
 require 'json'
 require 'rest_client'
+require 'fat_zebra/config'
 require 'fat_zebra/errors'
 require "fat_zebra/version"
 require 'fat_zebra/constants'
@@ -9,4 +10,43 @@ require 'fat_zebra/models/base'
 require 'fat_zebra/models/purchase'
 require 'fat_zebra/models/refund'
 require 'fat_zebra/models/card'
-require 'fat_zebra/models/response'
+require 'fat_zebra/models/response'
+
+module FatZebra
+  extend self
+  extend Forwardable
+
+	attr_accessor :config
+  attr_accessor :_gateway
+
+  # Configure the Fat Zebra gateway
+  def configure(auth = nil, &block)
+		raise ArgumentError, "missing authentication parameters or block" unless auth || block_given?
+
+  	if !auth
+      self.config = Config.new
+      if (block.arity > 0)
+        block.call(self.config)
+      else
+        self.config.instance_eval(&block)
+      end
+    else
+      self.config = Config.from_hash(auth)
+    end
+
+    self.config.validate!
+
+    self.configure_gateway
+
+    self.config
+	end
+
+  def configure_gateway
+    self._gateway = Gateway.configure(self.config)
+  end
+
+  def gateway
+    raise GatewayError.new("Please configure the Gateway before use. See FatZebra.configure { }") if self.config.nil?
+    self._gateway
+  end
+end	

data/spec/config_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe FatZebra::Config do
+  it "should configure with a block" do
+    FatZebra.configure do
+      username "TEST"
+      token "TEST"
+      sandbox true
+    end
+
+    FatZebra.config.username.should == "TEST"
+    FatZebra.config.token.should == "TEST"
+    FatZebra.config.sandbox.should be_true
+  end
+
+  it "should configure from a hash" do
+    config = FatZebra.configure(:username => "TEST", :token => "TEST", :sandbox => true)
+    config.username.should == 'TEST'
+  end
+
+  it "should prepare a new gateway when configured" do
+    FatZebra.configure do
+      username "TEST"
+      token "TEST"
+      test_mode true
+      sandbox true
+      options :headers => {"A" => "B"}
+    end
+
+    FatZebra.gateway.should_not be_nil
+  end
+
+  it "should raise an error when trying to access the gateway before it is configured" do
+    FatZebra.config = nil
+    lambda { FatZebra.gateway }.should raise_exception(FatZebra::GatewayError)
+  end
+end	

data/spec/gateway_spec.rb

@@ -8,7 +8,15 @@ describe FatZebra::Gateway do
 	before :each do
 		# Setup the gateway for testing
 		server = TEST_LOCAL == true ? "fatapi.dev" : "gateway.sandbox.fatzebra.com.au"
-		@gw = FatZebra::Gateway.new(TEST_USER, TEST_TOKEN, server, {:secure => !TEST_LOCAL})
+		FatZebra.configure do
+			username TEST_USER
+			token TEST_TOKEN
+			sandbox true
+			test_mode true
+			gateway server
+			options :secure => !TEST_LOCAL, :silence => true # Silence keeps the warnings quiet for testing (deprecation warnings)
+		end
+		@gw = FatZebra.gateway
 	end
 
 	it "should require username and token are provided" do
@@ -24,22 +32,22 @@ describe FatZebra::Gateway do
 	end
 
 	it "should perform a purchase" do
-		result = @gw.purchase(10000, {:card_holder => "Matthew Savage", :card_number => "5555555555554444", :card_expiry => "05/2013", :cvv => 123}, "TEST#{rand}", "1.2.3.4")
+		result = FatZebra::Models::Purchase.create(10000, {:card_holder => "Matthew Savage", :number => "5555555555554444", :expiry => "05/2013", :cvv => 123}, "TEST#{rand}", "1.2.3.4")
 		result.should be_successful
 		result.errors.should be_empty
 	end
 
 	it "should fetch a purchase" do
-		result = @gw.purchase(10000, {:card_holder => "Matthew Savage", :card_number => "5555555555554444", :card_expiry => "05/2013", :cvv => 123}, "TES#{rand}T", "1.2.3.4")
-		purchase = @gw.purchases(:id => result.purchase.id)
+		result = FatZebra::Models::Purchase.create(10000, {:card_holder => "Matthew Savage", :number => "5555555555554444", :expiry => "05/2013", :cvv => 123}, "TES#{rand}T", "1.2.3.4")
+		purchase = FatZebra::Models::Purchase.find(:id => result.purchase.id)
 		purchase.id.should == result.purchase.id
 	end
 
 	it "should fetch a purchase via reference" do
 		ref = "TES#{rand}T"
-		result = @gw.purchase(10000, {:card_holder => "Matthew Savage", :card_number => "5555555555554444", :card_expiry => "05/2013", :cvv => 123}, ref, "1.2.3.4")
+		result = FatZebra::Models::Purchase.create(10000, {:card_holder => "Matthew Savage", :number => "5555555555554444", :expiry => "05/2013", :cvv => 123}, ref, "1.2.3.4")
 
-		purchases = @gw.purchases(:reference => ref)
+		purchases = FatZebra::Models::Purchase.find(:reference => ref)
 		purchases.id.should == result.purchase.id
 	end
 
@@ -56,16 +64,16 @@ describe FatZebra::Gateway do
 	it "should fetch purchases with a from date" do
 		start = Time.now
 		5.times do |i|
-			@gw.purchase(10000, {:card_holder => "Matthew Savage", :card_number => "5555555555554444", :card_expiry => "05/2013", :cvv => 123}, "TEST#{rand(1000)}-#{i}", "1.2.3.4")
+			FatZebra::Models::Purchase.create(10000, {:card_holder => "Matthew Savage", :number => "5555555555554444", :expiry => "05/2013", :cvv => 123}, "TEST#{rand(1000)}-#{i}", "1.2.3.4")
 		end
 
-		purchases = @gw.purchases(:from => start)
+		purchases = FatZebra::Models::Purchase.find(:from => start)
 		purchases.count.should >= 5
 	end
 
 	it "should refund a transaction" do
-		purchase = @gw.purchase(10000, {:card_holder => "Matthew Savage", :card_number => "5555555555554444", :card_expiry => "05/2013", :cvv => 123}, "TES#{rand}T", "1.2.3.4")
-		result = @gw.refund(purchase.result.id, 100, "REFUND-#{purchase.result.id}")
+		purchase = FatZebra::Models::Purchase.create(10000, {:card_holder => "Matthew Savage", :number => "5555555555554444", :expiry => "05/2013", :cvv => 123}, "TES#{rand}T", "1.2.3.4")
+		result = FatZebra::Models::Refund.create(purchase.result.id, 100, "REFUND-#{purchase.result.id}")
 
 		result.should be_successful
 		result.result.successful.should be_true
@@ -77,26 +85,33 @@ describe FatZebra::Gateway do
 		response.result.token.should_not be_nil
 	end
 
-	it "should fetch a tokenized card" do
-		token = @gw.tokenize("M Smith", "5123456789012346", "05/2013", "123").result.token
-		card_response = @gw.tokenized_card(token)
+	# it "should fetch a tokenized card" do
+	# 	token = @gw.tokenize("M Smith", "5123456789012346", "05/2013", "123").result.token
+	# 	card_response = @gw.tokenized_card(token)
 
-		card_response.should be_successful
-		card_response.result.token.should == token
-		card_response.result.card_number.should == "512345XXXXXX2346"
-	end
+	# 	card_response.should be_successful
+	# 	card_response.result.token.should == token
+	# 	card_response.result.card_number.should == "512345XXXXXX2346"
+	# end
 
-	it "should fetch all cards" do
-		cards = @gw.tokenized_cards
+	# it "should fetch all cards" do
+	# 	cards = @gw.tokenized_cards
 
-		cards.first.should be_instance_of(FatZebra::Models::Card)
-	end
+	# 	cards.first.should be_instance_of(FatZebra::Models::Card)
+	# end
 
 	it "should perform a purchase with a tokenized card" do
 		token = @gw.tokenize("M Smith", "5123456789012346", "05/2013", "123").result.token
-		purchase = @gw.purchase(10000, {:card_token => token}, "TEST#{rand}}", "127.0.0.1")
+		purchase = @gw.purchase(10000, {:token => token}, "TEST#{rand}}", "127.0.0.1")
 
 		purchase.should be_successful
 		purchase.result.successful.should be_true
 	end
+
+	it "should transact in USD" do
+		result = FatZebra::Models::Purchase.create(10000, {:card_holder => "Matthew Savage", :number => "5555555555554444", :expiry => "05/2013", :cvv => 123}, "TEST#{rand}", "1.2.3.4", 'USD')
+		result.should be_successful, result.raw
+		result.errors.should be_empty
+		result.result.currency.should == 'USD'
+	end
 end

data/spec/models/purchase_spec.rb

@@ -34,4 +34,22 @@ describe FatZebra::Models::Purchase do
 		r = FatZebra::Models::Purchase.new(response)
 		r.card_token.should == "a1bhj98j"
 	end
+
+	it "should return the currency code" do
+		response = {
+				"authorization" => "55355",
+        		"id" => "001-P-12345AA",
+        		"card_number" => "512345XXXXXX2346",
+		        "card_holder" => "John Smith",
+		        "card_expiry" => "10/2011",
+		        "card_token"  => "a1bhj98j",
+		        "amount" => 349,
+		        "authorized" => true,
+		        "reference" => "ABC123",
+		        "message" => "Approved",
+		        "currency" => "USD"
+			}
+		r = FatZebra::Models::Purchase.new(response)
+		r.currency.should == "USD"
+	end
 end

metadata

@@ -1,93 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: fat_zebra
 version: !ruby/object:Gem::Version
-  version: 1.1.3
-  prerelease: 
+  version: 1.1.4
 platform: ruby
 authors:
 - Matthew Savage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-18 00:00:00.000000000 Z
+date: 2013-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70319775786820 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70319775786820
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70319775828120 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70319775828120
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70319775827160 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70319775827160
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard-tomdoc
-  requirement: &70319775826140 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70319775826140
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ZenTest
-  requirement: &70319775824660 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70319775824660
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &70319775824080 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70319775824080
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70319775823500 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70319775823500
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Provides integration with the Fat Zebra internet payment gateway (www.fatzebra.com.au),
   including purchase, refund, auth, capture and recurring billing functionality.
 email:
@@ -104,6 +124,7 @@ files:
 - README.markdown
 - Rakefile
 - lib/fat_zebra.rb
+- lib/fat_zebra/config.rb
 - lib/fat_zebra/constants.rb
 - lib/fat_zebra/errors.rb
 - lib/fat_zebra/gateway.rb
@@ -113,6 +134,7 @@ files:
 - lib/fat_zebra/models/refund.rb
 - lib/fat_zebra/models/response.rb
 - lib/fat_zebra/version.rb
+- spec/config_spec.rb
 - spec/gateway_spec.rb
 - spec/models/purchase_spec.rb
 - spec/models/refund_spec.rb
@@ -121,35 +143,29 @@ files:
 - vendor/cacert.pem
 homepage: ''
 licenses: []
+metadata: {}
 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: -2567456050335982654
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2567456050335982654
 requirements: []
 rubyforge_project: fat_zebra
-rubygems_version: 1.8.17
+rubygems_version: 2.0.7
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Fat Zebra payments gem - integrate your ruby app with Fat Zebra
 test_files:
+- spec/config_spec.rb
 - spec/gateway_spec.rb
 - spec/models/purchase_spec.rb
 - spec/models/refund_spec.rb