nimbleshop_stripe 0.0.10 → 0.0.11

data/app/controllers/nimbleshop_stripe/payments_controller.rb

@@ -3,13 +3,12 @@ module NimbleshopStripe
   class PaymentsController < ::ActionController::Base
 
     def create
-      order             =  Order.find_by_id!(session[:order_id])
+      order             =  Order.find_by_id! session[:order_id]
       token             =  params[:stripeToken]
 
       address_attrs     = order.final_billing_address.to_credit_card_attributes
-      creditcard_attrs  = params[:creditcard].merge(address_attrs)
-      creditcard        = Creditcard.new(creditcard_attrs)
-      creditcard.perform_validations = false
+      creditcard_attrs  = creditcard_params.merge address_attrs
+      creditcard        = Creditcard.new creditcard_attrs
 
       payment_method    = NimbleshopStripe::Stripe.first
       processor         = NimbleshopStripe::Processor.new({order: order, payment_method: payment_method})
@@ -17,7 +16,7 @@ module NimbleshopStripe
       default_action = Shop.current.default_creditcard_action
 
       if processor.send(default_action, token: token)
-        url = nimbleshop_simply.order_path(order)
+        url = nimbleshop_simply.order_path order
         @output = "window.location='#{url}'"
       else
         error = processor.errors.first
@@ -33,6 +32,10 @@ module NimbleshopStripe
 
     end
 
-  end
+    private
 
+    def creditcard_params
+      params.require(:creditcard).permit(:number, :"expires_on(3i)", :"expires_on(2i)", :"expires_on(1i)", :cvv)
+    end
+  end
 end

data/app/controllers/nimbleshop_stripe/stripes_controller.rb

@@ -8,30 +8,16 @@ module NimbleshopStripe
     before_filter :load_payment_method
 
     def update
-      respond_to do |format|
-        if @payment_method.update_attributes(post_params[:stripe])
-          format.js  {
-            flash[:notice] = 'Stripe record was successfully updated'
-            render js: "window.location = '/admin/payment_methods'"
-          }
-        else
-          msg =  @payment_method.errors.full_messages.first
-          error =  %Q[alert("#{msg}")]
-          format.js { render js: error }
-        end
-      end
-    end
+      alert_msg = if @payment_method.update_attributes(post_params[:stripe])
+                    msg = "Record has been updated"
+                    %Q[alert("#{msg}")]
+                  else
+                    msg =  @payment_method.errors.full_messages.first
+                    %Q[alert("#{msg}")]
+                  end
 
-    def destroy
       respond_to do |format|
-        if @payment_method.destroy
-          format.js {
-            flash[:notice] = 'Stripe record was successfully deleted'
-            render js: "window.location = '/admin/payment_methods'"
-          }
-        else
-          format.js { render js: 'Stripe record could not be deleted. Please try again later.' }
-        end
+        format.js { render js: alert_msg }
       end
     end
 

data/app/models/nimbleshop_stripe/stripe.rb

@@ -12,7 +12,7 @@ module NimbleshopStripe
     end
 
     def kapture!(order)
-      processor = NimbleshopAuthorizedotnet::Processor.new(order)
+      processor = NimbleshopAuthorizedotnet::Processor.new order
       processor.kapture
       order.kapture!
     end

data/app/views/nimbleshop_stripe/payments/_new.html.erb

@@ -13,7 +13,7 @@
 </p>
 
 <%= form_for @creditcard, url: nimbleshop_stripe.payment_path(format: :js), remote: true, html: { id: 'stripe-payment-form', class: 'form-horizontal' } do |f| %>
-  <div class='nimbleshop_stripe_umbrella'>
+  <div class='nimbleshop_stripe_umbrella' style="margin-left:-125px;">
     <% if @creditcard.errors.any? %>
       <div class="alert alert-error">
         <ul>
