samurai 0.2.29 → 0.3.0

data/app/views/application/_transaction.html.erb

@@ -17,7 +17,7 @@
 
   <p><strong>Date / Time:</strong> <%= transaction.created_at %></p>
   <p>
-    <strong>Descriptor:</strong> <%= transaction.descriptor %><br>
+    <strong>Description:</strong> <%= transaction.description %><br>
     <strong>Billing Reference:</strong> <%= transaction.billing_reference %><br>
     <strong>Customer Reference: </strong> <%= transaction.customer_reference %><br>
     <strong>Custom Data: </strong> <%= transaction.custom %><br>
@@ -26,4 +26,4 @@
   <p>
     <strong>AVS Response:</strong> <%= transaction.processor_response.try(:avs_result_code) || 'None' %>
   </p>
-<% end %>
+<% end %>

data/lib/samurai/message.rb

@@ -29,7 +29,7 @@ class Samurai::Message < Samurai::Base
     'error input.merchant_login invalid'      => 'The merchant ID is not valid or active.',
     'error input.store_number invalid'        => 'Invalid Store Number.',
     'error processor.bank_info invalid'       => 'Invalid banking information.',
-    'error processor.transaction not_allowed' => 'Merchant can not accept this card.',
+    'error processor.transaction not_allowed' => 'This transaction type is not allowed.',
     'error processor.transaction type_invalid'    => 'Requested transaction type is not allowed for this card/merchant.',
     'error processor.transaction method_invalid'  => 'The requested transaction could not be performed for this merchant.',
     'error input.amount exceeds_limit'            => 'The maximum transaction amount was exceeded.',
@@ -59,14 +59,17 @@ class Samurai::Message < Samurai::Base
     'error input.card_number too_short'       => 'The card number was too short.',
     'error input.card_number too_long'        => 'The card number was too long.',
     'error input.card_number failed_checksum' => 'The card number was invalid.',
+    'error input.card_number is_invalid'      => 'The card number was invalid.',
     'error input.cvv is_blank'                => 'The CVV was blank.',
     'error input.cvv not_numeric'             => 'The CVV was invalid.',
     'error input.cvv too_short'               => 'The CVV was too short.',
     'error input.cvv too_long'                => 'The CVV was too long.',
     'error input.expiry_month is_blank'       => 'The expiration month was blank.',
     'error input.expiry_month not_numeric'    => 'The expiration month was invalid.',
+    'error input.expiry_month is_invalid'     => 'The expiration month was invalid.',
     'error input.expiry_year is_blank'        => 'The expiration year was blank.',
     'error input.expiry_year not_numeric'     => 'The expiration year was invalid.',
+    'error input.expiry_year is_invalid'      => 'The expiration year was invalid.',
   }
 
   def self.response_mappings

data/lib/samurai/processor.rb

@@ -4,12 +4,13 @@
 # This class represents a Samurai Processor connection
 # It can be used to create purchase & authorize transactions
 class Samurai::Processor < Samurai::Base
-  
+  alias_method :token, :id
+
   # Returns the default processor specified by Samurai.processor_token if you passed it into Samurai.setup_site.
   def self.the_processor
     Samurai::Processor.new(:id => Samurai.processor_token)
   end
-  
+
   # Convenience method that calls the purchase method on the default processor.
   def self.purchase(*args)
     the_processor.purchase(*args)
@@ -19,14 +20,16 @@ class Samurai::Processor < Samurai::Base
   def self.authorize(*args)
     the_processor.authorize(*args)
   end
-  
+
   # Convenience method to authorize and capture a payment_method for a particular amount in one transaction.
   # Parameters:
   #
   # * `payment_method_token`: token identifying the payment method to authorize
   # * `amount`: amount to authorize
   # * `options`: an optional has of additional values to pass in accepted values are:
-  #   * `descriptor`: descriptor for the transaction
+  #   * `description`: description for the transaction
+  #   * `descriptor_name`: dynamic descriptor name field
+  #   * `descriptor_phone`: dynamic descriptor phone field
   #   * `custom`: custom data, this data does not get passed to the processor, it is stored within `api.samurai.feefighters.com` only
   #   * `customer_reference`: an identifier for the customer, this will appear in the processor if supported
   #   * `billing_reference`: an identifier for the purchase, this will appear in the processor if supported
@@ -43,7 +46,9 @@ class Samurai::Processor < Samurai::Base
   # * `amount`: amount to authorize
   #
   # * options: an optional has of additional values to pass in accepted values are:
-  #   * `descriptor`: descriptor for the transaction
+  #   * `description`: description for the transaction
+  #   * `descriptor_name`: dynamic descriptor name field
+  #   * `descriptor_phone`: dynamic descriptor phone field
   #   * `custom`: custom data, this data does not get passed to the processor, it is stored within api.samurai.feefighters.com only
   #   * `customer_reference`: an identifier for the customer, this will appear in the processor if supported
   #   * `billing_reference`: an identifier for the purchase, this will appear in the processor if supported
