vindicia 0.2.2

data/Isolate

@@ -0,0 +1,3 @@
+gem 'jeweler'
+gem 'rspec'
+gem 'savon'

data/README.md

@@ -0,0 +1,44 @@
+This library is an API wrapper for the [Vindicia][] payment gateway.
+
+# Dependencies
+
+As of the 0.2.0 release, this gem targets Ruby 1.9.
+
+It requires the [savon][] SOAP client library, and will use [httpclient][] if present (otherwise just using net/http).
+
+# Usage
+
+Firstly, call `Vindicia.authenticate` with your login, password, and target environment. These values will remain cached for all subsequent calls.
+
+After that, all soap calls are methods on classes in the Vindicia namespace, taking either hashes or other instances as arguments. For example,
+
+      account, created = Vindicia::Account.update({
+        :merchantAccountId => "user42",
+        :name => "bob"
+      })
+
+Almost all interaction is dynamically driven by the content of the WSDL files, but there are two special cases.
+
+`Vindicia::Thing#ref` will return a minimal hash for lookups in subsequent calls. So after creating a new `Account`, you can substitute `account.ref` in a purchase call, rather than sending the entire object back over the wire.
+
+`Vindicia::Thing.find` is a convenience method to call the appropriate method to look up the object by merchant id, simply to reduce redundancy.
+
+# Development
+
+Developers looking to build upon this gem will need to install [isolate][], which will sandbox installation of savon, [rspec][], and [jeweler][] in `./tmp`.
+
+To run the specs, you'll need to copy `authenticate.example.rb` to `authenticate.rb` and fill in your own account information. Additionally, a number of specs depend on existing data in my test account, which should probably be fixed at some point (probably with a rake task to populate the test environment).
+
+# Known Issues
+
+HTTPI (a savon dependency) is _really_ chatty logging to stdout, and I haven't figured out a good way to mute it.
+
+WSDL files are being live-downloaded every run. It'd be nice to cache them locally.
+
+
+[Vindicia]: http://www.vindicia.com/
+[savon]: https://github.com/rubiii/savon
+[httpclient]: https://github.com/nahi/httpclient
+[isolate]: https://github.com/jbarnette/isolate
+[rspec]: https://rspec.info/
+[jeweler]: https://github.com/technicalpickles/jeweler

data/Rakefile

@@ -0,0 +1,20 @@
+require 'isolate/now'
+require 'isolate/rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "vindicia"
+    gemspec.summary = "Wrapper interface to Vindicia's SOAP API"
+    gemspec.description = gemspec.summary
+    gemspec.email = "jamie@almlabs.com"
+    gemspec.homepage = "http://github.com/almlabs/vindicia"
+    gemspec.authors = ["Jamie Macey"]
+    gemspec.add_dependency('savon', '=0.8.2')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/lib/savon_patches.rb

@@ -0,0 +1,40 @@
+class Savon::SOAP::XML
+  def self.to_hash(xml)
+    # Vindicia xml isn't _completely_ self-documenting. Ensure xsi header exists.
+    if xml =~ /soap.vindicia.com/ and xml !~ /xmlns:xsi/
+      xml = xml.sub(/soap:Envelope/, "soap:Envelope\n    xmlns:xsi=\"#{SchemaTypes["xmlns:xsi"]}\"")
+    end
+    (Crack::XML.parse(xml) rescue {}).find_soap_body
+  end
+end
+
+class Savon::WSDL::Document
+  def arg_list
+    # simple passthrough
+    parser.arg_list
+  end
+end
+
+class Savon::WSDL::ParserWithArgList < Savon::WSDL::Parser
+  attr_reader :arg_list
+  
+  def initialize
+    super
+    @arg_list = {}
+  end
+  
+  def tag_start(tag, attrs)
+    super
+    arg_list_from tag, attrs if @section == :message
+  end
+  
+  def arg_list_from(tag, attrs)
+    # Track argument lists so I can use arrays instead of hashes when posting data
+    if tag == "message"
+      @section_name = attrs["name"]
+      @arg_list[@section_name] = []
+    elsif tag == "part"
+      @arg_list[@section_name] << attrs
+    end
+  end
+end

