authorize_cim 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source :gemcutter
+  gem 'crack'
+  gem 'builder'
+  
+group :test, :development do
+  gem 'rspec'
+  gem 'webmock'
+  gem 'jeweler'
+
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.2)
+    builder (2.1.2)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+    webmock (1.5.0)
+      addressable (>= 2.2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  builder
+  crack
+  jeweler
+  rspec
+  webmock

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake'
+require 'jeweler'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+Jeweler::Tasks.new do |gem|
+  
+  gem.name        = "authorize_cim"
+  gem.summary     = %Q{Ruby Gem for integrating Authorize.net Customer Information Manager (CIM)}
+  gem.description = %Q{Ruby Gem for integrating Authorize.net Customer Information Manager (CIM)}
+  gem.email       = "tylerflint@gmail.com"
+  gem.homepage    = "http://github.com/tylerflint/authorize_cim"
+  gem.authors     = ["Tyler Flint", "Lyon Hill"]
+  gem.files       = Dir["{lib}/**/*", "{spec}/**/*","[A-Z]*"]
+  
+  gem.add_dependency "crack"
+  gem.add_dependency "builder"
+  
+  Jeweler::GemcutterTasks.new
+end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ['--colour --format progress']
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/authorize_cim.rb

@@ -0,0 +1,687 @@
+require 'crack'
+require 'builder'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+class InvalidOrMissingCredentials < Exception 
+end
+
+class AuthorizeCim
+  
+  def initialize(attrs)
+    
+    raise InvalidOrMissingCredentials unless attrs[:key] && attrs[:login]
+    
+    @key   = attrs[:key]
+    @login = attrs[:login]
+    
+    @endpoint = case attrs[:endpoint]
+      when :live then 'https://api.authorize.net/xml/v1/request.api'
+      when :test then 'https://apitest.authorize.net/xml/v1/request.api'
+      else 'https://api.authorize.net/xml/v1/request.api'
+    end
+    @uri = URI.parse(@endpoint)
+    
+      
+  end
+
+  # Create a new customer profile
+  #
+  #
+  # params:
+  #   Necessary:
+  #     :merchant_id => '<some id>'  (up to 20 characters)
+  #    or
+  #     :description => '<some discription>' (up to 255 characters)
+  #    or
+  #     :email => '<emailaddress>' (up to 255 characters)
+  #  
+  # return: 
+  #  xml return converted to hash containing the return_code and customer_profile_id
+  #     note: a return code of I00001 is good, anything else is bad
+  #
+  def create_customer_profile(input)
+  	data = build_request('createCustomerProfileRequest') do |xml|
+      xml.tag!('profile') do
+        xml.merchantCustomerId input[:merchant_id] if input[:merchant_id]
+        xml.description input[:description] if input[:description]
+        xml.email input[:email] if input[:email]
+      end
+    end
+    parse send(data)
+  end
+  	
+  # Create a new customer payment profile for an existing customer profile. 
+  # You can create up to 10 payment profiles for each customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id               => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id  => <id of customer> (numeric (necessary))
+  #     :payment_profile      => {
+  #       :bill_to => {  (optional)
+  #         :first_name     => '<billing first name>' (up to 50 characters (optional))
+  #         :last_name      => '<billing last name>' (up to 50 characters (optional))
+  #         :company        => '<company name>' (up to 50 characters (optional))
+  #         :address        => '<address>' (up to 60 characters (optional))
+  #         :city           => '<city>' (up to 40 characters (optional))
+  #         :state          => '<state>' (valid 2 character state code (optional))
+  #         :zip            => '<zip code>' (up to 20 characters (optional))
+  #         :country        => '<country>' (up to 60 characters (optional))
+  #         :phone_number   => '<phone number>' (up to 25 digits (optional))
+  #         :fax_number     => '<fax number>' (up to 25 digits (optional))
+  #       }
+  #       :payment => { (NECESSARY > must include either bank info or credit card info)
+  #         :credit_card => { (necessary if there is no bank_account in payment hash)
+  #           :card_number      => <number> (13 to 16 digits (necessary))
+  #           :expiration_date  => '<YYYY-MM>' (has to be 4 digit year, dash line, then 2 digit month (necessary))
+  #           :card_code        => <number> (3 or 4 digit number on back of card (optional))
+  #         }
+  #         :bank_account => { (necessary if there is no credit_card in payment hash)
+  #           :account_type     => '<type of account>' (must be "checking", "savings", or "businessChecking" (necessary))
+  #           :routing_number   => <number> (9 digit bank routing number (necessary))
+  #           :account_number   => <number> (5 to 17 digit number (necessary))
+  #           :name_on_account  => '<name>' (up to 22 characters (necessary))
+  #           :echeck_type      => '<type>' (needs to be 'CCD', 'PPD', 'TEL', or 'WEB' (optional))
+  #           :bank_name        => '<bank name>' (up to 50 characters (optional))
+  #         }
+  #         
+  #       }
+  #     }
+  #     :validation_mode => '<mode>' (needs to be 'none', 'testMode', 'liveMode', or 'oldLiveMode' (necessary))
+  # 
+  # returns:
+  #   xml converted to hash table for easy access
+  # 
+  def create_customer_payment_profile(input)
+  	data = build_request('createCustomerPaymentProfileRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.tag!('paymentProfile') do
+        if input[:payment_profile][:bill_to]
+          xml.tag!('billTo') do
+            xml.firstName input[:payment_profile][:bill_to][:first_name] if input[:payment_profile][:bill_to][:first_name]
+            xml.lastName input[:payment_profile][:bill_to][:last_name] if input[:payment_profile][:bill_to][:last_name]
+            xml.company input[:payment_profile][:bill_to][:company] if input[:payment_profile][:bill_to][:company]
+            xml.address input[:payment_profile][:bill_to][:address] if input[:payment_profile][:bill_to][:address]
+            xml.city input[:payment_profile][:bill_to][:city] if input[:payment_profile][:bill_to][:city]
+            xml.state input[:payment_profile][:bill_to][:state] if input[:payment_profile][:bill_to][:state]
+            xml.zip input[:payment_profile][:bill_to][:zip] if input[:payment_profile][:bill_to][:zip]
+            xml.country input[:payment_profile][:bill_to][:country] if input[:payment_profile][:bill_to][:country]
+            xml.phoneNumber input[:payment_profile][:bill_to][:phone_number] if input[:payment_profile][:bill_to][:phone_number]
+            xml.faxNumber input[:payment_profile][:bill_to][:fax_number] if input[:payment_profile][:bill_to][:fax_number]
+          end
+        end
+        xml.tag!('payment') do
+          if input[:payment_profile][:payment][:credit_card]
+            xml.tag!('creditCard') do
+              xml.cardNumber input[:payment_profile][:payment][:credit_card][:card_number] if input[:payment_profile][:payment][:credit_card][:card_number]
+              xml.expirationDate input[:payment_profile][:payment][:credit_card][:expiration_date] if input[:payment_profile][:payment][:credit_card][:expiration_date]
+              xml.cardCode input[:payment_profile][:payment][:credit_card][:card_code] if input[:payment_profile][:payment][:credit_card][:card_code]
+            end
+          elsif input[:payment_profile][:payment][:bank_account]
+            xml.tag!('bankAccount') do
+              xml.accountType input[:payment_profile][:payment][:bank_account][:account_type] if input[:payment_profile][:payment][:bank_account][:account_type]
+              xml.routingNumber input[:payment_profile][:payment][:bank_account][:routing_number] if input[:payment_profile][:payment][:bank_account][:routing_number]
+              xml.accountNumber input[:payment_profile][:payment][:bank_account][:account_number] if input[:payment_profile][:payment][:bank_account][:account_number]
+              xml.nameOnAccount input[:payment_profile][:payment][:bank_account][:name_on_account] if input[:payment_profile][:payment][:bank_account][:name_on_account]
+              xml.echeckType input[:payment_profile][:payment][:bank_account][:echeck_type] if input[:payment_profile][:payment][:bank_account][:echeck_type]
+              xml.bankName input[:payment_profile][:payment][:bank_account][:bank_name] if input[:payment_profile][:payment][:bank_account][:bank_name]
+            end
+          end
+        end
+        xml.validationMode input[:payment_profile][:validation_mode] if input[:payment_profile][:validation_mode]
+      end
+    end
+    parse send(data)
+  end
+  
+  # Create a new customer shipping address for an existing customer profile. 
+  # You can create up to 100 customer shipping addresses for each customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id               => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id  => <id of customer> (numeric (necessary))
+  #     :address => {  (a hash containing address information(necessary)
+  #       :first_name     => '<billing first name>' (up to 50 characters (optional))
+  #       :last_name      => '<billing last name>' (up to 50 characters (optional))
+  #       :company        => '<company name>' (up to 50 characters (optional))
+  #       :address        => '<address>' (up to 60 characters (optional))
+  #       :city           => '<city>' (up to 40 characters (optional))
+  #       :state          => '<state>' (valid 2 character state code (optional))
+  #       :zip            => '<zip code>' (up to 20 characters (optional))
+  #       :country        => '<country>' (up to 60 characters (optional))
+  #       :phone_number   => '<phone number>' (up to 25 digits (optional))
+  #       :fax_number     => '<fax number>' (up to 25 digits (optional))
+  #     }
+  #
+  # returns:
+  #   xml converted to hash table for easy access
+  def create_customer_shipping_address(input)
+  	data = build_request('createCustomerShippingAddressRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.tag!('address') do
+        xml.firstName input[:address][:first_name] if input[:address][:first_name]
+        xml.lastName input[:address][:last_name] if input[:address][:last_name]
+        xml.company input[:address][:company] if input[:address][:company]
+        xml.address input[:address][:address] if input[:address][:address]
+        xml.city input[:address][:city] if input[:address][:city]
+        xml.state input[:address][:state] if input[:address][:state]
+        xml.zip input[:address][:zip] if input[:address][:zip]
+        xml.country input[:address][:country] if input[:address][:country]
+        xml.phoneNumber input[:address][:phone_number] if input[:address][:phone_number]
+        xml.faxNumber input[:address][:fax_number] if input[:address][:fax_number]
+      end
+    end
+    parse send(data)
+  end
+  
+  # Create a new payment transaction from an existing customer profile.
+  # can handle all transactions except Void transaction.
+  #
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id      => '<id>' (up to 20 digits (optional))
+  #     :transaction => { (REQUIRED)                                                          TODO \/ I dont know the rest...
+  #     :trans_type => '<transType>' (must be profileTransAuthCapture, profileTransAuthOnly, profileTransPriorAuthCapture, profileTransCaptureOnly, profileTransRefund, profileTransVoid' (REQUIRED))
+  #       :transaction_type => { 
+  #         :amount => '<amount>' (total amound of transaction ie. 1234.23 (allow a maximum of 4 digits after decimal point)(REQUIRED))
+  #         :tax    => { (optional)
+  #           :amount       => '<amount>' (total tax amount ie 65.34 (allow a maximum of 4 digits after decimal point))
+  #           :name         => '<name>' (name of tax ie federal, state etc.)
+  #           :description  => '<description>' (up to 255 characters)
+  #         }
+  #         :shipping => { (optional)
+  #           :amount       => '<amount>' (total tax amount ie 65.34 (allow a maximum of 4 digits after decimal point))
+  #           :name         => '<name>' (name of tax ie federal, state etc.)
+  #           :description  => '<description>' (up to 255 characters)
+  #         }  
+  #         :duty => { (optional)
+  #           :amount       => '<amount>' (total tax amount ie 65.34 (allow a maximum of 4 digits after decimal point))
+  #           :name         => '<name>' (name of tax ie federal, state etc.)
+  #           :description  => '<description>' (up to 255 characters)
+  #         }  
+  #         :line_items => [ (an array of items on transaction, each array item is a hash containign \/ (optional))
+  #           :item_id => '<id>' (up to 31 characters)
+  #           :name => '<name>' (up to 31 characters)
+  #           :description => '<description>' (up to 255 characters)
+  #           :quantity => <number> (up to 4 digits(and 2 decimal places... but how could you have .34 things you sold...))
+  #           :unit_price => <number> (up to 4 digits(and 2 decimal places))
+  #           :taxable => <boolean> (must be "true" or "false")
+  #         ]
+  #         :customer_profile_id          => <id number> (profile Identification number given by authorize.net (required))
+  #         :customer_payment_profile_id  => <payment id number> (profile payment ID given by authorize.net (required))
+  #         :customer_Shipping_address_id => <address id> (address ID given by authorize.net (optional))
+  #         :trans_id                     => <number> (original transactions transId (CONDITIONAL - required for "Prior Authorization and Capture Transactions"))
+  #         :credit_card_number_masked    => <numb> (last 4 digits of credit card (CONDITIONAL - require for "Refund Transactions"))
+  #         :order => { (optional)
+  #           :invoice_number => '<invoice number>' (up to 20 characters)
+  #           :description    => '<description>' (up to 255 characters)
+  #           :purchase_order_number => '<order number>' (up to 25 characters)
+  #         }
+  #         :tax_exempt         => <BOOLEAN> (must be "TRUE" or "FALSE"  (optional))
+  #         :recurring_billing  => <BOOLEAN> (must be "TRUE" or "FALSE"  (optional))
+  #         :card_code          => <num> (3 to 4 digits (Required IF merchent would like to use CCV)(optional))
+  #         :split_tender_id    => <number> (up to 6 digits (conditional)(optional))
+  #         :approval_code      => <code> (6 character authorication code of an original transaction (conditional - caption only transactions))
+  #       }
+  #     }
+  #     :extra_options => <string> (information listed in name/value pair... things like customer ip address... etc(optional))
+  # 
+  # Returns:
+  #  XML converted to hash for easy reading
+  # 
+  def create_customer_profile_transaction(input)
+  	data = build_request('createCustomerProfileTransactionRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.tag!('transaction') do
+        xml.tag!(input[:transaction][:trans_type]) do
+          xml.amount input[:transaction][:transaction_type][:amount] if input[:transaction][:transaction_type][:amount]
+          if input[:transaction][:transaction_type][:tax]
+            xml.tag!('tax') do
+              xml.amount input[:transaction][:transaction_type][:tax][:amount] if input[:transaction][:transaction_type][:tax][:amount]
+              xml.name input[:transaction][:transaction_type][:tax][:name] if input[:transaction][:transaction_type][:tax][:name]
+              xml.description input[:transaction][:transaction_type][:tax][:description] if input[:transaction][:transaction_type][:tax][:description]
+            end
+          end
+          if input[:transaction][:transaction_type][:shipping]
+            xml.tag!('shipping') do
+              xml.amount input[:transaction][:transaction_type][:shipping][:amount] if input[:transaction][:transaction_type][:shipping][:amount]
+              xml.name input[:transaction][:transaction_type][:shipping][:name] if input[:transaction][:transaction_type][:shipping][:name]
+              xml.description input[:transaction][:transaction_type][:shipping][:description] if input[:transaction][:transaction_type][:shipping][:description]
+            end
+          end
+          if input[:transaction][:transaction_type][:duty]
+            xml.tag!('duty') do
+              xml.amount input[:transaction][:transaction_type][:duty][:amount] if input[:transaction][:transaction_type][:duty][:amount]
+              xml.name input[:transaction][:transaction_type][:duty][:name] if input[:transaction][:transaction_type][:duty][:name]
+              xml.description input[:transaction][:transaction_type][:duty][:description] if input[:transaction][:transaction_type][:duty][:description]
+            end
+          end
+          if input[:transaction][:transaction_type][:line_item]
+            xml.tag!('lineItems')  do
+              arr = input[:transaction][:transaction_type][:line_item]
+              arr.each { |item|
+                xml.itemId item[:item_id]
+                xml.name item[:name]
+                xml.description item[:description]
+                xml.quantity item[:quantity]
+                xml.unitPrice item[:unit_price]
+                xml.taxable item[:taxable]
+              }
+            end
+          end
+          xml.customerProfileId input[:transaction][:transaction_type][:customer_profile_id] if input[:transaction][:transaction_type][:customer_profile_id]
+          xml.customerPaymentProfileId input[:transaction][:transaction_type][:customer_payment_profile_id] if input[:transaction][:transaction_type][:customer_payment_profile_id]
+          xml.customerShippingAddressId input[:transaction][:transaction_type][:customer_shipping_address_id] if input[:transaction][:transaction_type][:customer_shipping_address_id]
+          xml.transId input[:transaction][:transaction_type][:trans_id] if input[:transaction][:transaction_type][:trans_id]
+          xml.creditCardNumberMasked input[:transaction][:transaction_type][:credit_card_number_masked] if input[:transaction][:transaction_type][:credit_card_number_masked]
+          if input[:transaction][:transaction_type][:order]
+            xml.tag!('order') do
+              xml.invoiceNumber input[:transaction][:transaction_type][:order][:invoice_number] if input[:transaction][:transaction_type][:order][:invoice_number]
+              xml.description input[:transaction][:transaction_type][:order][:description] if input[:transaction][:transaction_type][:order][:description]
+              xml.purchaseOrderNumber input[:transaction][:transaction_type][:order][:purchase_order_number] if input[:transaction][:transaction_type][:order][:purchase_order_number]
+            end
+          end
+          xml.taxExempt input[:transaction][:transaction_type][:tax_exempt] if input[:transaction][:transaction_type][:tax_exempt]
+          xml.recurringBilling input[:transaction][:transaction_type][:recurring_billing] if input[:transaction][:transaction_type][:recurring_billing]
+          xml.cardCode input[:transaction][:transaction_type][:card_code] if input[:transaction][:transaction_type][:card_code]
+          xml.splitTenderId input[:transaction][:transaction_type][:split_tender_id] if input[:transaction][:transaction_type][:split_tender_id]
+          xml.approvalCode input[:transaction][:transaction_type][:approval_code] if input[:transaction][:transaction_type][:approval_code]
+        end
+      end
+      xml.extraOptions input[:extra_options] if input[:extra_options]
+    end    
+    parse send(data)
+  end
+     
+  # Void a transaction.
+  # 
+  # params:
+  #     A hash containing all necessary fileds
+  #   all possible params:
+  #         :customer_profile_id          => <id number> (profile Identification number given by authorize.net (optional))
+  #         :customer_payment_profile_id  => <payment id number> (profile payment ID given by authorize.net (optional))
+  #         :customer_Shipping_address_id => <address id> (address ID given by authorize.net (optional))
+  #         :trans_id                     => <number> (original transactions transId (Required))
+  #
+  def void_transaction(input)
+    data = build_request('deleteCustomerProfileRequest') do |xml|
+      xml.transaction do
+        xml.profileTransVoid do
+      	  xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+          xml.customerPaymentProfileId input[:customer_payment_profile_id] if input[:customer_payment_profile_id]
+          xml.customerShippingAddressId input[:customer_shipping_address_id] if input[:customer_shipping_address_id]
+          xml.transId input[:trans_id] if input[:trans_id]
+        end
+      end
+    end
+    
+  end
+
+     
+
+  # Delete an existing customer profile along with all associated customer payment profiles and customer shipping addresses.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id               => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id  => <id of customer> (numeric (necessary))
+  #
+  # returns:
+  #     xml converted to hash for easy access
+  def delete_customer_profile(input)
+  	data = build_request('deleteCustomerProfileRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+    end    
+    parse send(data)
+  end
+  
+  # Delete a customer payment profile from an existing customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id                       => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id          => <id of customer> (numeric (necessary))
+  #     :customer_payment_profile_id  => <payment id> (numeric (necessary))
+  # returns:
+  #     xml converted to hash for easy access
+  def delete_customer_payment_profile(input)
+  	data = build_request('deleteCustomerPaymentProfileRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.customerPaymentProfileId input[:customer_payment_profile_id] if input[:customer_payment_profile_id]
+    end    
+    parse send(data)
+  end
+    
+  # Delete a customer shipping address from an existing customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id                       => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id          => <id of customer> (numeric (necessary))
+  #     :customer_address_id  => <shipping id> (numeric (necessary))
+  #
+  # returns:
+  #     xml converted to hash for easy access
+  def delete_customer_shipping_address(input)
+  	data = build_request('deleteCustomerShippingAddressRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.customerAddressId input[:customer_address_id] if input[:customer_address_id]
+    end    
+  	parse send(data)
+    
+  end
+  
+  # Retrieve all customer profile IDs you have previously created.
+  # returns:
+  #     xml converted to hash for easy access
+  def get_customer_profile_ids
+  	data = build_request('getCustomerProfileIdsRequest') {}
+  	parse send(data)
+  end
+  
+  # Retrieve an existing customer profile along with all the associated customer payment profiles and customer shipping addresses.
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :customer_profile_id          => <id of customer> (numeric (necessary))
+  def get_customer_profile(input)
+  	data = build_request('getCustomerProfileRequest') do |xml|
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+    end
+    parse send(data)
+  	
+  end
+  
+  # Retrieve a customer payment profile for an existing customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :customer_profile_id          => <id of customer> (numeric (necessary))
+  #     :customer_payment_profile_id  => <payment id> (numeric (necessary))
+  #
+  # returns:
+  #     xml converted to hash for easy access
+  def get_customer_payment_profile(input)
+  	data = build_request('getCustomerPaymentProfileRequest') do |xml|
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.customerPaymentProfileId input[:customer_payment_profile_id] if input[:customer_payment_profile_id]
+    end    
+    parse send(data)
+  	
+  end
+  
+  # Retrieve a customer shipping address for an existing customer profile.
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id                       => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id          => <id of customer> (numeric (necessary))
+  #     :customer_address_id  => <shipping id> (numeric (necessary))
+  #
+  # returns:
+  #     xml converted to hash for easy access
+  def get_customer_shipping_address(input)
+  	data = build_request('getCustomerShippingAddressRequest') do |xml|
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.customerAddressId input[:customer_address_id] if input[:customer_address_id]
+    end    
+    parse send(data)
+  end
+  
+  # Update an existing customer profile.
+  # params:
+  #   Necessary:
+  #     :customer_profile_id => <id of customer> (numeric (necessary))
+  #  {
+  #     :merchant_id => '<some id>'  (up to 20 characters)
+  #    or
+  #     :description => '<some discription>' (up to 255 characters)
+  #    or
+  #     :email => '<emailaddress>' (up to 255 characters)
+  #  }
+  # return: 
+  #  xml return converted to hash containing the return_code and customer_profile_id
+  #     note: a return code of I00001 is good, anything else is bad
+  #
+  def update_customer_profile(input) 
+  	data = build_request('updateCustomerProfileRequest') do |xml|
+      xml.tag!('profile') do
+        xml.merchantCustomerId input[:merchant_id] if input[:merchant_id]
+        xml.description input[:description] if input[:description]
+        xml.email input[:email] if input[:email]
+        xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      end
+    end    
+    parse send(data)
+  end
+  
+  # Update a customer payment profile for an existing customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id               => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id  => <id of customer> (numeric (necessary))
+  #     :payment_profile      => {
+  #       :bill_to => {  (optional)
+  #         :first_name     => '<billing first name>' (up to 50 characters (optional))
+  #         :last_name      => '<billing last name>' (up to 50 characters (optional))
+  #         :company        => '<company name>' (up to 50 characters (optional))
+  #         :address        => '<address>' (up to 60 characters (optional))
+  #         :city           => '<city>' (up to 40 characters (optional))
+  #         :state          => '<state>' (valid 2 character state code (optional))
+  #         :zip            => '<zip code>' (up to 20 characters (optional))
+  #         :country        => '<country>' (up to 60 characters (optional))
+  #         :phone_number   => '<phone number>' (up to 25 digits (optional))
+  #         :fax_number     => '<fax number>' (up to 25 digits (optional))
+  #       }
+  #       :payment => { (NECESSARY > must include either bank info or credit card info)
+  #         :credit_card => { (necessary if there is no bank_account in payment hash)
+  #           :card_number      => <number> (13 to 16 digits (necessary))
+  #           :expiration_date  => '<YYYY-MM>' (has to be 4 digit year, dash line, then 2 digit month (necessary))
+  #           :card_code        => <number> (3 or 4 digit number on back of card (optional))
+  #         }
+  #         :bank_account => { (necessary if there is no credit_card in payment hash)
+  #           :account_type     => '<type of account>' (must be "checking", "savings", or "businessChecking" (necessary))
+  #           :routing_number   => <number> (9 digit bank routing number (necessary))
+  #           :account_number   => <number> (5 to 17 digit number (necessary))
+  #           :name_on_account  => '<name>' (up to 22 characters (necessary))
+  #           :echeck_type      => '<type>' (needs to be 'CCD', 'PPD', 'TEL', or 'WEB' (optional))
+  #           :bank_name        => '<bank name>' (up to 50 characters (optional))
+  #         }
+  #       }
+  #       
+  #     }
+  #     :customer_payment_profile_id  => <payment id> (numeric (necessary))
+  #     :validation_mode => '<mode>' (needs to be 'none', 'testMode', 'liveMode', or 'oldLiveMode' (necessary))
+  # 
+  # returns:
+  #   xml converted to hash table for easy access
+  # 
+  def update_customer_payment_profile(input)
+  	data = build_request('updateCustomerPaymentProfileRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.tag!('paymentProfile') do
+        if input[:payment_profile][:bill_to]
+          xml.tag!('billTo') do
+            xml.firstName input[:payment_profile][:bill_to][:first_name] if input[:payment_profile][:bill_to][:first_name]
+            xml.lastName input[:payment_profile][:bill_to][:last_name] if input[:payment_profile][:bill_to][:last_name]
+            xml.company input[:payment_profile][:bill_to][:company] if input[:payment_profile][:bill_to][:company]
+            xml.address input[:payment_profile][:bill_to][:address] if input[:payment_profile][:bill_to][:address]
+            xml.city input[:payment_profile][:bill_to][:city] if input[:payment_profile][:bill_to][:city]
+            xml.state input[:payment_profile][:bill_to][:state] if input[:payment_profile][:bill_to][:state]
+            xml.zip input[:payment_profile][:bill_to][:zip] if input[:payment_profile][:bill_to][:zip]
+            xml.country input[:payment_profile][:bill_to][:country] if input[:payment_profile][:bill_to][:country]
+            xml.phoneNumber input[:payment_profile][:bill_to][:phone_number] if input[:payment_profile][:bill_to][:phone_number]
+            xml.faxNumber input[:payment_profile][:bill_to][:fax_number] if input[:payment_profile][:bill_to][:fax_number]
+          end
+        end
+        xml.tag!('payment') do
+          if input[:payment_profile][:payment][:credit_card]
+            xml.tag!('creditCard') do
+              xml.cardNumber input[:payment_profile][:payment][:credit_card][:card_number] if input[:payment_profile][:payment][:credit_card][:card_number]
+              xml.expirationDate input[:payment_profile][:payment][:credit_card][:expiration_date] if input[:payment_profile][:payment][:credit_card][:expiration_date]
+              xml.cardCode input[:payment_profile][:payment][:credit_card][:card_code] if input[:payment_profile][:payment][:credit_card][:card_code]
+            end
+          elsif input[:payment_profile][:payment][:bank_account]
+            xml.tag!('bankAccount') do
+              xml.accountType input[:payment_profile][:payment][:bank_account][:account_type] if input[:payment_profile][:payment][:bank_account][:account_type]
+              xml.routingNumber input[:payment_profile][:payment][:bank_account][:routing_number] if input[:payment_profile][:payment][:bank_account][:routing_number]
+              xml.accountNumber input[:payment_profile][:payment][:bank_account][:account_number] if input[:payment_profile][:payment][:bank_account][:account_number]
+              xml.nameOnAccount input[:payment_profile][:payment][:bank_account][:name_on_account] if input[:payment_profile][:payment][:bank_account][:name_on_account]
+              xml.echeckType input[:payment_profile][:payment][:bank_account][:echeck_type] if input[:payment_profile][:payment][:bank_account][:echeck_type]
+              xml.bankName input[:payment_profile][:payment][:bank_account][:bank_name] if input[:payment_profile][:payment][:bank_account][:bank_name]
+            end
+          end
+        end
+        xml.customerPaymentProfileId input[:customer_payment_profile_id] if input[:customer_payment_profile_id]
+        xml.validationMode input[:payment_profile][:validation_mode] if input[:payment_profile][:validation_mode]
+      end
+    end    
+    parse send(data)
+  end
+  
+  # Update a shipping address for an existing customer profile.
+  # 
+  # params:
+  #     A hash containing all necessary fields
+  #   all possible params:
+  #     :ref_id               => '<id>' (up to 20 digits (optional))
+  #     :customer_profile_id  => <id of customer> (numeric (necessary))
+  #     :address => {  (a hash containing address information(necessary)
+  #       :first_name     => '<billing first name>' (up to 50 characters (optional))
+  #       :last_name      => '<billing last name>' (up to 50 characters (optional))
+  #       :company        => '<company name>' (up to 50 characters (optional))
+  #       :address        => '<address>' (up to 60 characters (optional))
+  #       :city           => '<city>' (up to 40 characters (optional))
+  #       :state          => '<state>' (valid 2 character state code (optional))
+  #       :zip            => '<zip code>' (up to 20 characters (optional))
+  #       :country        => '<country>' (up to 60 characters (optional))
+  #       :phone_number   => '<phone number>' (up to 25 digits (optional))
+  #       :fax_number     => '<fax number>' (up to 25 digits (optional))
+  #       :customer_address_id  => <shipping id> (numeric (necessary))
+  #     }
+  #
+  # returns:
+  #   xml converted to hash table for easy access
+  def update_customer_shipping_address(input)
+  	data = build_request('updateCustomerShippingAddressRequest') do |xml|
+  	  xml.refId input[:ref_id] if input[:ref_id]
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.tag!('address') do
+        xml.firstName input[:address][:first_name] if input[:address][:first_name]
+        xml.lastName input[:address][:last_name] if input[:address][:last_name]
+        xml.company input[:address][:company] if input[:address][:company]
+        xml.address input[:address][:address] if input[:address][:address]
+        xml.city input[:address][:city] if input[:address][:city]
+        xml.state input[:address][:state] if input[:address][:state]
+        xml.zip input[:address][:zip] if input[:address][:zip]
+        xml.country input[:address][:country] if input[:address][:country]
+        xml.phoneNumber input[:address][:phone_number] if input[:address][:phone_number]
+        xml.faxNumber input[:address][:fax_number] if input[:address][:fax_number]
+        xml.customerAddressId input[:address][:customer_address_id] if input[:address][:customer_address_id]
+      end
+    end    
+    parse send(data)
+  end
+  
+  # # Update the status of a split tender group (a group of transactions, each of which pays for part of one order).
+  #   def update_split_tender_group(input)
+  #     data = build_request('updateSplitTenderGroupRequest') do |xml|
+  # 
+  #       DONT WANNA DO IT
+  #     
+  #     end    
+  #     parse send(data)
+  #   end
+  
+  
+  # Verify an existing customer payment profile by generating a test transaction.
+  def validate_customer_payment_profile(input)
+  	data = build_request('validateCustomerPaymentProfileRequest') do |xml|
+      xml.customerProfileId input[:customer_profile_id] if input[:customer_profile_id]
+      xml.customerPaymentProfileId input[:customer_payment_profile_id] if input[:customer_payment_profile_id]
+      xml.customerAddressId input[:customer_address_id] if input[:customer_address_id]
+      xml.cardCode input[:card_code] if input[:card_code]
+      xml.validationMode input[:validation_mode] if input[:validation_mode]
+    end    
+    parse send(data)
+  end
+   
+  # Create request head that is required for all requests.
+  #
+  # params: 
+  #   request string
+  #   block of code containing all the additional xml code
+  #
+  # return:
+  #   completed xml as a string
+  #
+  def build_request(request, xml = Builder::XmlMarkup.new(:indent => 2))
+    xml.instruct!
+    xml.tag!(request, :xmlns => 'AnetApi/xml/v1/schema/AnetApiSchema.xsd') do
+      xml.tag!('merchantAuthentication') do
+        xml.name @login
+        xml.transactionKey @key
+      end
+      yield(xml)
+    end
+    xml.target!
+  end
+  
+  # parse all xml documents given back from the API
+  # return:
+  #   hash containing all values from the xml doc
+  def parse(xml)
+    Crack::XML.parse(xml)
+  end
+  
+  # get the response code from any response.
+  #
+  # prerams:
+  #   response xml already parsed to hash  
+  # returns:
+  #   string - response code (something like "I00001" or "E00039")
+  def response_code(hash)
+    hash[hash.keys[0]]['messages']['message']['code']
+  end
+  
+  # get the response code from any response.
+  #
+  # prerams:
+  #   response xml already parsed to hash  
+  # returns: 
+  #   string - response text (should be something like "Successful." or some long explaination why we it didnt work)
+  def response_text(hash)
+    hash[hash.keys[0]]['messages']['message']['text']
+  end
+
+  
+  def send(xml) # returns xmlDoc of response
+    http = Net::HTTP.new(@uri.host, @uri.port)
+    http.use_ssl = 443 == @uri.port
+    begin
+      resp, body = http.post(@uri.path, xml, {'Content-Type' => 'text/xml'})
+    rescue   Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+      puts e.message      
+    end
+    body
+  end
+  
+end

data/spec/base.rb

@@ -0,0 +1,2 @@
+
+Dir["#{File.dirname(__FILE__)}/../lib/**/*"].each { |lib| require lib }

data/spec/lib/authorize_cim_spec.rb

@@ -0,0 +1,206 @@
+require "#{File.dirname(__FILE__)}/../base"
+
+describe AuthorizeCim do
+  
+  before do
+    @client = AuthorizeCim.new(:endpoint => :test, :login => <must fill in login to test>, :key => <must fill in key to test>)
+  end
+  
+  before :each do
+    hash = { :merchant_id => 'Lyon Hill', :description => 'Test User, should be deleted', :email => 'lyon@delorum.com'}
+    rtn = @client.create_customer_profile(hash)
+    @customer_profile = rtn['createCustomerProfileResponse']['customerProfileId']
+
+    hash2 = {:customer_profile_id => @customer_profile, :validation_mode => 'none', :payment_profile => {}}
+    hash2[:payment_profile] = {:customer_type => 'business', :payment => {}}
+    hash2[:payment_profile][:payment] = {:credit_card => {}}
+    hash2[:payment_profile][:payment][:credit_card] = {:card_number => '4007000000027', :expiration_date => '2011-03'}
+    rtn2 = @client.create_customer_payment_profile(hash2)
+    @customer_payment_profile = rtn2['createCustomerPaymentProfileResponse']['customerPaymentProfileId']
+    
+    hash3 = {:customer_profile_id => @customer_profile, :address => {}}
+    hash3[:address] = {
+      :first_name => 'Lyon', 
+      :last_name => 'Hill', 
+      :company => 'Delorum', 
+      :address => '218 N 2nd E', 
+      :city => 'Rexburg',
+      :state => 'ID',
+      :zip => '83440',
+      :country => 'United States Of America',
+      :phone_number => '2086810512',
+      :fax_number => '(208)359-1103'}
+    rtn3 = @client.create_customer_shipping_address(hash3)
+    @customer_address_profile = rtn3['createCustomerShippingAddressResponse']['customerAddressId']
+  end
+  
+  after :each do
+    hash4 = {:customer_profile_id => @customer_profile}
+    @client.delete_customer_profile(hash4)
+
+  end
+  
+  it "creates a valid customer profile" do
+    thing = { :merchant_id => 'guy', :description => 'o GOODNESS!', :email => 'lyon@delorum.com'}
+    item = @client.create_customer_profile(thing)
+    item['createCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+    kill = item['createCustomerProfileResponse']['customerProfileId']
+    @client.delete_customer_profile({:customer_profile_id => @customer_profile})
+  end
+
+  it "should fail to create a valid customer profile when it recieves invalid input" do
+    thing = {:useless_stuff => 'HAY, Im not useless :_('}
+    item = @client.create_customer_profile(thing)
+    item['createCustomerProfileResponse']['messages']['message']['code'].should_not == 'I00001'
+  end
+  
+  it "create Customer payment profile with the minimum requirements" do
+    hash = {:customer_profile_id => @customer_profile, :validation_mode => 'none', :payment_profile => {}}
+    hash[:payment_profile] = {:customer_type => 'business', :payment => {}}
+    hash[:payment_profile][:payment] = {:credit_card => {}}
+    hash[:payment_profile][:payment][:credit_card] = {:card_number => '1234567890123456', :expiration_date => '2011-03'}
+    pay_profile_return = @client.create_customer_payment_profile(hash)
+    pay_profile_return['createCustomerPaymentProfileResponse']['messages']['message']['code'].should == 'I00001'
+  end
+
+  it "create Customer payment profile with the maximum allowed fields" do
+    hash = {:ref_id => 'letters', :customer_profile_id => @customer_profile, :validation_mode => 'none', :payment_profile => {}}
+    hash[:payment_profile] = {:customer_type => 'business', :payment => {}, :bill_to => {}}
+    hash[:payment_profile][:bill_to] = {:first_name => 'Lyon', :last_name => 'Hill', :company => 'Delorum', :address => '185 N 2000 E', :city => 'Rexburg', :state => 'ID', :zip => '83440', :country => 'USA', :phone_number => 2083591103, :fax_number => 2085895149}
+    hash[:payment_profile][:payment] = {:credit_card => {}}
+    hash[:payment_profile][:payment][:credit_card] = {:card_number => '1234567890123456', :expiration_date => '2011-03'}
+    pay_profile_return = @client.create_customer_payment_profile(hash)
+    pay_profile_return['createCustomerPaymentProfileResponse']['messages']['message']['code'].should == 'I00001'
+  end
+
+  it "create a valid customer shipping address" do
+    hash = {:customer_profile_id => @customer_profile, :address => {}}
+    hash[:address] = {:first_name => 'Tyler', :last_name => 'Flint', :company => 'Delorum', :address => '23 N 2nd E', :city => 'Rexburg', :state => 'ID', :zip => '83440', :country => 'USA', :phone_number => 2083598909, :fax_number => 2082315149}
+    address_return = @client.create_customer_shipping_address(hash)
+    address_return['createCustomerShippingAddressResponse']['messages']['message']['code'].should == 'I00001'
+  end
+  
+
+  it "create a valid customer profile transaction" do
+    hash = {:ref_id => '2', :transaction => {}, :trans_type => 'profileTransPriorAuthCapture'}
+    hash[:transaction] = {:trans_type => 'profileTransAuthOnly', :transaction_type => {}}
+    hash[:transaction][:transaction_type] = {:amount => '101.11', :customer_profile_id => @customer_profile , :customer_payment_profile_id => @customer_payment_profile, :tax => {}}
+    hash[:transaction][:transaction_type][:tax] = {:amount => '23.21', :name => 'state taxes'}
+    transaction = @client.create_customer_profile_transaction(hash)
+    transaction['createCustomerProfileTransactionResponse']['messages']['message']['code'].should == 'I00001'
+  end
+  
+  it "should get customer profile IDs" do
+    all_customer_profile_ids = @client.get_customer_profile_ids
+    all_customer_profile_ids['getCustomerProfileIdsResponse']['messages']['message']['code'].should == 'I00001'
+  end
+
+  it "should get all of one customers profile info" do
+    hash = {:customer_profile_id => @customer_profile}
+    one_customer_info = @client.get_customer_profile(hash)
+    one_customer_info['getCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+  end
+    
+  it "should get one customers payment profile(s)" do
+    one_customer_payment = @client.get_customer_payment_profile({:customer_profile_id => @customer_profile, :customer_payment_profile_id => @customer_payment_profile})
+    one_customer_payment['getCustomerPaymentProfileResponse']['messages']['message']['code'].should == 'I00001'
+  end
+
+  it "should get one customers shipping address" do
+    one_customer_shipping = @client.get_customer_shipping_address({:customer_profile_id => @customer_profile, :customer_address_id => @customer_address_profile})
+    one_customer_shipping['getCustomerShippingAddressResponse']['messages']['message']['code'].should == 'I00001'
+  end
+  
+  it "should update a customer profile" do
+    hash = {:customer_profile_id => @customer_profile, :merchant_id => 'John Wayne'}
+    update_customer = @client.update_customer_profile(hash)
+    update_customer['updateCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+  end
+    
+  it "should update customer payment profile" do
+    hash = {:customer_profile_id => @customer_profile, :customer_payment_profile_id => @customer_payment_profile, :validation_mode => 'none', :payment_profile => {}}
+    hash[:payment_profile] = {:customer_type => 'business', :payment => {}}
+    hash[:payment_profile][:payment] = {:credit_card => {}}
+    hash[:payment_profile][:payment][:credit_card] = {:card_number => '1234567890123456', :expiration_date => '2011-03'}
+    pay_profile_return = @client.update_customer_payment_profile(hash)
+    pay_profile_return['updateCustomerPaymentProfileResponse']['messages']['message']['code'].should == 'I00001'
+  end
+  
+
+  it "should update customer shipping address" do
+    hash3 = {:customer_profile_id => @customer_profile, :address => {}}
+    hash3[:address] = {
+      :first_name => 'Lyon', 
+      :last_name => 'Hill', 
+      :company => 'Delorum', 
+      :address => '218 N 2nd E', 
+      :city => 'Rexburg',
+      :state => 'ID',
+      :zip => '83440',
+      :country => 'United States Of America',
+      :phone_number => '2086810512',
+      :fax_number => '(208)359-1103',
+      :customer_address_id => @customer_address_profile }
+    
+  end
+  
+  it "should validate Customer Payment Profile Request" do
+    
+  end
+  
+  it "should parse return statements for all xml returns except the get functions" do
+    xml = <<EOF
+    <?xml version="1.0" encoding="utf-8"?>
+    <createCustomerProfileResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="AnetApi/xml/v1/schema/AnetApiSchema.xsd">
+    	<messages>
+    		<resultCode>Ok</resultCode>
+    		<message>
+    			<code>I00001</code>
+    			<text>Successful.</text>
+    		</message>
+    	</messages>
+    	<customerProfileId>2667736</customerProfileId>
+    	<customerPaymentProfileIdList />
+    	<customerShippingAddressIdList />
+    	<validationDirectResponseList />
+    </createCustomerProfileResponse>
+EOF
+
+  item = @client.parse(xml) 
+	item['createCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+	item['createCustomerProfileResponse']['customerProfileId'].should == '2667736'
+  end
+  
+  it "should delete a customer profile" do
+    hash = {:customer_profile_id => @customer_profile}
+    rtn = @client.delete_customer_profile(hash)
+    rtn['deleteCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+    
+  end
+  
+  it "should delete a customer payment profile" do
+    hash = {:customer_profile_id => @customer_profile, :customer_payment_profile_id => @customer_payment_profile}
+    rtn = @client.delete_customer_profile(hash)
+    rtn['deleteCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+    
+  end
+  
+  it "should delete a customer shipping address" do
+    hash = {:customer_profile_id => @customer_profile, :customer_address_id => @customer_address_profile}
+    rtn = @client.delete_customer_profile(hash)
+    rtn['deleteCustomerProfileResponse']['messages']['message']['code'].should == 'I00001'
+    
+  end
+  
+  it "should get the response code from the hash" do
+    xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><createCustomerProfileResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><customerProfileId>2688406</customerProfileId><customerPaymentProfileIdList /><customerShippingAddressIdList /><validationDirectResponseList /></createCustomerProfileResponse>"
+    hash = @client.parse(xml)
+    "I00001".should == @client.response_code(hash)
+  end
+  
+  it "should get the plain text response from the hash" do
+    xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><createCustomerProfileResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><customerProfileId>2688406</customerProfileId><customerPaymentProfileIdList /><customerShippingAddressIdList /><validationDirectResponseList /></createCustomerProfileResponse>"
+    hash = @client.parse(xml)
+    "Successful.".should == @client.response_text(hash)
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification 
+name: authorize_cim
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tyler Flint
+- Lyon Hill
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-29 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: crack
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: builder
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: crack
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: builder
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id007
+description: Ruby Gem for integrating Authorize.net Customer Information Manager (CIM)
+email: tylerflint@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- VERSION
+- lib/authorize_cim.rb
+- spec/base.rb
+- spec/lib/authorize_cim_spec.rb
+has_rdoc: true
+homepage: http://github.com/tylerflint/authorize_cim
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby Gem for integrating Authorize.net Customer Information Manager (CIM)
+test_files: 
+- spec/base.rb
+- spec/lib/authorize_cim_spec.rb