@@ -52,7 +57,7 @@ class Samurai::Processor < Samurai::Base
   def authorize(payment_method_token, amount, options = {})
     execute(:authorize, options.merge(:payment_method_token => payment_method_token, :amount => amount))
   end
-  
+
   private
 
   # Make the actual ActiveResource POST request, process the response
@@ -77,5 +82,5 @@ class Samurai::Processor < Samurai::Base
       end
     end
   end
-  
-end
+
+end

data/lib/samurai/transaction.rb

@@ -33,13 +33,14 @@ class Samurai::Transaction < Samurai::Base
 
   # Reverse this transaction.  First, tries a void.
   # If a void is unsuccessful, (because the transaction has already settled) perform a credit for the full amount.
-  def reverse(options = {})
+  def reverse(amount = nil, options = {})
     execute(:reverse, {:amount => amount || self.amount}.reverse_merge(options))
   end
 
   def success?
     respond_to?(:processor_response) && processor_response && processor_response.success
   end
+  alias_method :success, :success?
   def failed?
     !success?
   end
@@ -65,11 +66,12 @@ class Samurai::Transaction < Samurai::Base
   # Override base error processing with specific Transaction behavior
   # Examine the `<processor_response><messages>` array, and add an error to the Errors object for each `<message>`
   def process_response_errors
-    if respond_to?(:processor_response) && self.processor_response.respond_to?(:messages)
-      self.processor_response.messages.each do |message|
-        if message.subclass == 'error'
-          self.errors.add message.context, message.description
-        end
+    _messages = []
+    _messages += processor_response.messages if respond_to?(:processor_response) && processor_response.respond_to?(:messages)
+    _messages += payment_method.messages if payment_method
+    _messages.each do |message|
+      if message.subclass == 'error'
+        self.errors.add message.context, message.description
       end
     end
   end
@@ -82,7 +84,9 @@ class Samurai::Transaction < Samurai::Base
       :type => options[:type],
       :payment_method_token => options[:payment_method_token],
       :currency_code => options[:currency_code] || (options[:payment_method_token] && 'USD'), # currency code is only required for payloads that include the PMT
-      :descriptor => options[:descriptor],
+      :description => options[:description],
+      :descriptor_name => options[:descriptor_name],
+      :descriptor_phone => options[:descriptor_phone],
       :custom => options[:custom],
       :customer_reference => options[:customer_reference],
       :billing_reference => options[:billing_reference]
@@ -94,7 +98,8 @@ class Samurai::Transaction < Samurai::Base
   # Setup the Transaction schema for ActiveResource, so that new objects contain empty attributes
   KNOWN_ATTRIBUTES = [
     :amount, :type, :payment_method_token, :currency_code,
-    :descriptor, :custom, :customer_reference, :billing_reference, :processor_response
+    :description, :custom, :customer_reference, :billing_reference, :processor_response,
+    :descriptor_name, :descriptor_phone
   ]
   if [ActiveResource::VERSION::MAJOR, ActiveResource::VERSION::MINOR].compact.join('.').to_f < 3.1
     # If we're using ActiveResource pre-3.1, there's no schema class method, so we resort to some tricks...

data/lib/samurai/version.rb

@@ -1,3 +1,3 @@
 module Samurai
-  VERSION = "0.2.29".freeze
+  VERSION = "0.3.0".freeze
 end

data/spec/lib/payment_method_spec.rb

@@ -1,97 +1,247 @@
 require 'spec_helper'
 
-describe "PaymentMethod actions" do
+describe "PaymentMethod" do
+  before do
+    @params = {
+      :first_name   => "FirstName",
+      :last_name    => "LastName",
+      :address_1    => "123 Main St.",
+      :address_2    => "Apt #3",
+      :city         => "Chicago",
+      :state        => "IL",
+      :zip          => "10101",
+      :card_number  => "4111-1111-1111-1111",
+      :cvv          => "123",
+      :expiry_month => '03',
+      :expiry_year  => "2015",
+    }
+  end
 