data/lib/vindicia.rb

@@ -0,0 +1,469 @@
+require 'savon'
+require 'savon_patches'
+
+Savon.configure do |config|
+  config.log = false            # disable logging
+  #config.log_level = :info      # changing the log level
+  #config.logger = Rails.logger  # using the Rails logger
+  config.soap_version = 1
+end
+
+module Vindicia
+  NAMESPACE = "http://soap.vindicia.com/Vindicia"
+
+  class << self
+    attr_reader :login, :password, :environment
+    def authenticate(login, pass, env=:prodtest)
+      @login       = login
+      @password    = pass
+      @environment = env.to_s
+    end
+
+    def version
+      '3.4'
+    end
+
+    def auth
+      {'version' => version, 'login' => login, 'password' => password}
+    end
+
+    def domain
+      case @environment
+      when 'production'; "soap.vindicia.com"
+      when 'staging'   ; "soap.staging.sj.vindicia.com"
+      else             ; "soap.prodtest.sj.vindicia.com"
+      end
+    end
+
+    def endpoint
+      "https://#{domain}/v#{version}/soap.pl"
+    end
+
+    def xsd(klass)
+      require 'open-uri'
+      url = "http://#{domain}/#{version}/Vindicia.xsd"
+      @xsd_data ||= begin
+        doc = REXML::Document.new(open(url).read)
+        doc.root.get_elements("//xsd:complexType").inject({}){|memo, node|
+          memo[node.attributes["name"]] = node.get_elements("xsd:sequence/xsd:element").map{|e|e.attributes}
+          memo
+        }
+      end
+      @xsd_data[klass]
+    end
+
+    def wsdl(object)
+      "http://#{domain}/#{version}/#{object}.wsdl"
+    end
+
+    def class(type)
+      klass = type.split(':').last
+      klass = singularize($1) if klass =~ /^ArrayOf(.*)$/
+      Vindicia.const_get(klass) rescue nil
+    end
+
+    def type_of(arg)
+      case arg
+        when TrueClass, FalseClass
+          'xsd:boolean'
+        when String
+          'xsd:string'
+        when Fixnum
+          'xsd:int'
+        when Float #, Decimal
+          'xsd:decimal'
+        # TODO: 'xsd:long'
+        when Date, DateTime, Time
+          'xsd:dateTime'
+        #TODO: 'xsd:anyURI'
+        when SoapObject
+          "wsdl:#{arg.classname}"
+        else
+          raise "Unknown type for #{arg.class}~#{arg.inspect}"
+      end
+    end
+
+    def coerce(name, type, value)
+      return value if value.kind_of? SoapObject
+
+      case type
+      when /ArrayOf/
+        return [] if value.nil?
+        if value.kind_of? Hash
+          if value[name.to_sym]
+            return coerce(name, type, [value[name.to_sym]].flatten)
+          else
+            value = [value]
+          end
+        end
+        value.map do |val|
+          coerce(name, singularize(type), val)
+        end
+      when /^namesp/, /^vin/, /^tns/
+        type = value[:type] if value.kind_of? Hash
+        if klass = Vindicia.class(type)
+          klass.new(value)
+        else
+          value
+        end
+      when "xsd:int"
+        value.to_i
+      else
+        value
+      end
+    end
+
+  private
+    def singularize(type)
+      # Specifically formulated for just the ArrayOf types in Vindicia
+      # The '!' is there to handle singularizing "ses" suffix correctly
+      type.sub(/ArrayOf/,'').
+        sub(/ies$/, 'y').
+        sub(/([sx])es$/, '\1!').
+        sub(/s$/, '').
+        chomp('!')
+    end
+  end
+
+  module XMLBuilder
+    def build_xml(xml, name, type, value)
+      if value.kind_of? Array
+        build_array_xml(xml, name, type, value)
+      else
+        build_tag_xml(xml, name, type, value)
+      end
+    end
+
+    def build_array_xml(xml, name, type, value)
+      attrs = {
+        "xmlns:enc" => "http://schemas.xmlsoap.org/soap/encoding/",
+        "xsi:type" => "enc:Array",
+        "enc:arrayType" => "vin:#{name}[#{value.size}]"
+      }
+      xml.tag!(name, attrs) do |x|
+        value.each do |val|
+          build_tag_xml(x, 'item', type, val)
+        end
+      end
+    end
+
+    def build_tag_xml(xml, name, type, value)
+      case value
+      when Hash
+        Vindicia.class(type).new(value).build(xml, name)
+      when SoapObject
+        value.build(xml, name)
+      when NilClass
+        xml.tag!(name, value, {"xsi:nil" => true})
+      else
+        type = type.sub(/^tns/,'vin')
+        xml.tag!(name, value, {"xsi:type" => type})
+      end
+    end
+  end
+
+  module SoapClient
+    include XMLBuilder
+
+    def find(id)
+      self.send(:"fetch_by_merchant_#{name.downcase}_id", id)
+    end
+
+    def method_missing(method, *args)
+      # TODO: verify that this method _is_ a method callable on the wsdl,
+      #       and defer to super if not.
+      method = underscore(method.to_s).to_sym # back compatability from camelCase api
+      out_vars = nil # set up outside variable
+
+      response = soap.request(:wsdl, method) do |soap, wsdl|
+        out_vars = wsdl.arg_list["#{method.to_s.lower_camelcase}_out"]
+
+        soap.namespaces["xmlns:vin"] = Vindicia::NAMESPACE
+        soap.body = begin
+          xml = Builder::XmlMarkup.new
+
+          key = "#{method.to_s.lower_camelcase}_in"
+          wsdl.arg_list[key].zip([Vindicia.auth] + args).each do |arg, data|
+            build_xml(xml, arg['name'], arg['type'], data)
+          end
+
+          xml.target!
+        end
+      end
+
+      values = response.to_hash[:"#{method}_response"]
+      objs = out_vars.map do |var|
+        value = values[underscore(var["name"]).to_sym]
+        Vindicia.coerce(var["name"], var["type"], value)
+      end
+
+      ret = objs.shift
+
+      return [ret] + objs unless objs.first.is_a? SoapObject
+
+      case objs.size
+      when 0
+        ret.request_status = ret
+        ret
+      when 1
+        objs.first.request_status = ret
+        objs.first
+      else
+        objs.first.request_status = ret
+        objs
+      end
+    end
+
+    def name
+      self.to_s.split('::').last
+    end
+
+    def soap
+      @soap ||= begin
+        Savon::Client.new do |wsdl|
+          wsdl.document = Vindicia.wsdl(name)
+          # Test WSDL files contain production endpoints, must override
+          wsdl.endpoint = Vindicia.endpoint
+
+          # Be sure to parse arg lists for revification w/ custom parser
+          def wsdl.parser
+            @parser ||= begin
+              parser = Savon::WSDL::ParserWithArgList.new
+              REXML::Document.parse_stream self.document, parser
+              parser
+            end
+          end
+        end
+      end
+    end
+
+  private
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+
+  class SoapObject
+    include XMLBuilder
+    include Comparable
+    attr_accessor :request_status
+
+    def attributes
+      @attributes ||= Vindicia.xsd(classname).inject({}) do |memo, attr|
+        memo[attr["name"]] = attr["type"]
+        memo["vid"] = attr["type"] if attr["name"] == "VID" # oh, casing
+        memo
+      end
+    end
+
+    def initialize(arg=nil)
+      case arg
+      when String, nil
+        arg = {"merchant#{classname}Id" => arg}
+      when Array
+        arg = Hash[arg]
+      end
+
+      arg.each do |key, value|
+        if key == :type
+          # XML->Hash conversion causes conflict between 'type' metadata
+          # and 'type' data field in CreditCard (+others?)
+          # so extract the value we want.
+          value = [value].flatten.reject{|e|e =~ /:/}.first
+          next if value.nil?
+        end
+        # skip metadata
+        next if [:xmlns, :array_type].include? key
+        type = attributes[camelcase(key.to_s)]
+        cast_as_soap_object(type, value) do |obj|
+          value = obj
+        end
+
+        key = underscore(key) # old camelCase back-compat
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def build(xml, tag)
+      xml.tag!(tag, {"xsi:type" => "vin:#{classname}"}) do |xml|
+        attributes.each do |name, type|
+          next if name == 'vid'
+
+          value = instance_variable_get("@#{underscore(name)}") || instance_variable_get("@#{name}")
+          build_xml(xml, name, type, value)
+        end
+      end
+    end
+    
+    def cast_as_soap_object(type, value)
+      return nil if type.nil? or value.nil?
+      return value unless type =~ /tns:/
+
+      if type =~ /ArrayOf/
+        type = singularize(type.sub('ArrayOf',''))
+
+        if value.kind_of?(Hash) && value[:array_type]
+          key = value.keys - [:type, :array_type, :xmlns]
+          value = value[key.first]
+        end
+        value = [value] unless value.kind_of? Array
+
+        ary = value.map{|e| cast_as_soap_object(type, e) }
+        yield ary if block_given?
+        return ary
+      end
+
+      if klass = Vindicia.class(type)
+        obj = klass.new(value)
+        yield obj if block_given?
+        return obj
+      else
+        value
+      end
+    end
+
+    def classname
+      self.class.to_s.split('::').last
+    end
+
+    def each
+      attributes.each do |attr, type|
+        value = self.send(attr)
+        yield attr, value if value
+      end
+    end
+
+    def key?(k)
+      attributes.key?(k.to_s)
+    end
+
+    def type(*args)
+      # type is deprecated, override so that it does a regular attribute lookup
+      method_missing(:type, *args)
+    end
+
+    def method_missing(method, *args)
+      attr = underscore(method.to_s).to_sym # back compatability from camelCase api
+      key = camelcase(attr.to_s)
+
+      if attributes[key]
+        Vindicia.coerce(key, attributes[key], instance_variable_get("@#{attr}"))
+      else
+        super
+      end
+    end
+
+    # TODO: respond_to?
+
+    def ref
+      key = instance_variable_get("@merchant#{classname}Id")
+      ukey = instance_variable_get("@merchant_#{underscore(classname)}_id")
+      {"merchant#{classname}Id" => ukey || key}
+    end
+
+    def to_hash
+      instance_variables.inject({}) do |result, ivar|
+        name = ivar[1..-1]
+        value = instance_variable_get(ivar)
+        case value
+        when SoapObject
+          value = value.to_hash
+        when Array
+          value = value.map{|e| e.kind_of?(SoapObject) ? e.to_hash : e}
+        end
+        result[name] = value
+        result
+      end
+    end
+
+  private
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def camelcase(underscored_word)
+      underscored_word.gsub(/_(.)/) do |m| m.upcase.sub('_','') end
+    end
+
+    def singularize(type)
+      # Specifically formulated for just the ArrayOf types in Vindicia
+      type.sub(/ies$/, 'y').
+        sub(/([sx])es$/, '\1').
+        sub(/s$/, '')
+    end
+  end
+
+  # API classes
+  class Account           < SoapObject; extend SoapClient end
+  class Activity          < SoapObject; extend SoapClient end
+  class Address           < SoapObject; extend SoapClient end
+  class AutoBill          < SoapObject; extend SoapClient end
+  class BillingPlan       < SoapObject; extend SoapClient end
+  class Chargeback        < SoapObject; extend SoapClient end
+  class Entitlement       < SoapObject; extend SoapClient end
+  class PaymentMethod     < SoapObject; extend SoapClient end
+  class PaymentProvider   < SoapObject; extend SoapClient end
+  class Product           < SoapObject; extend SoapClient end
+  class Refund            < SoapObject; extend SoapClient end
+  class Transaction       < SoapObject; extend SoapClient end
+
+  # customized data classes
+  class Return < SoapObject
+    def code; self.return_code.to_i; end
+    def response; self.return_string; end
+  end
+
+  # Stub data types
+  class ActivityCancellation          < SoapObject ; end
+  class ActivityEmailContact          < SoapObject ; end
+  class ActivityFulfillment           < SoapObject ; end
+  class ActivityLogin                 < SoapObject ; end
+  class ActivityLogout                < SoapObject ; end
+  class ActivityNamedValue            < SoapObject ; end
+  class ActivityNote                  < SoapObject ; end
+  class ActivityPhoneContact          < SoapObject ; end
+  class ActivityTypeArg               < SoapObject ; end
+  class ActivityURIView               < SoapObject ; end
+  class ActivityUsage                 < SoapObject ; end
+  class Authentication                < SoapObject ; end
+  class BillingPlanPeriod             < SoapObject ; end
+  class BillingPlanPrice              < SoapObject ; end
+  class Boleto                        < SoapObject ; end
+  class CancelResult                  < SoapObject ; end
+  class CaptureResult                 < SoapObject ; end
+  class CreditCard                    < SoapObject ; end
+  class DirectDebit                   < SoapObject ; end
+  class ECP                           < SoapObject ; end
+  class ElectronicSignature           < SoapObject ; end
+  class EmailTemplate                 < SoapObject ; end
+  class MerchantEntitlementId         < SoapObject ; end
+  class MetricStatistics              < SoapObject ; end
+  class NameValuePair                 < SoapObject ; end
+  class PayPal                        < SoapObject ; end
+  class SalesTax                      < SoapObject ; end
+  class ScoreCode                     < SoapObject ; end
+  class TaxExemption                  < SoapObject ; end
+  class Token                         < SoapObject ; end
+  class TokenAmount                   < SoapObject ; end
+  class TokenTransaction              < SoapObject ; end
+  class TransactionItem               < SoapObject ; end
+  class TransactionStatus             < SoapObject ; end
+  class TransactionStatusBoleto       < SoapObject ; end
+  class TransactionStatusCreditCard   < SoapObject ; end
+  class TransactionStatusDirectDebit  < SoapObject ; end
+  class TransactionStatusECP          < SoapObject ; end
+  class TransactionStatusPayPal       < SoapObject ; end
+  class WebSession                    < SoapObject ; end
+end