@@ -97,7 +97,11 @@ $(document).ready(function(){
         $.ajax({
           type: 'POST',
           url: $this.attr('action'),
-          data: $this.serializeArray()
+          data: $this.serializeArray(),
+          error: function(){
+            $('[data-behavior~=stripe-submit-button]').attr('value', 'Submit').removeAttr('disabled');
+            alert("Something has gone wrong")
+          }
         });
 
 

data/app/views/nimbleshop_stripe/stripes/_edit.html.erb

@@ -1,31 +1,66 @@
-<div class='payment-method-engine-well'>
-
-  <div>
-    <h2>Stripe</h2>
-    <div class="edit_link">
-      <%= link_to 'Edit', '#', class: 'nimbleshop-payment-method-edit', id: 'nimbleshop-stripe-payment-method-edit' %>
-      <%= link_to nimbleshop_stripe.stripe_path, class: 'nimbleshop-payment-method-delete',
-                                  confirm: 'Do you really want to delete Stripe payment method', method: :delete, remote: true do %>
-          <i class='icon-remove icon-white'></i>
-      <% end %>
-    </div>
+<% payment_method = NimbleshopStripe::Stripe.first %>
 
+<%= content_tag :div, style: 'display:none', data: { behavior: "payment-method-form-#{payment_method.permalink}" } do %>
+  <div style="margin-left:50px;margin-bottom:20px;">
     <%= nimbleshop_stripe_picture_on_admin_payment_methods %>
-
-    <div class='clear'></div>
   </div>
 
-  <%= render partial: '/nimbleshop_stripe/stripes/form' %>
-</div>
+  <%= form_for payment_method,  url: '/nimbleshop_stripe/stripe',
+                                                      remote: true,
+                                                      html: { method: 'put',
+                                                              id: 'nimbleshop-stripe-form',
+                                                              class: 'nimbleshop-payment-method-form form-horizontal'} do |f| %>
+
+    <fieldset>
+      <div class='control-group'>
+        <%= f.label :publishable_key, nil, class: 'control-label' %>
+        <div class='controls'>
+          <%= f.text_field :publishable_key, class: 'span6' %>
+        </div>
+      </div>
+
+      <div class='control-group'>
+        <%= f.label :secret_key, nil, class: 'control-label' %>
+        <div class='controls'>
+          <%= f.text_field :secret_key, class: 'span6' %>
+        </div>
+      </div>
 
-<script>
-  $(function(){
+      <div class='control-group'>
+        <%= f.label :business_name, nil, class: 'control-label' %>
+        <%= link_to '?', '#', 'data-content' => 'Please enter the name of the company as it would appear in the credit card statement. If are not sure what name would appear in the credit card statements then consult your merchant account provider.',
+                          'data-original-title' => 'Business name' %>
+        <div class='controls'>
+          <%= f.text_field :business_name, class: 'span6' %>
+        </div>
+      </div>
 
-    $('#nimbleshop-stripe-payment-method-edit').toggle(function(){
-      $('#nimbleshop-stripe-form-well').show();
-    }, function(){
-      $('#nimbleshop-stripe-form-well').hide();
-    });
+      <div class='control-group'>
+        <div class='controls'>
+          <label class='checkbox'>
+            <%= f.check_box :mode, {}, 'test', 'production' %> Enable test mode
+            <%= link_to '?', '#', class: 'help', 'data-content' => 'In the test mode real credit card numbers are not accepted.',
+                              'data-original-title' => 'Test mode' %>
+          </label>
+        </div>
+      </div>
 
-  })
-</script>
+      <div class='control-group'>
+        <div class='controls'>
+          <label class='checkbox'>
+            <%= f.check_box :ssl, {}, 'enabled', 'disabled' %> Enable SSL requirement
+            <%= link_to '?', '#', class: 'help', 'data-content' => 'Enabling SSL requirement will force the payment page to be on SSL.',
+                              'data-original-title' => 'SSL requirement' %>
+          </label>
+        </div>
+      </div>
+
+    </fieldset>
+
+    <div class='form-actions'>
+      <%= f.submit('Submit', class: 'btn btn-primary') %>
+      &nbsp;
+      <%= link_to 'Disable', main_app.disable_admin_payment_method_path(payment_method), class: 'disable-payment-method-link', method: :put %>
+    </div>
+  <% end %>
+<% end %>

data/lib/nimbleshop_stripe/processor.rb

@@ -5,9 +5,9 @@ module NimbleshopStripe
 
     def initialize(options)
       @errors = []
-      @order = options.fetch(:order)
-      @payment_method = options.fetch(:payment_method)
-      @gateway = ::NimbleshopStripe::Gateway.instance(payment_method)
+      @order = options.fetch :order
+      @payment_method = options.fetch :payment_method
+      @gateway = ::NimbleshopStripe::Gateway.instance payment_method
       ::Stripe.api_key = payment_method.secret_key
     end
 
@@ -18,8 +18,7 @@ module NimbleshopStripe
     end
 
     def do_authorize(options = {})
-      #Stripe does not support authorize operation
-      do_purchase(options)
+      do_purchase options
     end
 
     # Creates purchase for the order amount.
@@ -33,53 +32,42 @@ module NimbleshopStripe
     #
     def do_purchase(options = {})
       options.symbolize_keys!
-      options.assert_valid_keys(:token)
+      options.assert_valid_keys :token
 
-      token = options[:token]
+      token = options.fetch :token
 
       response = gateway.purchase(order.total_amount_in_cents, token)
-      token_response = ::Stripe::Token.retrieve(token)
-
-      record_transaction(response, 'purchased',
-                                    fingerprint: token_response.card.fingerprint,
-                                    livemode: token_response.livemode,
-                                    card_number: "XXXX-XXXX-XXXX-#{token_response.card.last4}",
-                                    cardtype: token_response.card.type.downcase,
-                                    transaction_gid: token_response.id)
 
       if response.success?
+        # record transaction only if the operation was a success. Because if the operation was a failure then
+        # getting Token.retrieve will throw exception
+        ::Nimbleshop::PaymentTransactionRecorder.new(payment_transaction_recorder_hash(response, token)).record
+
         order.update_attributes(payment_method: payment_method)
         order.purchase!
       else
         Rails.logger.info response.params['error']['message']
         @errors << 'Credit card was declined. Please try again!'
-        return false
       end
-    end
 
-    # Voids the previously authorized transaction.
-    #
-    # === Options
-    #
-    # * <tt>:transaction_gid</tt> -- transaction_gid is the transaction id returned by the gateway. This is a required field.
-    #
-    # This method returns false if void fails. Error messages are in <tt>errors</tt> array.
-    # If void succeeds then <tt>order.void</tt> is invoked.
-    #
-    def do_void(options = {})
-      options.symbolize_keys!
-      options.assert_valid_keys(:transaction_gid)
-      transaction_gid = options[:transaction_gid]
+      response.success?
+    end
 
-      response = gateway.void(transaction_gid, {})
-      record_transaction(response, 'voided')
+    def payment_transaction_recorder_hash(response, token)
+      token_response = ::Stripe::Token.retrieve token
+
+      {  response: response,
+         order: order,
+         operation: :purchased,
+         transaction_gid: response.authorization,
+         metadata: {  fingerprint: token_response.card.fingerprint,
+                      livemode: token_response.livemode,
+                      card_number: "XXXX-XXXX-XXXX-#{token_response.card.last4}",
+                      cardtype: token_response.card.type.downcase }}
+    end
 
-      if response.success?
-        order.void
-      else
-        @errors << "Void operation failed"
-        false
-      end
+    def do_void(options = {})
+      raise 'Stripe does not support void operation'
     end
 
     # Refunds the given transaction.
@@ -93,41 +81,21 @@ module NimbleshopStripe
     #
     def do_refund(options = {})
       options.symbolize_keys!
-      options.assert_valid_keys(:transaction_gid, :card_number)
+      options.assert_valid_keys :transaction_gid, :card_number
 
-      transaction_gid      = options[:transaction_gid]
-      card_number = options[:card_number]
+      transaction_gid      = options.fetch :transaction_gid
+      card_number = options.fetch :card_number
 
       response = gateway.refund(order.total_amount_in_cents, transaction_gid, card_number: card_number)
-      record_transaction(response, 'refunded')
 
       if response.success?
+        ::Nimbleshop::PaymentTransactionRecorder.new(transaction_gid: response.authorization, response: response, operation: :refunded, order: order).record
         order.refund
       else
-        @errors << "Refund failed"
-        false
+        @errors << "Refund operation failed"
       end
 
-    end
-
-    def record_transaction(response, operation, additional_options = {}) # :nodoc:
-      transaction_gid = additional_options.fetch(:transaction_gid)
-
-      options = { operation:          'capture',
-                  params:             response.params,
-                  success:            true,
-                  metadata:           additional_options,
-                  transaction_gid:    transaction_gid }
-
-      if response.success?
-        options.update(amount: order.total_amount_in_cents)
-      end
-
-      order.payment_transactions.create(options)
-    end
-
-    def valid_card?(creditcard) # :nodoc:
-      true
+      response.success?
     end
 
   end

data/lib/tasks/nimbleshop_stripe_tasks.rake

@@ -14,7 +14,7 @@ namespace :nimbleshop_stripe do
   task :load_record => :environment do
 
     if NimbleshopStripe::Stripe.find_by_permalink('stripe')
-      puts "Stripe record already exists"
+      Rails.logger.debug "Stripe record already exists"
     else
       NimbleshopStripe::Stripe.create!(
         {
@@ -25,7 +25,7 @@ namespace :nimbleshop_stripe do
           permalink: 'stripe',
           description: %Q[<p> Stripe is a payment gateway service provider allowing merchants to accept credit card payments. </p>]
         })
-        puts "Stripe record was successfuly created"
+        Rails.logger.debug "Stripe record was successfuly created"
     end
   end
 end

data/test/unit/payment_method_test.rb

@@ -1,21 +1,21 @@
 require "test_helper"
 
-class PaymentMethodAuthorizeNetTest < ActiveSupport::TestCase
+class PaymentMethodStripeTest < ActiveSupport::TestCase
 
   test "validations" do
-    pm = NimbleshopAuthorizedotnet::Authorizedotnet.new(name: 'Authorize.net', description: 'this is description')
+    pm = NimbleshopStripe::Stripe.new(name: 'Stripe', description: 'this is description')
     refute pm.valid?
-    expected = ["Business name can't be blank", "Login can't be blank", "Transaction key can't be blank"]
+    expected = ["Business name can't be blank", "Publishable key can't be blank", "Secret key can't be blank"].sort
     assert_equal expected, pm.errors.full_messages.sort
   end
 
   test "should save the record" do
-    pm = NimbleshopAuthorizedotnet::Authorizedotnet.new(name: 'Authorize.net', description: 'this is description')
-    pm.login_id = 'FWERSDEED093d'
-    pm.transaction_key = 'SDFSDFSFSF423433SDFSFSSFSFSF334'
+    pm = NimbleshopStripe::Stripe.new(name: 'Stripe', description: 'this is description')
+    pm.publishable_key = 'FWERSDEED093d'
+    pm.secret_key = 'SDFSDFSFSF423433SDFSFSSFSFSF334'
     pm.business_name = 'BigBinary LLC'
     assert pm.save
-    assert_match /authorize-net/, pm.permalink
+    assert_match /stripe/, pm.permalink
   end
 
 end

data/test/unit/processor_test.rb

@@ -1,241 +1,77 @@
 require 'test_helper'
 
 module Processor
-  class NimbleshopAuthorizeNetAuthorizeTest < ActiveRecord::TestCase
+  class NimbleshopStripePurchaseTest < ActiveRecord::TestCase
+
+    TOKEN = 'tok_0eLPgnVqeoGqWd'
+
     setup do
-      payment_method     = NimbleshopAuthorizedotnet::Authorizedotnet.first
+      payment_method     = NimbleshopStripe::Stripe.first
+      assert_equal 'test', payment_method.mode.to_s
+      assert_equal 'Stripe', payment_method.name
       @order = create(:order)
       @order.stubs(:total_amount).returns(100.48)
-      @processor = NimbleshopAuthorizedotnet::Processor.new(order: @order, payment_method: payment_method)
+      @processor = NimbleshopStripe::Processor.new(order: @order, payment_method: payment_method)
     end
 
-    test 'when authorization succeeds' do
-      creditcard = build(:creditcard)
+    test 'when purchase succeeds' do
+      transactions_count = @order.payment_transactions.count
 
-      playcasette('authorize.net/authorize-success') do
-        assert_equal true, @processor.authorize(creditcard: creditcard)
+      playcasette('stripe/purchase-success') do
+        assert_equal true, @processor.purchase(token: TOKEN)
       end
 
       @order.reload
 
       transaction = @order.payment_transactions.last
-      assert_equal 'authorized', transaction.operation
-      assert_equal true, transaction.success
-      assert_equal NimbleshopAuthorizedotnet::Authorizedotnet.first, @order.payment_method
-      assert       @order.authorized?
-    end
-
-    test 'authorization fails when credit card number is not entered' do
-      creditcard = build(:creditcard, number: nil)
-      assert_equal false, @processor.authorize(creditcard: creditcard)
-      assert_equal 'Please enter credit card number', @processor.errors.first
-
-      @order.reload
-
-      assert_nil    @order.payment_method
-      assert        @order.abandoned?
+      assert_equal 'purchased', transaction.operation
+      assert_equal NimbleshopStripe::Stripe.first, @order.payment_method
+      assert       @order.purchased?
+      assert_equal transactions_count + 1, @order.payment_transactions.count
+      assert_equal 'ch_0eLWIXVivQp0KE', transaction.transaction_gid
     end
 
-    test 'authorization fails with invalid credit card number' do
-      creditcard = build(:creditcard, number: 2)
+    test 'purchase fails when  token number is not entered' do
+      transactions_count = @order.payment_transactions.count
 
-      playcasette('authorize.net/authorize-failure') do
-        assert_equal false, @processor.authorize(creditcard: creditcard)
-        assert_equal 'Credit card was declined. Please try again!', @processor.errors.first
+      playcasette('stripe/purchase-failure') do
+        assert_equal false, @processor.purchase(token: 'xxxxxx')
+        assert_equal "Credit card was declined. Please try again!", @processor.errors.first
       end
 
       @order.reload
 
       assert_nil    @order.payment_method
       assert        @order.abandoned?
+      assert_equal transactions_count, @order.payment_transactions.count
     end
   end
 
-  class AuthorizeNetCaptureTest < ActiveRecord::TestCase
-    setup do
-      payment_method     = NimbleshopAuthorizedotnet::Authorizedotnet.first
-      @order     = create(:order, payment_method: payment_method)
-      @order.stubs(:total_amount).returns(100.48)
-      @processor = NimbleshopAuthorizedotnet::Processor.new(order: @order, payment_method: payment_method)
-      creditcard = build(:creditcard)
-
-      playcasette('authorize.net/authorize-success') do
-        @processor.authorize(creditcard: creditcard)
-      end
-
-      @tsx_id = @order.payment_transactions.last.transaction_gid
-    end
-
-    test 'when capture succeeds' do
-      creditcard = build(:creditcard)
-
-      playcasette('authorize.net/capture-success') do
-        assert_equal true, @processor.kapture(transaction_gid: @tsx_id)
-      end
+  class NimbleshopStripeRefundTest < ActiveRecord::TestCase
 
-      @order.reload
-      transaction = @order.payment_transactions.last
-      assert_equal  'captured', transaction.operation
-      assert_equal  true, transaction.success
-      assert        @order.purchased?
-    end
-
-    test 'when capture fails' do
-      creditcard = build(:creditcard, number: 2)
-
-      playcasette('authorize.net/capture-failure') do
-        assert_equal false, @processor.kapture(transaction_gid: @tsx_id)
-        assert_equal 'Capture request failed', @processor.errors.first
-      end
+    TOKEN = 'tok_0g3n2A0IthHLzf'
 
-      @order.reload
-
-      transaction = @order.payment_transactions.last
-
-      assert_equal false, transaction.success
-      assert_equal 'captured', transaction.operation
-      assert       @order.authorized?
-    end
-  end
-
-  class AuthorizeNetRefundTest < ActiveRecord::TestCase
     setup do
-      payment_method     = NimbleshopAuthorizedotnet::Authorizedotnet.first
+      payment_method     = NimbleshopStripe::Stripe.first
+      assert_equal 'test', payment_method.mode.to_s
+      assert_equal 'Stripe', payment_method.name
       @order = create(:order)
       @order.stubs(:total_amount).returns(100.48)
-      @processor = NimbleshopAuthorizedotnet::Processor.new(order: @order, payment_method: payment_method)
-      creditcard = build(:creditcard)
-
-      playcasette('authorize.net/purchase-success') do
-        assert_equal true, @processor.purchase(creditcard: creditcard)
+      @processor = NimbleshopStripe::Processor.new(order: @order, payment_method: payment_method)
+      playcasette('stripe/purchase-success-for-refund') do
+        assert_equal true, @processor.purchase(token: TOKEN)
       end
-
-      assert @order.reload.purchased?
-
       @transaction = @order.payment_transactions.last
     end
 
     test 'when refund succeeds' do
-
-      playcasette('authorize.net/refund-success') do
-        assert_equal true, @processor.refund(transaction_gid:   @transaction.transaction_gid,
+      assert_equal 'ch_0g3pxaKlHho2cr', @transaction.transaction_gid
+      playcasette('stripe/refund-success') do
+        assert_equal true, @processor.refund(transaction_gid:   'ch_0g3pxaKlHho2cr',
                                              card_number:       @transaction.metadata[:card_number])
       end
-
       @order.reload
-      transaction = @order.payment_transactions.last
-
-      assert_equal  'refunded', transaction.operation
-      assert_equal  true, transaction.success
-      assert_equal  NimbleshopAuthorizedotnet::Authorizedotnet.first, @order.payment_method
-      assert        @order.refunded?
-    end
-
-    test 'when refund fails' do
-
-      playcasette('authorize.net/refund-failure') do
-        assert_equal false, @processor.refund(transaction_gid: @transaction.transaction_gid, card_number: '1234')
-      end
-
-      @order.reload
-
-      transaction = @order.payment_transactions.last
-
-      assert_equal 'refunded', transaction.operation
-      assert_equal false, transaction.success
-    end
-  end
-
-  class AuthorizeNetVoidTest < ActiveRecord::TestCase
-    setup do
-      payment_method     = NimbleshopAuthorizedotnet::Authorizedotnet.first
-      @order = create(:order)
-      @order.stubs(:total_amount).returns(100.48)
-      @processor = NimbleshopAuthorizedotnet::Processor.new(order: @order, payment_method: payment_method)
-      creditcard = build(:creditcard)
-
-      playcasette('authorize.net/authorize-success') do
-        assert_equal true, @processor.authorize(creditcard: creditcard)
-      end
-
-      @tsx_id = @order.payment_transactions.last.transaction_gid
-    end
-
-    test 'when capture succeeds' do
-      playcasette('authorize.net/void-success') do
-        assert_equal true, @processor.void(transaction_gid: @tsx_id)
-      end
-
-      @order.reload
-      transaction = @order.payment_transactions.last
-
-      assert_equal  'voided', transaction.operation
-      assert_equal  true, transaction.success
-      assert_equal  NimbleshopAuthorizedotnet::Authorizedotnet.first, @order.payment_method
-      assert        @order.voided?
-    end
-
-    test 'when capture fails' do
-      playcasette('authorize.net/void-failure') do
-        assert_equal false, @processor.void(transaction_gid: @tsx_id)
-      end
-
-      @order.reload
-
-      transaction = @order.payment_transactions.last
-
-      assert_equal 'voided', transaction.operation
-      assert_equal false, transaction.success
-    end
-  end
-
-  class AuthorizeNetPurchaseTest < ActiveRecord::TestCase
-    setup do
-      payment_method     = NimbleshopAuthorizedotnet::Authorizedotnet.first
-      @order = create(:order)
-      @order.stubs(:total_amount).returns(100.48)
-      @processor = NimbleshopAuthorizedotnet::Processor.new(order: @order, payment_method: payment_method)
-    end
-
-    test 'when purchase succeeds' do
-      creditcard = build(:creditcard)
-
-      playcasette('authorize.net/purchase-success') do
-        assert_equal true, @processor.purchase(creditcard: creditcard)
-      end
-
-      @order.reload
-
-      transaction = @order.payment_transactions.last
-      assert_equal  'purchased', transaction.operation
-      assert_equal  true, transaction.success
-      assert        @order.purchased?
-    end
-
-    test 'purchase fails when credit card number is not entered ' do
-      creditcard = build(:creditcard, number: nil)
-
-      playcasette('authorize.net/purchase-failure') do
-        assert_equal false, @processor.purchase(creditcard: creditcard)
-        assert_equal 'Please enter credit card number', @processor.errors.first
-      end
-
-      assert       @order.abandoned?
-    end
-
-    test 'purchase fails when invalid credit card number is entered' do
-      creditcard = build(:creditcard, number: 2)
-
-      playcasette('authorize.net/purchase-failure') do
-        assert_equal false, @processor.purchase(creditcard: creditcard)
-        assert_equal 'Credit card was declined. Please try again!', @processor.errors.first
-      end
-
-      transaction = @order.payment_transactions.last
-
-      assert_equal false, transaction.success
-      assert_equal 'purchased', transaction.operation
-      assert       @order.abandoned?
+      assert       @order.refunded?
     end
   end
 end