-  it "should create a new PaymentMethod using S2S endpoint" do
-    Samurai::PaymentMethod.create(
-        :city => "Chicago",
-        :zip => "53211",
-        :expiry_month => 03,
-        :cvv => "123",
-        :card_number => "4111111111111111",
-        :address_1 => "1240 W Monroe #1",
-        :address_2 => "",
-        :last_name => "harper",
-        :expiry_year => "2015",
-        :first_name => "sean",
-        :state => "IL")
+  describe 'S2S #create' do
+    it 'should be successful' do
+      pm = Samurai::PaymentMethod.create @params
+      Samurai::PaymentMethod.find(pm.token).tap do |pm|
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_true
+        pm.first_name.should  == @params[:first_name]
+        pm.last_name.should   == @params[:last_name]
+        pm.address_1.should   == @params[:address_1]
+        pm.address_2.should   == @params[:address_2]
+        pm.city.should        == @params[:city]
+        pm.state.should       == @params[:state]
+        pm.zip.should         == @params[:zip]
+        pm.last_four_digits.should == @params[:card_number][-4, 4]
+        pm.expiry_month.should  == @params[:expiry_month].to_i
+        pm.expiry_year.should   == @params[:expiry_year].to_i
+      end
+    end
+    describe 'fail on input.card_number' do
+      it 'should return is_blank' do
+        pm = Samurai::PaymentMethod.create @params.merge(:card_number => '')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.card_number'].should == [ 'The card number was blank.' ]
+      end
+      it 'should return too_short' do
+        pm = Samurai::PaymentMethod.create @params.merge(:card_number => '4111-1')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.card_number'].should == [ 'The card number was too short.' ]
+      end
+      it 'should return too_long' do
+        pm = Samurai::PaymentMethod.create @params.merge(:card_number => '4111-1111-1111-1111-11')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.card_number'].should == [ 'The card number was too long.' ]
+      end
+      it 'should return failed_checksum' do
+        pm = Samurai::PaymentMethod.create @params.merge(:card_number => '4111-1111-1111-1234')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.card_number'].should == [ 'The card number was invalid.' ]
+      end
+    end
+    describe 'fail on input.cvv' do
+      it 'should return too_short' do
+        pm = Samurai::PaymentMethod.create @params.merge(:cvv => '1')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.cvv'].should == [ 'The CVV was too short.' ]
+      end
+      it 'should return too_long' do
+        pm = Samurai::PaymentMethod.create @params.merge(:cvv => '111111')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.cvv'].should == [ 'The CVV was too long.' ]
+      end
+      it 'should return not_numeric' do
+        pm = Samurai::PaymentMethod.create @params.merge(:cvv => 'abcd1')
+        pm.is_sensitive_data_valid.should be_false
+        pm.errors['input.cvv'].should == [ 'The CVV was invalid.' ]
+      end
+    end
+    describe 'fail on input.expiry_month' do
+      it 'should return is_blank' do
+        pm = Samurai::PaymentMethod.create @params.merge(:expiry_month => '')
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_false
+        pm.errors['input.expiry_month'].should == [ 'The expiration month was blank.' ]
+      end
+      it 'should return is_invalid' do
+        pm = Samurai::PaymentMethod.create @params.merge(:expiry_month => 'abcd')
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_false
+        pm.errors['input.expiry_month'].should == [ 'The expiration month was invalid.' ]
+      end
+    end
+    describe 'fail on input.expiry_year' do
+      it 'should return is_blank' do
+        pm = Samurai::PaymentMethod.create @params.merge(:expiry_year => '')
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_false
+        pm.errors['input.expiry_year'].should == [ 'The expiration year was blank.' ]
+      end
+      it 'should return is_invalid' do
+        pm = Samurai::PaymentMethod.create @params.merge(:expiry_year => 'abcd')
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_false
+        pm.errors['input.expiry_year'].should == [ 'The expiration year was invalid.' ]
+      end
+    end
   end
 
-  describe 'with errors' do
-    before(:each) do
+  describe 'S2S #update' do
+    before do
       @params = {
-        :city => "Chicago",
-        :zip => "53211",
-        :expiry_month => 03,
-        :cvv => "123",
-        :card_number => "4111111111111111",
-        :address_1 => "1240 W Monroe #1",
-        :address_2 => "",
-        :last_name => "harper",
-        :expiry_year => "2015",
-        :first_name => "sean",
-        :state => "IL",
+        :first_name   => "FirstNameX",
+        :last_name    => "LastNameX",
+        :address_1    => "123 Main St.X",
+        :address_2    => "Apt #3X",
+        :city         => "ChicagoX",
+        :state        => "IL",
+        :zip          => "10101",
+        :card_number  => "5454-5454-5454-5454",
+        :cvv          => "456",
+        :expiry_month => '05',
+        :expiry_year  => "2016",
       }
+      @pm = Samurai::PaymentMethod.find create_payment_method(default_payment_method_params)[:payment_method_token]
     end
-
-    it 'should validate blank card number' do
-      pm = Samurai::PaymentMethod.create @params.merge(:card_number=>'')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.card_number'].should == [ 'The card number was blank.' ]
-    end
-    it 'should validate invalid card number' do
-      pm = Samurai::PaymentMethod.create @params.merge(:card_number=>'abc123')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.card_number'].should == [ 'The card number was invalid.' ]
+    it 'should be successful' do
+      @pm.update_attributes @params
+      Samurai::PaymentMethod.find(@pm.token).tap do |pm|
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_true
+        pm.first_name.should  == @params[:first_name]
+        pm.last_name.should   == @params[:last_name]
+        pm.address_1.should   == @params[:address_1]
+        pm.address_2.should   == @params[:address_2]
+        pm.city.should        == @params[:city]
+        pm.state.should       == @params[:state]
+        pm.zip.should         == @params[:zip]
+        pm.last_four_digits.should == @params[:card_number][-4, 4]
+        pm.expiry_month.should  == @params[:expiry_month].to_i
+        pm.expiry_year.should   == @params[:expiry_year].to_i
+      end
     end