data/spec/authenticate.example.rb

@@ -0,0 +1 @@
+Vindicia.authenticate('login', 'password', :prodtest)

data/spec/vindicia_spec.rb

@@ -0,0 +1,267 @@
+require 'vindicia'
+require 'authenticate'
+
+describe Vindicia::Account do
+  it 'should return a singleton soap wrapper' do
+    a = Vindicia::Account
+    b = Vindicia::Account
+    a.soap.should be_equal(b.soap)
+  end
+  
+  describe '#new' do
+    it 'should handle nil' do
+      Vindicia::Account.new.ref.should == {'merchantAccountId' => nil}
+    end
+    
+    it 'should handle a string' do
+      Vindicia::Account.new('thing').ref.should == {'merchantAccountId' => 'thing'}
+    end
+    
+    it 'should handle a hash' do
+      Vindicia::Account.new(:merchantAccountId => 'thing').ref.should == {'merchantAccountId' => 'thing'}
+    end
+
+    it 'should handle multiple words' do
+      Vindicia::AutoBill.new(:merchantAutoBillId => 'thing').ref.should == {'merchantAutoBillId' => 'thing'}
+    end
+
+    it 'should handle underscored words' do
+      Vindicia::AutoBill.new(:merchant_auto_bill_id => 'thing').ref.should == {'merchantAutoBillId' => 'thing'}
+    end
+  end
+  
+  describe '#update' do
+    it 'should create/update an account' do
+      account, created = Vindicia::Account.update({
+        :merchantAccountId => "bob#{Time.now.to_i}",
+        :name => "bob"
+      })
+      account.VID.should =~ /^[0-9a-f]{40}$/
+    end
+    
+    it 'should accept raw objects' do
+      account, created = Vindicia::Account.update(Vindicia::Account.new({
+        :merchantAccountId => "bob#{Time.now.to_i}",
+        :name => "long"
+      }))
+      account.name.should == "long"
+      account.VID.should =~ /^[0-9a-f]{40}$/
+    end
+
+    it 'should update a name' do
+      account, created = Vindicia::Account.update({
+        :merchantAccountId => '123',
+        :name => 'bob'
+      })
+      account.name.should == 'bob'
+
+      account, created = Vindicia::Account.update({
+        :merchantAccountId => '123',
+        :name => 'sam'
+      })
+      account.name.should == 'sam'
+    end
+  end
+  
+  describe '#find' do
+    it 'should return an account' do
+      name = "bob#{Time.now.to_i}"
+      Vindicia::Account.update({
+        :merchantAccountId => '123',
+        :name => name
+      })
+      account = Vindicia::Account.find('123')
+      account.name.should == name
+    end
+  end
+  
+end
+
+describe Vindicia::SoapObject do
+  it 'should map associated classes' do
+    product = Vindicia::Product.new(
+      :default_billing_plan => {:status => "Active"}
+    )
+    product.default_billing_plan.should be_kind_of(Vindicia::BillingPlan)
+  end
+
+  it 'should deserialze arrays' do
+    plan = Vindicia::BillingPlan.new(
+      :periods => [{
+        :quantity => "1"
+      }]
+    )
+    plan.periods.should be_kind_of(Array)
+    plan.periods.size.should == 1
+    plan.periods.first.should be_kind_of(Vindicia::BillingPlanPeriod)
+  end
+
+  it 'should deserialize arrays from soap' do
+    plan = Vindicia::BillingPlan.new(
+      :status => "Active",
+      :periods => {
+        :periods => {
+          :do_not_notify_first_bill => true,
+          :prices => {
+            :prices => {
+              :type     => "namesp32:BillingPlanPrice",
+              :xmlns    => "",
+              :currency => "USD",
+              :amount   => "49.00",
+              :price_list_name => {:type=>"xsd:string", :xmlns=>""}
+            },
+            :type  => "namesp32:ArrayOfBillingPlanPrices",
+            :xmlns => "",
+            :array_type => "namesp32:BillingPlanPrice[1]"
+          },
+          :type => ["Month", "namesp32:BillingPlanPeriod"],
+          :expire_warning_days => "0",
+          :quantity => "1",
+          :cycles => "0",
+          :xmlns => ""
+        },
+        :type => "namesp32:ArrayOfBillingPlanPeriods",
+        :xmlns => "",
+        :array_type => "namesp32:BillingPlanPeriod[1]"
+      }
+    )
+
+    plan.periods.should be_kind_of(Array)
+    plan.periods.size.should == 1
+    plan.periods.first.should be_kind_of(Vindicia::BillingPlanPeriod)
+  end
+end
+
+describe Vindicia::Product do
+  it 'should look up by merchant id' do
+    product = Vindicia::Product.find('em-2-PREMIUM-USD')
+    product.description.should == 'Premium (49.0 USD)'
+  end
+  
+  it 'should bundle the "Return" status in the Product' do
+    product = Vindicia::Product.find('em-2-PREMIUM-USD')
+    product.request_status.code.should == 200
+  end
+end
+
+describe Vindicia do
+  before :each do
+    # Product, BillingPlan are set up in CashBox by hand
+    account, created = Vindicia::Account.update({
+      :merchantAccountId => Time.now.to_i.to_s,
+      :name => "Integration User #{Time.now.to_i}"
+    })
+    @account, validated = Vindicia::Account.updatePaymentMethod(account.ref, {
+      # Payment Method
+      :type => 'CreditCard',
+      :creditCard => {
+        :account => '4783684405207461',
+        :expirationDate => '201207'
+      },
+      :accountHolderName => 'John Smith',
+      :billingAddress => {
+        :name => 'John Smith',
+        :addr1 => '123 Main St',
+        :city => 'Toronto',
+        :district => 'Ontario',
+        :country => 'Canada',
+        :postalCode => 'M4V 5X7'
+      },
+      :merchantPaymentMethodId => "Purchase.id #{Time.now.to_i}"
+    }, true, 'Validate', nil)
+  end
+  
+  it 'should map associated objects to a Vindicia:: class' do
+    @account.paymentMethods.first.class.should == Vindicia::PaymentMethod
+  end
+
+  it 'should map associated arrays to a Vindicia:: class' do
+    transaction = Vindicia::Transaction.auth({
+      :account                => @account.ref,
+      :merchantTransactionId  => "Purchase.id (#{Time.now.to_i})",
+      :sourcePaymentMethod    => {:VID => @account.paymentMethods.first.VID},
+      :amount                 => 49.00,
+      :transactionItems       => [{:sku => 'sku', :name => 'Established Men Subscription', :price => 49.00, :quantity => 1}]
+    }, 100, false)
+    transaction.request_status.code.should == 200
+
+    transaction.statusLog.first.should be_kind_of(Vindicia::TransactionStatus)
+  end
+
+  describe Vindicia::AutoBill do
+    it 'should create recurring billing' do
+      @product = Vindicia::Product.new('em-2-PREMIUM-USD')
+      @billing = Vindicia::BillingPlan.new('em-2-PREMIUM-USD')
+      autobill, created, authstatus, firstBillDate, firstBillAmount, firstBillingCurrency = \
+      Vindicia::AutoBill.update({
+        :account => @account.ref,
+        :product => @product.ref,
+        :billingPlan => @billing.ref
+      }, 'Fail', true, 100)
+    
+      autobill.request_status.code.should == 200
+    end
+  end
+
+  describe Vindicia::Transaction do
+    describe '#auth' do
+      it 'should auth a purchase' do
+        payment_vid = @account.paymentMethods.first.VID
+        transaction = Vindicia::Transaction.auth({
+          :account                => @account.ref,
+          :merchantTransactionId  => "Purchase.id (#{Time.now.to_i})",
+          :sourcePaymentMethod    => {:VID => payment_vid},
+          :amount                 => 49.00,
+          :transactionItems       => [{:sku => 'sku', :name => 'Established Men Subscription', :price => 49.00, :quantity => 1}]
+          #:divisionNumber                xsd:string
+          #:userAgent                     xsd:string
+          #:sourceMacAddress              xsd:string
+          #:sourceIp                      xsd:string
+          #:billingStatementIdentifier    xsd:string
+        }, 100, false)
+        transaction.request_status.code.should == 200
+      end
+    end
+
+    describe '#capture' do
+      before :each do
+        payment_vid = @account.paymentMethods.first.VID
+        @transaction = Vindicia::Transaction.auth({
+          :account                => @account.ref,
+          :merchantTransactionId  => "Purchase.id (#{Time.now.to_i})",
+          :sourcePaymentMethod    => {:VID => payment_vid},
+          :amount                 => 49.00,
+          :transactionItems       => [{:sku => 'sku', :name => 'Established Men Subscription', :price => 49.00, :quantity => 1}]
+        }, 100, false)
+      end
+      
+      it 'should capture an authorized purchase' do
+        ret, success, fail, results = Vindicia::Transaction.capture([@transaction.ref])
+        success.should == 1
+        results.first.merchantTransactionId.should == @transaction.merchantTransactionId
+        results.first.returnCode.should == 200
+        
+        pending 'a way to force immediate capturing'
+        transaction = Vindicia::Transaction.find(@transaction.merchantTransactionId)
+        transaction.statusLog.status.should == 'Captured'
+      end
+    end
+
+    describe '#authCapture' do
+      it 'should return a captured transaction' do
+        payment_vid = @account.paymentMethods.first.VID
+        transaction = Vindicia::Transaction.authCapture({
+          :account                => @account.ref,
+          :merchantTransactionId  => "Purchase.id (#{Time.now.to_i})",
+          :sourcePaymentMethod    => {:VID => payment_vid},
+          :amount                 => 49.00,
+          :transactionItems       => [{:sku => 'sku', :name => 'Established Men Subscription', :price => 49.00, :quantity => 1}]
+        }, false)
+        transaction.request_status.code.should == 200
+
+        pending 'a way to force immediate capturing'
+        transaction.statusLog.status.should == 'Captured'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: vindicia
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- Jamie Macey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: savon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 8
+        - 2
+        version: 0.8.2
+  type: :runtime
+  version_requirements: *id001
+description: Wrapper interface to Vindicia's SOAP API
+email: jamie@almlabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- Isolate
+- README.md
+- Rakefile
+- VERSION
+- lib/savon_patches.rb
+- lib/vindicia.rb
+- spec/authenticate.example.rb
+- spec/vindicia_spec.rb
+has_rdoc: true
+homepage: http://github.com/almlabs/vindicia
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Wrapper interface to Vindicia's SOAP API
+test_files: 
+- spec/authenticate.example.rb
+- spec/vindicia_spec.rb