trustcommerce 0.5.0

data/MIT-LICENSE

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

data/README

@@ -0,0 +1,147 @@
+= TrustCommerce Subscription Library
+
+[TrustCommerce](http://www.trustcommerce.com) is a payment gateway providing credit card
+processing and recurring / subscription billing services.
+
+This library provides a simple interface to create, edit, delete, and query subscriptions
+using TrustCommerce.
+
+== Background
+
+TrustCommerce's recurring / subscription billing solution is implemented through a service
+called [Citadel](http://www.trustcommerce.com/citadel.php).  A Citadel-enabled account is
+required to use the subscription-based features implemented by this library.
+
+=== Citadel Basics
+* Citadel stores customer profiles which can include credit card information and billing frequency.
+* Citadel will automatically bill customers on their respective schedules.
+* Citadel identifies each customer by a Billing ID (six-character alphanumeric string).
+* A customer's profile, credit card, and billing frequency can be modified using the Billing ID.
+
+== Installation
+
+The simple way:
+  $ sudo gem install trustcommerce
+
+Directly from repository:
+  $ svn co svn://rubyforge.org/var/svn/trustcommerce/trunk trustcommerce
+
+It is highly recommended to download and install the
+[TCLink ruby extension](http://www.trustcommerce.com/tclink.php).
+This extension provides failover capability and enhanced security features.
+If this library is not installed, standard POST over SSL will be used.
+
+== Configuration
+
+When you signup for a TrustCommerce account you are issued a custid and a password.
+These are your credentials when using the TrustCommerce API.
+
+  TrustCommerce.custid   = '123456'
+  TrustCommerce.password = 'topsecret'
+
+  # optional - sets Vault password for use in query() calls
+  TrustCommerce.vault_password = 'supersecure'
+
+The password that TrustCommerce issues never changes or expires when used through the TCLink
+extension.  However if you choose to use SSL over HTTP instead (the fallback option if the TCLink
+library is not installed), be aware that you need to set the password to your Vault password.
+Likewise, if your application uses the query() method you must set the vault_password.
+The reason is that TrustCommerce currently routes these query() calls through the vault 
+and therefore your password must be set accordingly.  To make matters more complicated, 
+TrustCommerce currently forces you to change the Vault password every 90 days.
+
+
+== Examples
+
+=== Creating a subscription
+
+  # Bill Jennifer $12.00 monthly
+  response = TrustCommerce::Subscription.create(
+    :cc     => '4111111111111111',
+    :exp    => '0412',
+    :name   => 'Jennifer Smith',
+    :amount => 1200,
+    :cycle  => '1m'
+  )
+  
+  if response['status'] == 'approved'
+    puts "Subscription created with Billing ID: #{response['billingid']}"
+  else
+    puts "An error occurred: #{response['error']}"
+  end
+
+
+=== Update a subscription
+
+  # Update subscription to use new credit card
+  response = TrustCommerce::Subscription.update(
+    :billingid => 'ABC123',
+    :cc        => '5411111111111115', 
+    :exp       => '0412'
+  )
+  
+  if response['status'] == 'accepted'
+    puts 'Subscription updated.'
+  else
+    puts "An error occurred: #{response['error']}"
+  end
+
+
+=== Delete a subscription
+
+  # Delete subscription
+  response = TrustCommerce::Subscription.delete(
+    :billingid => 'ABC123'
+  )
+  
+  if response['status'] == 'accepted'
+    puts 'Subscription removed from active use.'
+  else
+    puts 'An error occurred.'
+  end
+
+
+=== Query a subscription
+
+  # Get all sale transactions for a subscription in CSV format
+  response = TrustCommerce::Subscription.query(
+    :querytype => 'transaction',
+    :action    => 'sale',
+    :billingid => 'ABC123'
+  )
+
+
+=== Process a one-time charge
+
+  # Process one-time sale against existing subscription
+  response = TrustCommerce::Subscription.charge(
+    :billingid => 'ABC123',
+    :amount    => 1995
+  )
+
+
+=== Credit a transaction
+
+  # Process one-time credit against existing transaction
+  response = TrustCommerce::Subscription.credit(
+    :transid => '001-0000111101',
+    :amount  => 1995
+  )
+
+
+== Running the tests
+
+The following special environment variables must be set up prior to running tests:
+
+  $ export TC_USERNAME=123456
+  $ export TC_PASSWORD=password
+  $ export TC_VAULT_PASSWORD=password
+
+Run tests via rake:
+
+  $ rake test
+
+Run tests via ruby:
+
+  $ ruby test/trustcommerce_test.rb
+

data/Rakefile

@@ -0,0 +1,198 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'erb'
+
+require File.dirname(__FILE__) + '/lib/trustcommerce'
+require File.dirname(__FILE__) + '/lib/version'
+
+task :default => :test
+
+Rake::TestTask.new(:test) { |t|
+  t.libs << 'test'
+  t.test_files = Dir.glob('test/*_test.rb')
+  t.verbose = true
+}
+
+namespace :doc do
+  
+  Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = 'doc'
+    rdoc.title    = "TrustCommerce Subscription Library"
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('README')
+    rdoc.rdoc_files.include('MIT-LICENSE')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+  
+  task :rdoc => 'doc:readme'
+  
+  task :refresh => :rerdoc do
+    system 'open doc/index.html'
+  end
+
+  task :readme do
+    require 'support/rdoc/code_info'
+    RDoc::CodeInfo.parse('(lib|test)/*.rb')
+    
+    strip_comments = lambda {|comment| comment.gsub(/^# ?/, '')}
+    docs_for       = lambda do |location|
+      info = RDoc::CodeInfo.for(location)
+      raise RuntimeError, "Couldn't find documentation for `#{location}'" unless info
+      strip_comments[info.comment]
+    end
+    
+    open('README', 'w') do |file|
+      file.write ERB.new(IO.read('README.erb')).result(binding)
+    end
+  end
+  
+  task :deploy => :rerdoc do
+    sh %(scp -r doc zackchandler@rubyforge.org:/var/www/gforge-projects/trustcommerce/)
+  end
+  
+end
+
+namespace :site do
+  require 'rdoc/markup/simple_markup'
+  require 'rdoc/markup/simple_markup/to_html'
+  
+  readme = lambda { IO.read('README') }
+
+  readme_to_html = lambda do
+    handler = SM::ToHtml.new
+    handler.instance_eval do
+      require 'syntax'
+      require 'syntax/convertors/html'
+      def accept_verbatim(am, fragment) 
+        syntax = Syntax::Convertors::HTML.for_syntax('ruby')
+        @res << %(<div class="ruby">#{syntax.convert(fragment.txt, true)}</div>)
+      end
+    end
+    html = SM::SimpleMarkup.new.convert(readme.call, handler)
+    html.gsub(%r{\[([\w\s]+)\]\(([\w:/.]+)\)}, '<a href="\2">\1</a>')
+  end
+  
+  desc 'Regenerate the public website page'
+  task :build => 'doc:readme' do
+    open('site/public/index.html', 'w') do |file|
+      erb_data = {}
+      erb_data[:readme] = readme_to_html.call
+      file.write ERB.new(IO.read('site/index.erb')).result(binding)
+    end
+  end
+  
+  task :refresh => :build do
+    system 'open site/public/index.html'
+  end
+  
+  desc 'Update the live website'
+  task :deploy => :build do
+    site_files = FileList['site/public/*']
+    sh %(scp #{site_files.join ' '} zackchandler@rubyforge.org:/var/www/gforge-projects/trustcommerce/)
+  end
+end
+
+namespace :dist do
+  
+  spec = Gem::Specification.new do |s|
+    s.name              = 'trustcommerce'
+    s.version           = Gem::Version.new(TrustCommerce::Version)
+    s.summary           = 'TrustCommerce Subscription Library'
+    s.description       = s.summary
+    s.email             = 'zackchandler@depixelate.com'
+    s.author            = 'Zack Chandler'
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = %w(README MIT-LICENSE)
+    s.homepage          = 'http://trustcommerce.rubyforge.org'
+    s.rubyforge_project = 'trustcommerce'
+    s.files             = FileList['Rakefile', 'lib/*.rb', 'support/**/*.rb']
+    s.test_files        = Dir['test/*']
+
+    s.rdoc_options  = ['--title', 'TrustCommerce Subscription Library',
+                       '--main',  'README',
+                       '--line-numbers', '--inline-source']
+  end
+    
+  # Regenerate README before packaging
+  task :package => 'doc:readme'
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar_gz = true
+    pkg.package_files.include('{lib,test,support}/**/*')
+    pkg.package_files.include('README')
+    pkg.package_files.include('MIT-LICENSE')
+    pkg.package_files.include('Rakefile')
+  end
+  
+  desc 'Install with gems'
+  task :install => :repackage do
+    sh "sudo gem i pkg/#{spec.name}-#{spec.version}.gem"
+  end
+  
+  desc 'Uninstall gem'
+  task :uninstall do
+    sh "sudo gem uninstall #{spec.name}"
+  end
+  
+  desc 'Reinstall gem'
+  task :reinstall => [:uninstall, :install]
+  
+  task :confirm_release do
+    print "Releasing version #{spec.version}. Are you sure you want to proceed? [Yn] "
+    abort if STDIN.getc == ?n
+  end
+  
+  desc 'Tag release'
+  task :tag do
+    svn_root = 'svn+ssh://zackchandler@rubyforge.org/var/svn/trustcommerce'
+    sh %(svn cp #{svn_root}/trunk #{svn_root}/tags/rel-#{spec.version} -m "Tag #{spec.name} release #{spec.version}")
+  end
+  
+  desc 'Update changelog to include a release marker'
+  task :add_release_marker_to_changelog do
+    changelog = IO.read('CHANGELOG')
+    changelog.sub!(/^trunk:/, "#{spec.version}:")
+    
+    open('CHANGELOG', 'w') do |file|
+      file.write "trunk:\n\n#{changelog}"
+    end
+  end
+  
+  task :commit_changelog do
+    sh %(svn ci CHANGELOG -m "Bump changelog version marker for release")
+  end
+  
+  package_name = lambda {|specification| File.join('pkg', "#{specification.name}-#{specification.version}")}
+  
+  desc 'Push a release to rubyforge'
+  task :release => [:confirm_release, :clean, :add_release_marker_to_changelog, :package, :commit_changelog, :tag] do 
+    require 'rubyforge'
+    package = package_name[spec]
+
+    rubyforge = RubyForge.new
+    rubyforge.login
+
+    version_already_released = lambda do
+      releases = rubyforge.config['rubyforge']['release_ids']
+      releases.has_key?(spec.name) && releases[spec.name][spec.version]
+    end
+    
+    abort("Release #{spec.version} already exists!") if version_already_released.call
+
+    if release_id = rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version, "#{package}.tar.gz")
+      rubyforge.add_file(spec.rubyforge_project, spec.name, release_id, "#{package}.gem")
+    else
+      puts 'Release failed!'
+    end
+  end
+  
+  task :spec do
+    puts spec.to_ruby
+  end
+  
+end
+
+task :clean => ['dist:clobber_package', 'doc:clobber_rdoc']

data/lib/trustcommerce.rb

@@ -0,0 +1,217 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+# [TrustCommerce](http://www.trustcommerce.com) is a payment gateway providing credit card
+# processing and recurring / subscription billing services.
+#
+# This library provides a simple interface to create, edit, delete, and query subscriptions
+# using TrustCommerce.
+#
+# == Background
+#
+# TrustCommerce's recurring / subscription billing solution is implemented through a service
+# called [Citadel](http://www.trustcommerce.com/citadel.php).  A Citadel-enabled account is
+# required to use the subscription-based features implemented by this library.
+#
+# === Citadel Basics
+# * Citadel stores customer profiles which can include credit card information and billing frequency.
+# * Citadel will automatically bill customers on their respective schedules.
+# * Citadel identifies each customer by a Billing ID (six-character alphanumeric string).
+# * A customer's profile, credit card, and billing frequency can be modified using the Billing ID.
+#
+# == Installation
+#
+# The simple way:
+#   $ sudo gem install trustcommerce
+#
+# Directly from repository:
+#   $ svn co svn://rubyforge.org/var/svn/trustcommerce/trunk trustcommerce
+#
+# It is highly recommended to download and install the
+# [TCLink ruby extension](http://www.trustcommerce.com/tclink.php).
+# This extension provides failover capability and enhanced security features.
+# If this library is not installed, standard POST over SSL will be used.
+#
+# == Configuration
+#
+# When you signup for a TrustCommerce account you are issued a custid and a password.
+# These are your credentials when using the TrustCommerce API.
+#
+#   TrustCommerce.custid   = '123456'
+#   TrustCommerce.password = 'topsecret'
+#
+#   # optional - sets Vault password for use in query() calls
+#   TrustCommerce.vault_password = 'supersecure'
+#
+# The password that TrustCommerce issues never changes or expires when used through the TCLink
+# extension.  However if you choose to use SSL over HTTP instead (the fallback option if the TCLink
+# library is not installed), be aware that you need to set the password to your Vault password.
+# Likewise, if your application uses the query() method you must set the vault_password.
+# The reason is that TrustCommerce currently routes these query() calls through the vault 
+# and therefore your password must be set accordingly.  To make matters more complicated, 
+# TrustCommerce currently forces you to change the Vault password every 90 days.
+class TrustCommerce
+
+  class << self
+    attr_accessor :custid
+    attr_accessor :password
+    attr_accessor :vault_password
+    
+    # Returns Vault password.
+    def vault_password
+      @vault_password || password
+    end    
+  end
+  self.custid   = 'TestMerchant'
+  self.password = 'password'
+  
+  # Settings for standard POST over SSL 
+  # Only used if TCLink library is not installed
+  API_SETTINGS = { 
+    :domain => 'vault.trustcommerce.com',
+    :query_path => '/query/', 
+    :trans_path => '/trans/', 
+    :port => 443  
+  }
+  
+  class Subscription
+
+    #   # Bill Jennifer $12.00 monthly
+    #   response = TrustCommerce::Subscription.create(
+    #     :cc     => '4111111111111111',
+    #     :exp    => '0412',
+    #     :name   => 'Jennifer Smith',
+    #     :amount => 1200,
+    #     :cycle  => '1m'
+    #   )
+    #   
+    #   if response['status'] == 'approved'
+    #     puts "Subscription created with Billing ID: #{response['billingid']}"
+    #   else
+    #     puts "An error occurred: #{response['error']}"
+    #   end
+    def self.create(options)
+      return TrustCommerce.send_request(options.merge(:action => 'store'))
+    end
+    
+    #   # Update subscription to use new credit card
+    #   response = TrustCommerce::Subscription.update(
+    #     :billingid => 'ABC123',
+    #     :cc        => '5411111111111115', 
+    #     :exp       => '0412'
+    #   )
+    #   
+    #   if response['status'] == 'accepted'
+    #     puts 'Subscription updated.'
+    #   else
+    #     puts "An error occurred: #{response['error']}"
+    #   end
+    def self.update(options)
+      return TrustCommerce.send_request(options.merge(:action => 'store'))
+    end    
+    
+    #   # Delete subscription
+    #   response = TrustCommerce::Subscription.delete(
+    #     :billingid => 'ABC123'
+    #   )
+    #   
+    #   if response['status'] == 'accepted'
+    #     puts 'Subscription removed from active use.'
+    #   else
+    #     puts 'An error occurred.'
+    #   end
+    def self.delete(options)
+      return TrustCommerce.send_request(options.merge(:action => 'unstore'))
+    end
+    
+    #   # Process one-time sale against existing subscription
+    #   response = TrustCommerce::Subscription.charge(
+    #     :billingid => 'ABC123',
+    #     :amount    => 1995
+    #   )
+    def self.charge(options)
+      return TrustCommerce.send_request(options.merge(:action => 'sale'))
+    end
+    
+    #   # Process one-time credit against existing transaction
+    #   response = TrustCommerce::Subscription.credit(
+    #     :transid => '001-0000111101',
+    #     :amount  => 1995
+    #   )
+    def self.credit(options)
+      return TrustCommerce.send_request(options.merge(:action => 'credit'))
+    end
+    
+    #   # Get all sale transactions for a subscription in CSV format
+    #   response = TrustCommerce::Subscription.query(
+    #     :querytype => 'transaction',
+    #     :action    => 'sale',
+    #     :billingid => 'ABC123'
+    #   )
+    def self.query(options)
+      return TrustCommerce.send_query(options)
+    end    
+    
+  end
+  
+  # It is highly recommended to download and install the
+  # [TCLink ruby extension](http://www.trustcommerce.com/tclink.php).
+  # This extension provides failover capability and enhanced security features.
+  # If this library is not installed, standard POST over SSL will be used.
+  def self.tclink?
+    begin
+      require 'tclink'
+      true
+    rescue LoadError
+      false
+    end
+  end
+  
+  private
+  
+    def self.stringify_hash(hash)
+      hash.inject({}) { |h,(k,v)| h[k.to_s] = v.to_s; h }
+    end
+
+    def self.symbolize_hash(hash)
+      hash.inject({}) { |h,(k,v)| h[k.to_sym] = v.to_s; h }
+    end
+    
+    def self.send_request(options)
+      options[:custid]   = self.custid
+      options[:password] = self.password
+      options.update(:demo => 'y') if ENV['RAILS_ENV'] != 'production'
+      parameters = stringify_hash(options)
+      if tclink? # use TCLink extension if installed
+        return symbolize_hash(TCLink.send(parameters))
+      else # TCLink library not installed - use https post
+        parameters[:password] = self.vault_password.to_s
+        response = send_https_request(API_SETTINGS[:trans_path], parameters)
+        
+        # parse response
+        results = {}
+        response.body.split("\n").each do |line|
+          k, v = line.split('=')
+          results[k.to_sym] = v
+        end
+        results
+      end
+    end
+    
+    def self.send_query(options)
+      options[:custid]   = self.custid
+      options[:password] = self.vault_password.to_s
+      response = send_https_request(API_SETTINGS[:query_path], stringify_hash(options))
+    end
+    
+    def self.send_https_request(path, parameters)
+      http = Net::HTTP.new(API_SETTINGS[:domain], API_SETTINGS[:port])
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE # avoid ssl cert warning
+      request = Net::HTTP::Post.new(path)
+      request.form_data = parameters
+      http.request(request)
+    end
+
+end

data/lib/version.rb

@@ -0,0 +1,9 @@
+class TrustCommerce
+  module VERSION #:nodoc:
+    MAJOR    = '0'
+    MINOR    = '5'
+    TINY     = '0'
+  end
+  
+  Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].compact * '.'
+end

data/support/rdoc/code_info.rb

@@ -0,0 +1,211 @@
+require 'rubygems'
+require 'rake'
+require 'rdoc/rdoc'
+
+module RDoc
+  class CodeInfo    
+    class << self
+      def parse(wildcard_pattern = nil)
+        @info_for_corpus = parse_files(wildcard_pattern)
+      end
+      
+      def for(constant)
+        new(constant).info
+      end
+      
+      def info_for_corpus
+        raise RuntimeError, "You must first generate a corpus to search by using RDoc::CodeInfo.parse" unless @info_for_corpus
+        @info_for_corpus
+      end
+      
+      def parsed_files
+        info_for_corpus.map {|info| info.file_absolute_name}
+      end
+      
+      def files_to_parse
+        @files_to_parse ||= Rake::FileList.new
+      end
+      
+      private
+        def parse_files(pattern)
+          files   = pattern ? Rake::FileList[pattern] : files_to_parse
+          options = Options.instance
+          options.parse(files << '-q', RDoc::GENERATORS)
+          rdoc.send(:parse_files, options)
+        end
+        
+        def rdoc
+          TopLevel.reset
+          rdoc  = RDoc.new
+          stats = Stats.new
+          # We don't want any output so we'll override the print method
+          stats.instance_eval { def print; nil end } 
+          rdoc.instance_variable_set(:@stats, stats)
+          rdoc
+        end
+    end
+    
+    attr_reader :info
+    def initialize(location)
+      @location = CodeLocation.new(location)
+      find_constant
+      find_method if @location.has_method?
+    end
+    
+    private
+      attr_reader :location
+      attr_writer :info
+      def find_constant
+        parts = location.namespace_parts
+        self.class.info_for_corpus.each do |file_info|
+          @info = parts.inject(file_info) do |result, const_part|
+            (result.find_module_named(const_part) || result.find_class_named(const_part)) || break
+          end
+          return if info
+        end
+      end
+      
+      def find_method
+        return unless info
+        self.info = info.method_list.detect do |method_info|
+          next unless method_info.name == location.method_name
+          if location.class_method?
+            method_info.singleton
+          elsif location.instance_method?
+            !method_info.singleton
+          else
+            true
+          end
+        end
+      end
+  end
+  
+  class CodeLocation
+    attr_reader :location
+
+    def initialize(location)
+      @location = location
+    end
+
+    def parts
+      location.split(/::|\.|#/)
+    end
+
+    def namespace_parts
+      has_method? ? parts[0...-1] : parts
+    end
+
+    def has_method?
+      ('a'..'z').include?(parts.last[0, 1])
+    end
+
+    def instance_method?
+      !location['#'].nil?
+    end
+
+    def class_method?
+      has_method? && !location[/#|\./]
+    end
+
+    def method_name
+      parts.last if has_method?
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'test/unit'
+  class CodeInfoTest < Test::Unit::TestCase
+    def setup
+      RDoc::CodeInfo.parse(__FILE__)
+    end
+    
+    def test_constant_lookup
+      assert RDoc::CodeInfo.for('RDoc')
+      
+      info = RDoc::CodeInfo.for('RDoc::CodeInfo')
+      assert_equal 'CodeInfo', info.name      
+    end
+    
+    def test_method_lookup
+      {'RDoc::CodeInfo.parse'          => true,
+       'RDoc::CodeInfo::parse'         => true,
+       'RDoc::CodeInfo#parse'          => false,
+       'RDoc::CodeInfo.find_method'    => true,
+       'RDoc::CodeInfo::find_method'   => false,
+       'RDoc::CodeInfo#find_method'    => true,
+       'RDoc::CodeInfo#no_such_method' => false,
+       'RDoc::NoSuchConst#foo'         => false}.each do |location, result_of_lookup|
+         assert_equal result_of_lookup, !RDoc::CodeInfo.for(location).nil?
+       end
+    end
+  end
+  
+  class CodeLocationTest < Test::Unit::TestCase
+    def test_parts
+       {'Foo'           => %w(Foo),
+        'Foo::Bar'      => %w(Foo Bar),
+        'Foo::Bar#baz'  => %w(Foo Bar baz),
+        'Foo::Bar.baz'  => %w(Foo Bar baz),
+        'Foo::Bar::baz' => %w(Foo Bar baz),
+        'Foo::Bar::Baz' => %w(Foo Bar Baz)}.each do |location, parts|
+          assert_equal parts, RDoc::CodeLocation.new(location).parts
+        end
+    end
+    
+    def test_namespace_parts
+      {'Foo'           => %w(Foo),
+       'Foo::Bar'      => %w(Foo Bar),
+       'Foo::Bar#baz'  => %w(Foo Bar),
+       'Foo::Bar.baz'  => %w(Foo Bar),
+       'Foo::Bar::baz' => %w(Foo Bar),
+       'Foo::Bar::Baz' => %w(Foo Bar Baz)}.each do |location, namespace_parts|
+         assert_equal namespace_parts, RDoc::CodeLocation.new(location).namespace_parts
+       end
+     end
+    
+    def test_has_method?
+      {'Foo'           => false,
+       'Foo::Bar'      => false,
+       'Foo::Bar#baz'  => true,
+       'Foo::Bar.baz'  => true,
+       'Foo::Bar::baz' => true,
+       'Foo::Bar::Baz' => false}.each do |location, has_method_result|
+         assert_equal has_method_result, RDoc::CodeLocation.new(location).has_method?
+       end
+     end
+     
+    def test_instance_method?
+      {'Foo'           => false,
+       'Foo::Bar'      => false,
+       'Foo::Bar#baz'  => true,
+       'Foo::Bar.baz'  => false,
+       'Foo::Bar::baz' => false,
+       'Foo::Bar::Baz' => false}.each do |location, is_instance_method|
+         assert_equal is_instance_method, RDoc::CodeLocation.new(location).instance_method?
+       end
+     end
+     
+     def test_class_method?
+       {'Foo'           => false,
+        'Foo::Bar'      => false,
+        'Foo::Bar#baz'  => false,
+        'Foo::Bar.baz'  => false,
+        'Foo::Bar::baz' => true,
+        'Foo::Bar::Baz' => false}.each do |location, is_class_method|
+          assert_equal is_class_method, RDoc::CodeLocation.new(location).class_method?
+        end
+      end
+      
+      def test_method_name
+        {'Foo'           => nil,
+         'Foo::Bar'      => nil,
+         'Foo::Bar#baz'  => 'baz',
+         'Foo::Bar.baz'  => 'baz',
+         'Foo::Bar::baz' => 'baz',
+         'Foo::Bar::Baz' => nil}.each do |location, method_name|
+           assert_equal method_name, RDoc::CodeLocation.new(location).method_name
+         end
+       end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/trustcommerce'
+
+begin
+  require 'mocha'
+rescue LoadError
+  puts "Mocha required to run tests. `gem install mocha` and try again."
+  exit 1
+end
+
+TCLINK_LIB_INSTALLED = TrustCommerce.tclink?
+
+def via_tclink_and_https
+  # test via TCLink
+  if !TCLINK_LIB_INSTALLED
+    puts 'TCLink library not installed - skipping tests via TCLink'
+  else
+    TrustCommerce.stubs(:tclink?).returns(true)
+    yield
+  end
+  
+  # test via https
+  TrustCommerce.stubs(:tclink?).returns(false)
+  yield
+end
+
+def create_subscription!(name)
+  response = TrustCommerce::Subscription.create(
+    :cc       => CARDS[:visa][:cc], 
+    :exp      => CARDS[:visa][:exp],
+    :address1 => CARDS[:visa][:address],
+    :zip      => CARDS[:visa][:zip],
+    :avs      => 'y',      
+    :name     => name,
+  	:amount   => 1200,
+  	:cycle    => '1m',
+    :demo     => 'y'
+  )
+  assert_equal 'approved', response[:status]    
+  assert response.keys.include?(:billingid)
+  response[:billingid]
+end
+
+# --- [ TrustCommerce test data ] ---
+# reference: https://vault.trustcommerce.com/downloads/TCDevGuide.html#testdata
+CARDS = {
+  :visa       => { :cc      => '4111111111111111', 
+                   :exp     => '0412', 
+                   :cvv     => 123,
+                   :address => '123 Test St.', 
+                   :city    => 'Somewhere', 
+                   :state   => 'CA', 
+                   :zip     => 90001 },
+  :mastercard => { :cc      => '5411111111111115', 
+                   :exp     => '0412', 
+                   :cvv     => 777,
+                   :address => '4000 Main St.', 
+                   :city    => 'Anytown', 
+                   :state   => 'MA', 
+                   :zip     => 85001 },
+  :amex       => { :cc      => '341111111111111',  
+                   :exp     => '0412', 
+                   :cvv     => 4000,
+                   :address => '12 Colorado Blvd.', 
+                   :city    => 'Elsewhere', 
+                   :state   => 'IL', 
+                   :zip     => 54321 }
+}

data/test/trustcommerce_test.rb

@@ -0,0 +1,149 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+# The following special environment variables must be set up prior to running tests:
+# 
+#   $ export TC_USERNAME=123456
+#   $ export TC_PASSWORD=password
+#   $ export TC_VAULT_PASSWORD=password
+#
+# Run tests via rake:
+#
+#   $ rake test
+#
+# Run tests via ruby:
+#
+#   $ ruby test/trustcommerce_test.rb
+class TrustCommerceSubscriptionTest < Test::Unit::TestCase
+
+  def setup
+    if ENV['TC_USERNAME'].nil? || ENV['TC_PASSWORD'].nil?
+      puts 'TC_USERNAME and TC_PASSWORD must be set.'
+      puts 'Usage: TC_USERNAME=username TC_PASSWORD=password TC_VAULT_PASSWORD=password ruby test/trustcommerce_test.rb'
+      exit 1
+    else
+      TrustCommerce.custid         = ENV['TC_USERNAME']
+      TrustCommerce.password       = ENV['TC_PASSWORD']
+      TrustCommerce.vault_password = ENV['TC_VAULT_PASSWORD'] if ENV['TC_VAULT_PASSWORD']
+    end
+  end
+
+  def test_subscription_create
+    via_tclink_and_https do
+      response = TrustCommerce::Subscription.create(
+        :cc       => CARDS[:visa][:cc], 
+        :exp      => CARDS[:visa][:exp], 
+        :address1 => CARDS[:visa][:address],
+        :zip      => CARDS[:visa][:zip],
+        :avs      => 'y',
+        :name     => 'Jennifer Smith - create() test',
+      	:amount   => 1200,
+      	:cycle    => '1m',
+        :demo     => 'y'
+      )
+      assert_equal Hash, response.class
+      assert_not_nil response[:billingid]
+      assert response.keys.include?(:transid)
+      assert_equal 'approved', response[:status]  
+    end
+  end
+  
+  def test_subscription_update
+    via_tclink_and_https do
+      billing_id = create_subscription!('update() test')
+      response = TrustCommerce::Subscription.update(
+        :billingid => billing_id,
+        :cc        => CARDS[:mastercard][:cc], 
+        :exp       => CARDS[:mastercard][:exp],
+        :address1  => CARDS[:mastercard][:address],
+        :zip       => CARDS[:mastercard][:zip],
+        :avs       => 'y'
+      )
+      assert_equal 'accepted', response[:status]
+    end
+  end
+  
+  def test_subscription_delete
+    via_tclink_and_https do
+      billing_id = create_subscription!('delete() test')
+      response = TrustCommerce::Subscription.delete(
+        :billingid => billing_id
+      )
+      assert response.keys.include?(:transid)
+      assert_equal 'accepted', response[:status]
+    end
+  end
+  
+  def test_subscription_charge_and_credit
+    via_tclink_and_https do    
+      billing_id = create_subscription!('charge and credit() test')
+      
+      # charge
+      charge_response = TrustCommerce::Subscription.charge(
+        :billingid  => billing_id,
+        :amount     => 1995,
+        :demo       => 'y'
+      )
+      assert charge_response.keys.include?(:transid)
+      assert_equal 'approved', charge_response[:status]
+    
+      # credit
+      credit_response = TrustCommerce::Subscription.credit(
+        :transid  => charge_response[:transid],
+        :amount   => 995,
+        :demo     => 'y'
+      )
+      assert credit_response.keys.include?(:transid)
+      assert_equal 'accepted', credit_response[:status]
+    end
+  end
+  
+  def test_subscription_query
+    puts "\n"
+    puts "---------------------------------------------------------------------------"
+    puts "IMPORTANT: This query test will likely take between 1 and 2 minutes!"
+    puts "Make sure TC_VAULT_PASSWORD is set if it differs from your TCLink password."
+    puts "---------------------------------------------------------------------------"
+    
+    # create subscription
+    billing_id = create_subscription!('query() test')
+
+    # query for charges
+    options = { :querytype => 'transaction', :action => 'sale', :billingid => billing_id }
+    while (query_response = TrustCommerce::Subscription.query(options))
+      if query_response.body =~ /error/i
+        fail(query_response.body)
+        break
+      elsif query_response.body.split("\n").size < 2
+        puts 'Transaction has not yet showed up... will try again in 15 seconds.'
+        sleep(15)
+      else
+        puts 'Transaction found.'
+        
+        # setup index hash
+        field_names = query_response.body.split("\n")[0].split(',')
+        date_line_1 = query_response.body.split("\n")[1].split(',')
+        indexes = field_names.inject({}) {|h, field| h[field.to_sym] = field_names.index(field); h }
+
+        # check transaction data
+        assert_equal '1111',            date_line_1[indexes[:cc]]
+        assert_equal '1200',            date_line_1[indexes[:amount]]
+        assert_equal 'query() test',    date_line_1[indexes[:name]]
+        break
+      end
+    end
+  end
+  
+  # test private helpers
+  def test_stringify_hash
+    assert_equal ({ 'a' => '1', 'b' => '2' }),  TrustCommerce.stringify_hash(:a => '1', :b => '2')
+    assert_equal ({ 'a' => '1', 'b' => '2' }),  TrustCommerce.stringify_hash(:a => 1, :b => 2)
+    assert_equal ({ 'a' => '2' }),              TrustCommerce.stringify_hash(:a => 1, :a => 2)
+  end
+
+  def test_symbolize_hash
+    assert_equal ({ :a => '1', :b => '2' }),  TrustCommerce.symbolize_hash('a' => '1', 'b' => '2')
+    assert_equal ({ :a => '1', :b => '2' }),  TrustCommerce.symbolize_hash(:a => 1, 'b' => 2)
+    assert_equal ({ :a => '1' }),             TrustCommerce.symbolize_hash(:a => 1, 'a' => 2)
+  end
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: trustcommerce
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+date: 2007-02-28 00:00:00 -08:00
+summary: TrustCommerce Subscription Library
+require_paths: 
+- lib
+email: zackchandler@depixelate.com
+homepage: http://trustcommerce.rubyforge.org
+rubyforge_project: trustcommerce
+description: TrustCommerce Subscription Library
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Zack Chandler
+files: 
+- Rakefile
+- lib/trustcommerce.rb
+- lib/version.rb
+- support/rdoc/code_info.rb
+- README
+- MIT-LICENSE
+test_files: 
+- test/test_helper.rb
+- test/trustcommerce_test.rb
+rdoc_options: 
+- --title
+- TrustCommerce Subscription Library
+- --main
+- README
+- --line-numbers
+- --inline-source
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+