-    it 'should validate short card number' do
-      pm = Samurai::PaymentMethod.create @params.merge(:card_number=>'1234')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.card_number'].should == [ 'The card number was too short.' ]
+    it 'should be successful preserving sensitive data' do
+      _params = @params.merge({
+        :card_number => '****************',
+        :cvv => '***',
+      })
+      @pm.update_attributes _params
+      Samurai::PaymentMethod.find(@pm.token).tap do |pm|
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_true
+        pm.first_name.should  == @params[:first_name]
+        pm.last_name.should   == @params[:last_name]
+        pm.address_1.should   == @params[:address_1]
+        pm.address_2.should   == @params[:address_2]
+        pm.city.should        == @params[:city]
+        pm.state.should       == @params[:state]
+        pm.zip.should         == @params[:zip]
+        pm.last_four_digits.should == '1111'
+        pm.expiry_month.should  == @params[:expiry_month].to_i
+        pm.expiry_year.should   == @params[:expiry_year].to_i
+      end
     end
-    it 'should validate long card number' do
-      pm = Samurai::PaymentMethod.create @params.merge(:card_number=>'41111111111111111')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.card_number'].should == [ 'The card number was too long.' ]
+    describe 'fail on input.card_number' do
+      it 'should return too_short' do
+        @pm.update_attributes @params.merge(:card_number => '4111-1')
+        @pm.is_sensitive_data_valid.should be_false
+        @pm.errors['input.card_number'].should == [ 'The card number was too short.' ]
+      end
+      it 'should return too_long' do
+        @pm.update_attributes @params.merge(:card_number => '4111-1111-1111-1111-11')
+        @pm.is_sensitive_data_valid.should be_false
+        @pm.errors['input.card_number'].should == [ 'The card number was too long.' ]
+      end
+      it 'should return failed_checksum' do
+        @pm.update_attributes @params.merge(:card_number => '4111-1111-1111-1234')
+        @pm.is_sensitive_data_valid.should be_false
+        @pm.errors['input.card_number'].should == [ 'The card number was invalid.' ]
+      end
     end
-    it 'should not validate blank cvv' do
-      pm = Samurai::PaymentMethod.create @params.merge(:cvv=>'')
-      pm.has_errors?.should be_false
-      pm.errors.count.should == 0
+    describe 'fail on input.cvv' do
+      it 'should return too_short' do
+        @pm.update_attributes @params.merge(:cvv => '1')
+        @pm.is_sensitive_data_valid.should be_false
+        @pm.errors['input.cvv'].should == [ 'The CVV was too short.' ]
+      end
+      it 'should return too_long' do
+        @pm.update_attributes @params.merge(:cvv => '111111')
+        @pm.is_sensitive_data_valid.should be_false
+        @pm.errors['input.cvv'].should == [ 'The CVV was too long.' ]
+      end
     end
-    it 'should validate invalid cvv' do
-      pm = Samurai::PaymentMethod.create @params.merge(:cvv=>'abc')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.cvv'].should == [ 'The CVV was invalid.' ]
+    describe 'fail on input.expiry_month' do
+      it 'should return is_blank' do
+        @pm.update_attributes @params.merge(:expiry_month => '')
+        @pm.is_sensitive_data_valid.should be_true
+        @pm.is_expiration_valid.should be_false
+        @pm.errors['input.expiry_month'].should == [ 'The expiration month was blank.' ]
+      end
+      it 'should return is_invalid' do
+        @pm.update_attributes @params.merge(:expiry_month => 'abcd')
+        @pm.is_sensitive_data_valid.should be_true
+        @pm.is_expiration_valid.should be_false
+        @pm.errors['input.expiry_month'].should == [ 'The expiration month was invalid.' ]
+      end
     end
-    it 'should validate short cvv' do
-      pm = Samurai::PaymentMethod.create @params.merge(:cvv=>'1')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.cvv'].should == [ 'The CVV was too short.' ]
+    describe 'fail on input.expiry_year' do
+      it 'should return is_blank' do
+        @pm.update_attributes @params.merge(:expiry_year => '')
+        @pm.is_sensitive_data_valid.should be_true
+        @pm.is_expiration_valid.should be_false
+        @pm.errors['input.expiry_year'].should == [ 'The expiration year was blank.' ]
+      end
+      it 'should return is_invalid' do
+        @pm.update_attributes @params.merge(:expiry_year => 'abcd')
+        @pm.is_sensitive_data_valid.should be_true
+        @pm.is_expiration_valid.should be_false
+        @pm.errors['input.expiry_year'].should == [ 'The expiration year was invalid.' ]
+      end
     end
-    it 'should validate long cvv' do
-      pm = Samurai::PaymentMethod.create @params.merge(:cvv=>'11111')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.cvv'].should == [ 'The CVV was too long.' ]
+  end
+
+  describe '#find' do
+    before do
+      @token = Samurai::PaymentMethod.create(@params).token
     end
-    it 'should validate blank expiry_month' do
-      pm = Samurai::PaymentMethod.create @params.merge(:expiry_month=>'')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.expiry_month'].should == [ 'The expiration month was blank.' ]
+    it 'should be successful' do
+      Samurai::PaymentMethod.find(@token).tap do |pm|
+        pm.is_sensitive_data_valid.should be_true
+        pm.is_expiration_valid.should be_true
+        pm.first_name.should  == @params[:first_name]
+        pm.last_name.should   == @params[:last_name]
+        pm.address_1.should   == @params[:address_1]
+        pm.address_2.should   == @params[:address_2]
+        pm.city.should        == @params[:city]
+        pm.state.should       == @params[:state]
+        pm.zip.should         == @params[:zip]
+        pm.last_four_digits.should == @params[:card_number][-4, 4]
+        pm.expiry_month.should  == @params[:expiry_month].to_i
+        pm.expiry_year.should   == @params[:expiry_year].to_i
+      end
     end
-    it 'should validate blank expiry_year' do
-      pm = Samurai::PaymentMethod.create @params.merge(:expiry_year=>'')
-      pm.has_errors?.should be_true
-      pm.errors.count.should == 1
-      pm.errors['input.expiry_year'].should == [ 'The expiration year was blank.' ]
+    it 'should fail on an invalid token' do
+      lambda do
+        Samurai::PaymentMethod.find('abc123')
+      end.should raise_error(ActiveResource::ResourceNotFound)
     end
   end
 

data/spec/lib/processor_spec.rb

@@ -1,35 +1,194 @@
 require 'spec_helper'
 
-describe "Processor actions" do
+describe "Processor" do
   before :each do
+    @rand = rand(1000)
     @payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
   end
 
-  it "should return an empty processor" do
-    processor = Samurai::Processor.the_processor
-    processor.should_not be_nil
+  describe 'the_processor' do
+    it "should return the default processor" do
+      processor = Samurai::Processor.the_processor
+      processor.should_not be_nil
+      processor.token.should == DEFAULT_OPTIONS[:processor_token]
+    end
   end
 
-  it "should create a new purchase" do
-    purchase = Samurai::Processor.purchase(@payment_method_token, 1.0, :billing_reference=>rand(1000))
-    purchase.processor_response.success.should be_true
-    # FakeWeb.last_request
+  describe 'new processor' do
+    it "should return a processor" do
+      processor = Samurai::Processor.new(:id=>'abc123')
+      processor.should_not be_nil
+      processor.token.should == 'abc123'
+    end
   end
 
-  it "should create a new purchase with tracking data" do
-    purchase = Samurai::Processor.purchase(@payment_method_token, 1.0, {
-      :descriptor => "A test purchase",
-      :custom => "some optional custom data",
-      :billing_reference => "ABC123",
-      :customer_reference => "Customer (123)"
-    })
-    purchase.processor_response.success.should be_true
-    # FakeWeb.last_request
+  describe 'purchase' do
+    it 'should be successful' do
+      purchase = Samurai::Processor.purchase(@payment_method_token, 100.0, {
+        :description => "description",
+        :descriptor_name => "descriptor_name",
+        :descriptor_phone => "descriptor_phone",
+        :custom => "custom_data",
+        :billing_reference => "ABC123#{@rand}",
+        :customer_reference => "Customer (123)",
+      })
+      purchase.success.should be_true
+      purchase.description.should == 'description'
+      purchase.descriptor_name.should == 'descriptor_name'
+      purchase.descriptor_phone.should == 'descriptor_phone'
+      purchase.custom.should == 'custom_data'
+      purchase.billing_reference.should == "ABC123#{@rand}"
+      purchase.customer_reference.should == "Customer (123)"
+    end
+    describe 'failures' do
+      it 'should return processor.transaction - declined' do
+        purchase = Samurai::Processor.purchase(@payment_method_token, 1.02, :billing_reference=>rand(1000))
+        purchase.success.should be_false
+        purchase.errors['processor.transaction'].should == [ 'The card was declined.' ]
+      end
+      it 'should return input.amount - invalid' do
+        purchase = Samurai::Processor.purchase(@payment_method_token, 1.10, :billing_reference=>rand(1000))
+        purchase.success.should be_false
+        purchase.errors['input.amount'].should == [ 'The transaction amount was invalid.' ]
+      end
+    end
+    describe 'cvv responses' do
+      it 'should return processor.cvv_result_code = M' do
+        params = default_payment_method_params.merge('credit_card[cvv]'=>'111')
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.purchase(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.cvv_result_code.should == 'M'
+      end
+      it 'should return processor.cvv_result_code = N' do
+        params = default_payment_method_params.merge('credit_card[cvv]'=>'222')
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.purchase(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.cvv_result_code.should == 'N'
+      end
+    end
+    describe 'avs responses' do
+      it 'should return processor.avs_result_code = Y' do
+        params = default_payment_method_params.merge({
+          'credit_card[address_1]'  => '1000 1st Av',
+          'credit_card[address_2]'  => '',
+          'credit_card[zip]'        => '10101',
+        })
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.purchase(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.avs_result_code.should == 'Y'
+      end
+      it 'should return processor.avs_result_code = Z' do
+        params = default_payment_method_params.merge({
+          'credit_card[address_1]'  => '',
+          'credit_card[address_2]'  => '',
+          'credit_card[zip]'        => '10101',
+        })
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.purchase(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.avs_result_code.should == 'Z'
+      end
+      it 'should return processor.avs_result_code = N' do
+        params = default_payment_method_params.merge({
+          'credit_card[address_1]'  => '123 Main St',
+          'credit_card[address_2]'  => '',
+          'credit_card[zip]'        => '60610',
+        })
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        Samurai::PaymentMethod.find(payment_method_token)
+        purchase = Samurai::Processor.purchase(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.avs_result_code.should == 'N'
+      end
+    end
   end
 
-  it "should create a non-new authorization" do
-    authorization = Samurai::Processor.authorize(@payment_method_token, 1.0)
-    authorization.processor_response.success.should be_true
+  describe 'authorize' do
+    it 'should be successful' do
+      purchase = Samurai::Processor.authorize(@payment_method_token, 100.0, {
+        :description => "description",
+        :descriptor_name => "descriptor_name",
+        :descriptor_phone => "descriptor_phone",
+        :custom => "custom_data",
+        :billing_reference => "ABC123#{@rand}",
+        :customer_reference => "Customer (123)",
+      })
+      purchase.success.should be_true
+      purchase.description.should == 'description'
+      purchase.descriptor_name.should == 'descriptor_name'
+      purchase.descriptor_phone.should == 'descriptor_phone'
+      purchase.custom.should == 'custom_data'
+      purchase.billing_reference.should == "ABC123#{@rand}"
+      purchase.customer_reference.should == "Customer (123)"
+    end
+    describe 'failures' do
+      it 'should return processor.transaction - declined' do
+        authorize = Samurai::Processor.authorize(@payment_method_token, 1.02, :billing_reference=>rand(1000))
+        authorize.success.should be_false
+        authorize.errors['processor.transaction'].should == [ 'The card was declined.' ]
+      end
+      it 'should return input.amount - invalid' do
+        authorize = Samurai::Processor.authorize(@payment_method_token, 1.10, :billing_reference=>rand(1000))
+        authorize.success.should be_false
+        authorize.errors['input.amount'].should == [ 'The transaction amount was invalid.' ]
+      end
+    end
+    describe 'cvv responses' do
+      it 'should return processor.cvv_result_code = M' do
+        params = default_payment_method_params.merge('credit_card[cvv]'=>'111')
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.authorize(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.cvv_result_code.should == 'M'
+      end
+      it 'should return processor.cvv_result_code = N' do
+        params = default_payment_method_params.merge('credit_card[cvv]'=>'222')
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.authorize(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.cvv_result_code.should == 'N'
+      end
+    end
+    describe 'avs responses' do
+      it 'should return processor.avs_result_code = Y' do
+        params = default_payment_method_params.merge({
+          'credit_card[address_1]'  => '1000 1st Av',
+          'credit_card[address_2]'  => '',
+          'credit_card[zip]'        => '10101',
+        })
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.authorize(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.avs_result_code.should == 'Y'
+      end
+      it 'should return processor.avs_result_code = Z' do
+        params = default_payment_method_params.merge({
+          'credit_card[address_1]'  => '',
+          'credit_card[address_2]'  => '',
+          'credit_card[zip]'        => '10101',
+        })
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        purchase = Samurai::Processor.authorize(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.avs_result_code.should == 'Z'
+      end
+      it 'should return processor.avs_result_code = N' do
+        params = default_payment_method_params.merge({
+          'credit_card[address_1]'  => '123 Main St',
+          'credit_card[address_2]'  => '',
+          'credit_card[zip]'        => '60610',
+        })
+        payment_method_token = create_payment_method(params)[:payment_method_token]
+        Samurai::PaymentMethod.find(payment_method_token)
+        purchase = Samurai::Processor.authorize(payment_method_token, 1.00, :billing_reference=>rand(1000))
+        purchase.success.should be_true
+        purchase.processor_response.avs_result_code.should == 'N'
+      end
+    end
   end
 
+
 end

data/spec/lib/transaction_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe "Transaction" do
+  before do
+    @rand = rand(1000)
+    @payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
+  end
+
+  describe 'capture' do
+    describe 'success' do
+      before do
+        @auth = Samurai::Processor.authorize(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        capture = @auth.capture
+        capture.success.should be_true
+      end
+      it 'should be successful for full amount' do
+        capture = @auth.capture(100.0)
+        capture.success.should be_true
+      end
+      it 'should be successful for partial amount' do
+        capture = @auth.capture(50.0)
+        capture.success.should be_true
+      end
+    end
+    describe 'failures' do
+      it 'should return processor.transaction - invalid with declined auth' do
+        auth = Samurai::Processor.authorize(@payment_method_token, 100.02)  # declined auth
+        capture = auth.capture
+        capture.success.should be_false
+        capture.errors['processor.transaction'].should == [ 'This transaction type is not allowed.' ]
+      end
+      it 'should return processor.transaction - declined' do
+        auth = Samurai::Processor.authorize(@payment_method_token, 100.00)
+        capture = auth.capture(100.02)
+        capture.success.should be_false
+        capture.errors['processor.transaction'].should == [ 'The card was declined.' ]
+      end
+      it 'should return input.amount - invalid' do
+        auth = Samurai::Processor.authorize(@payment_method_token, 100.00)
+        capture = auth.capture(100.10)
+        capture.success.should be_false
+        capture.errors['input.amount'].should == [ 'The transaction amount was invalid.' ]
+      end
+    end
+  end
+
+  describe 'reverse' do
+    describe 'on capture' do
+      before do
+        @purchase = Samurai::Processor.purchase(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        reverse = @purchase.reverse
+        reverse.success.should be_true
+      end
+      it 'should be successful for full amount' do
+        reverse = @purchase.reverse(100.0)
+        reverse.success.should be_true
+      end
+      it 'should be successful for partial amount' do
+        reverse = @purchase.reverse(50.0)
+        reverse.success.should be_true
+      end
+    end
+    describe 'on authorize' do
+      before do
+        @authorize = Samurai::Processor.authorize(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        reverse = @authorize.reverse
+        reverse.success.should be_true
+      end
+    end
+    describe 'failures' do
+      it 'should return input.amount - invalid' do
+        purchase = Samurai::Processor.purchase(@payment_method_token, 100.00)
+        reverse = purchase.reverse(100.10)
+        reverse.success.should be_false
+        reverse.errors['input.amount'].should == [ 'The transaction amount was invalid.' ]
+      end
+    end
+  end
+
+  describe 'credit' do
+    describe 'on capture' do
+      before do
+        @purchase = Samurai::Processor.purchase(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        credit = @purchase.credit
+        credit.success.should be_true
+      end
+      it 'should be successful for full amount' do
+        credit = @purchase.credit(100.0)
+        credit.success.should be_true
+      end
+      it 'should be successful for partial amount' do
+        credit = @purchase.credit(50.0)
+        credit.success.should be_true
+      end
+    end
+    describe 'on authorize' do
+      before do
+        @authorize = Samurai::Processor.authorize(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        credit = @authorize.credit
+        credit.success.should be_true
+      end
+    end
+    describe 'failures' do
+      it 'should return input.amount - invalid' do
+        purchase = Samurai::Processor.purchase(@payment_method_token, 100.00)
+        credit = purchase.credit(100.10)
+        credit.success.should be_false
+        credit.errors['input.amount'].should == [ 'The transaction amount was invalid.' ]
+      end
+    end
+  end
+
+  describe 'void' do
+    describe 'on authorized' do
+      before do
+        @authorize = Samurai::Processor.authorize(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        void = @authorize.void
+        void.success.should be_true
+      end
+    end
+    describe 'on captured' do
+      before do
+        @purchase = Samurai::Processor.purchase(@payment_method_token, 100.0)
+      end
+      it 'should be successful' do
+        void = @purchase.void
+        void.success.should be_true
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,5 @@
 require 'rspec'
-require 'ruby-debug'
 require 'pp'
-Debugger.start
-Debugger.settings[:autoeval] = true
-Debugger.settings[:autolist] = 5
-Debugger.settings[:reload_source_on_change] = true
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
@@ -23,13 +18,13 @@ RSpec.configure do |c|
 end
 
 require 'samurai'
-Samurai.options = {
-  :site => SITE, 
+DEFAULT_OPTIONS = {
+  :site => SITE,
   :merchant_key => ENV['merchant_key'] || 'a1ebafb6da5238fb8a3ac9f6',
   :merchant_password => ENV['merchant_password'] || 'ae1aa640f6b735c4730fbb56',
   :processor_token => ENV['processor_token'] || '5a0e1ca1e5a11a2997bbf912'
 }
-
+Samurai.options = DEFAULT_OPTIONS.clone
 
 
 #

data/spec/support/transparent_redirect_helper.rb

@@ -24,7 +24,7 @@ module TransparentRedirectHelper
   end
 
   def default_payment_method_params
-    {
+    @default_payment_method_params ||= {
       'sandbox' => true,
       'redirect_url' => 'http://test.host',
       'merchant_key' => Samurai.merchant_key,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samurai
 version: !ruby/object:Gem::Version
-  version: 0.2.29
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-25 00:00:00.000000000Z
+date: 2011-12-22 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeresource
-  requirement: &2152093380 !ruby/object:Gem::Requirement
+  requirement: &70265074098340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *2152093380
+  version_requirements: *70265074098340
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2152092320 !ruby/object:Gem::Requirement
+  requirement: &70265074097660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2152092320
+  version_requirements: *70265074097660
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152090460 !ruby/object:Gem::Requirement
+  requirement: &70265074096960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *2152090460
+  version_requirements: *70265074096960
 - !ruby/object:Gem::Dependency
   name: fakeweb
-  requirement: &2152089360 !ruby/object:Gem::Requirement
+  requirement: &70265074096580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152089360
+  version_requirements: *70265074096580
 - !ruby/object:Gem::Dependency
   name: ruby-debug19
-  requirement: &2152075280 !ruby/object:Gem::Requirement
+  requirement: &70265074095780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,7 +66,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152075280
+  version_requirements: *70265074095780
 description: If you are an online merchant and using samurai.feefighters.com, this
   gem will make your life easy. Integrate with the samurai.feefighters.com portal
   and process transaction.
@@ -100,11 +100,10 @@ files:
 - lib/samurai/transaction.rb
 - lib/samurai/version.rb
 - samurai.gemspec
-- spec/lib/authorization_spec.rb
 - spec/lib/message_spec.rb
 - spec/lib/payment_method_spec.rb
 - spec/lib/processor_spec.rb
-- spec/lib/purchase_spec.rb
+- spec/lib/transaction_spec.rb
 - spec/spec_helper.rb
 - spec/support/transaction_seed.rb
 - spec/support/transparent_redirect_helper.rb
@@ -128,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.5
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Integration gem for samurai.feefighters.com

data/spec/lib/authorization_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe "processing authorizations" do
-
-  before :each do
-    payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
-    @authorization = Samurai::Processor.authorize(payment_method_token, 1.0, :billing_reference=>rand(1000))
-  end
-
-  it "should create a new authorization transaction" do
-    @authorization.processor_response.success.should be_true
-  end
-
-  it "should find the authorization" do
-    transaction = Samurai::Transaction.find(@authorization.reference_id)
-    transaction.reference_id.should == @authorization.reference_id
-  end
-
-  it "should successfully capture" do
-    capture = @authorization.capture(1.0)
-    capture.processor_response.success.should be_true
-  end
-
-  it "should capture an authorization without specifying an amount" do
-    capture = @authorization.capture
-    capture.amount.should == "#{1.0}"
-    capture.processor_response.success.should be_true
-  end
-
-  it "should partially capture an authorization" do
-    capture = @authorization.capture(BigDecimal('0.5'))
-    capture.amount.should == "#{BigDecimal('0.5')}"
-    capture.processor_response.success.should be_true
-  end
-
-  it "should void an authorization" do
-    void = @authorization.void
-    void.processor_response.success.should be_true
-  end
-
-  it "should credit an authorization for the full amount by default" do
-    credit = @authorization.credit
-    credit.amount.should == "#{BigDecimal('1.0')}"
-    credit.processor_response.success.should be_true
-  end
-
-  it "should partially credit an authorization" do
-    credit = @authorization.credit(BigDecimal('0.5'))
-    credit.amount.should == "#{BigDecimal('0.5')}"
-    credit.processor_response.success.should be_true
-  end
-end

data/spec/lib/purchase_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe "processing purchases" do
-
-  describe 'for a successful transaction' do
-    before :each do
-      @payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
-      @purchase = Samurai::Processor.purchase(@payment_method_token, 1.0, :billing_reference=>rand(1000))
-    end
-
-    it "should process successfully" do
-      @purchase.processor_response.success.should be_true
-    end
-
-    it "should be able to void a recent purchase" do
-      void = @purchase.void
-      void.processor_response.success.should be_true
-    end
-
-    it "should be able to credit a recent purchase" do
-      credit = @purchase.credit
-      credit.processor_response.success.should be_true
-      credit.transaction_type.should == 'Credit'
-    end
-
-    it "should be able to reverse a recent purchase" do
-      reverse = @purchase.reverse
-      reverse.processor_response.success.should be_true
-      reverse.transaction_type.should == 'Credit'
-    end
-
-    it "should be able to reverse a settled purchase" do
-      reverse = @purchase.reverse
-      reverse.processor_response.success.should be_true
-    end
-
-    it "should be able to credit a settled purchase" do
-      credit = @purchase.credit
-      credit.processor_response.success.should be_true
-    end
-  end
-
-  describe 'for a declined transaction' do
-    before :each do
-      @payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
-      @purchase = Samurai::Processor.purchase(@payment_method_token, 1.02)
-    end
-
-    it "should process" do
-      @purchase.processor_response.success.should be_false
-      [@purchase.errors['processor.transaction']].flatten.first.should == 'The card was declined.'
-    end
-  end
-
-
-  describe 'for a invalid card number transaction' do
-    before :each do
-      @payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
-      @purchase = Samurai::Processor.purchase(@payment_method_token, 1.07)
-    end
-
-    it "should process" do
-      @purchase.processor_response.success.should be_false
-      [@purchase.errors['input.card_number']].flatten.first.should == 'The card number was invalid.'
-    end
-  end
-
-  describe 'for a expired card transaction' do
-    before :each do
-      @payment_method_token = create_payment_method(default_payment_method_params)[:payment_method_token]
-      @purchase = Samurai::Processor.purchase(@payment_method_token, 1.08)
-    end
-
-    it "should process" do
-      @purchase.processor_response.success.should be_false
-      [@purchase.errors['input.expiry_month']].flatten.first.should == 'The expiration date month was invalid, or prior to today.'
-      [@purchase.errors['input.expiry_year']].flatten.first.should == 'The expiration date year was invalid, or prior to today.'
-    end
-  end
-
-
-end