spree_unified_payment 1.0.0

data/spec/mailers/transaction_notification_mailer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Spree::TransactionNotificationMailer do
+  let(:card_transaction) { mock_model(UnifiedPayment::Transaction, :status => 'successful', :xml_response => '') }
+  let(:order) { mock_model(Spree::Order) }
+  let(:user) { mock_model(Spree::User) }
+
+  before do
+    @email = "test_user@westaycute.com"
+    order.stub(:line_items).and_return([])
+    card_transaction.stub(:order).and_return(order)
+    card_transaction.stub(:user).and_return(user)
+    user.stub(:email).and_return(@email)
+  end
+  describe 'fetches info from card_transaction' do
+    it { card_transaction.should_receive(:order).and_return(order) }
+    it { card_transaction.should_receive(:user).and_return(order) }
+    it { user.should_receive(:email).and_return(@email) }
+    it { card_transaction.should_receive(:status).and_return(card_transaction.status) }
+    it { card_transaction.should_receive(:xml_response).and_return('') }
+
+    after do
+      Spree::TransactionNotificationMailer.send_mail(card_transaction)
+    end
+  end
+
+  context 'when xml response is a message' do
+    before do 
+      card_transaction.stub(:xml_response).and_return("<Message><OrderStatus>Approved</OrderStatus></Message>")
+    end
+
+    it { Hash.should_receive(:from_xml).with(card_transaction.xml_response).and_return({'Message' => { 'OrderStatus' => 'Approved'} } ) }
+    after do
+      Spree::TransactionNotificationMailer.send_mail(card_transaction)
+    end
+  end
+
+  context 'when xml response is not a message' do
+    before do 
+      card_transaction.stub(:xml_response).and_return("<NoMessage></NoMessage>")
+    end
+
+    it { Hash.should_not_receive(:from_xml) }
+    after do
+      Spree::TransactionNotificationMailer.send_mail(card_transaction)
+    end
+  end
+end

data/spec/models/spree/order_decorator_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe Spree::Order do
+  let(:user) { mock_model(Spree::User) }
+  before(:each) do
+    @order = Spree::Order.create!
+  end
+
+  it { should have_many :unified_transactions }
+
+  describe "#pending_card_transaction" do
+    before do
+      UnifiedPayment::Transaction.any_instance.stub(:wallet_transaction).and_return(true)
+      UnifiedPayment::Transaction.any_instance.stub(:enqueue_expiration_task).and_return(true)
+      UnifiedPayment::Transaction.any_instance.stub(:assign_attributes_using_xml).and_return(true)
+      UnifiedPayment::Transaction.any_instance.stub(:complete_order).and_return(true)
+      UnifiedPayment::Transaction.any_instance.stub(:notify_user_on_transaction_status).and_return(true)
+      @successful_card_transaction = @order.unified_transactions.create!(:status => 'successful', :payment_transaction_id => '1234')
+      @pending_card_transaction = @order.unified_transactions.create!(:status => 'pending', :payment_transaction_id => '1234')
+    end
+
+    it { @order.pending_card_transaction.should eq(@pending_card_transaction) }
+  end
+  
+  describe '#reserve_stock' do
+    before do
+      @pending_inventory_unit = mock_model(Spree::InventoryUnit, :pending => true)
+      @order_shipment_with_pending_units = mock_model(Spree::Shipment)
+      @order_shipment_with_pending_units.stub(:finalize!).and_return(true)
+      @order_shipment_with_pending_units.stub(:update!).with(@order).and_return(true)
+      @order_shipment_with_pending_units.stub(:inventory_units).and_return([@pending_inventory_unit])
+
+      @unpending_inventory_unit = mock_model(Spree::InventoryUnit, :pending => false)
+      @order_shipment_without_pending_units = mock_model(Spree::Shipment)
+      @order_shipment_without_pending_units.stub(:inventory_units).and_return([@unpending_inventory_unit])
+      @order.stub(:shipments).and_return([@order_shipment_with_pending_units, @order_shipment_without_pending_units])
+    end
+
+    it { @order.should_receive(:shipments).and_return([@order_shipment_with_pending_units, @order_shipment_without_pending_units]) }
+    it { @order_shipment_with_pending_units.should_receive(:update!).with(@order).and_return(true) }
+    it { @order_shipment_with_pending_units.should_receive(:finalize!).and_return(true) }
+    it { @order_shipment_without_pending_units.should_not_receive(:update!).with(@order) }
+    it { @order_shipment_without_pending_units.should_not_receive(:finalize!) }
+
+    after do
+      @order.reserve_stock
+    end
+  end
+
+  describe '#create_proposed_shipments' do
+    before do
+      @order_shipment = mock_model(Spree::Shipment)
+      inventory_unit = mock_model(Spree::InventoryUnit, :pending => false)
+      @order_shipment.stub(:inventory_units).and_return([inventory_unit])
+      @order_shipment.stub(:cancel).and_return(true)
+
+      @pending_order_shipment = mock_model(Spree::Shipment)
+      pending_inventory_unit = mock_model(Spree::InventoryUnit, :pending => true)
+      @pending_order_shipment.stub(:inventory_units).and_return([pending_inventory_unit])
+
+      @shipments = [@order_shipment, @pending_order_shipment]
+      @shipments.stub(:destroy_all).and_return(true)
+      @order.stub(:shipments).and_return(@shipments)
+    end
+
+    it { @order_shipment.should_receive(:cancel).and_return(true) }
+    it { @pending_order_shipment.should_not_receive(:cancel) }
+    it { @shipments.should_receive(:destroy_all).and_return(true) }
+
+    after do
+      @order.create_proposed_shipments
+    end
+  end
+
+  
+  describe '#release_inventory' do
+    before do
+      @pending_inventory_unit = mock_model(Spree::InventoryUnit, :pending => true)
+      @order_shipment_with_pending_units = mock_model(Spree::Shipment)
+      @order_shipment_with_pending_units.stub(:finalize!).and_return(true)
+      @order_shipment_with_pending_units.stub(:update!).with(@order).and_return(true)
+      @order_shipment_with_pending_units.stub(:inventory_units).and_return([@pending_inventory_unit])
+
+      @unpending_inventory_unit = mock_model(Spree::InventoryUnit, :pending => false)
+      @order_shipment_without_pending_units = mock_model(Spree::Shipment)
+      @order_shipment_without_pending_units.stub(:inventory_units).and_return([@unpending_inventory_unit])
+      @order_shipment_without_pending_units.stub(:cancel).and_return(true)
+      @order.stub(:shipments).and_return([@order_shipment_with_pending_units, @order_shipment_without_pending_units])
+    end
+
+    it { @order_shipment_without_pending_units.should_receive(:cancel).and_return(true) }
+    it { @order_shipment_with_pending_units.should_not_receive(:cancel) }
+
+    after do
+      @order.release_inventory
+    end
+  end
+
+  describe '#reason_if_cant_pay_by_card' do
+    before do
+      @order.total = 100
+      # @order.stub(:completed?).and_return(false)
+    end
+
+    context 'total is 0' do
+      before { @order.total = 0 }
+      it { @order.reason_if_cant_pay_by_card.should eq('Order Total is invalid') }
+    end
+
+    context 'order is completed' do
+      before { @order.stub(:completed?).and_return(true) }
+      it { @order.reason_if_cant_pay_by_card.should eq('Order already completed') }
+    end
+
+    context 'order has insufficient stock lines' do
+      before { @order.stub(:insufficient_stock_lines).and_return([0]) }
+      it { @order.reason_if_cant_pay_by_card.should eq('An item in your cart has become unavailable.') }
+    end
+  end
+
+  describe 'finalize!' do
+    before do
+      @order.stub(:user_id).and_return(user.id)
+      @adjustment = mock_model(Spree::Adjustment)
+      @order.stub(:adjustments).and_return([@adjustment])
+      @adjustment.stub(:update_column).with("state", "closed").and_return(true)
+      @order.stub(:save).and_return(true)
+      @order_updater = Spree::OrderUpdater.new(@order)
+      @order.stub(:updater).and_return(@order_updater)
+      @order_updater.stub(:update_shipment_state).and_return(true)
+      @order_updater.stub(:update_payment_state).and_return(true)
+      @order_updater.stub(:run_hooks).and_return(true)
+      @state_changes = []
+      @state_changes.stub(:create).with({:previous_state=>'confirm', :next_state=>"complete", :name=>"order", :user_id=>user.id}, {:without_protection=>true}).and_return(true)
+      
+      @order.stub(:state_changes).and_return(@state_changes)
+      @order.stub(:previous_states).and_return([:delivery, :payment, :confirm])
+      @order.stub(:reserve_stock).and_return(true)
+    end
+
+    it 'updates completed at' do
+      @order.completed_at.should be_nil
+      @order.finalize!
+      @order.reload.completed_at.should_not be_nil
+      @order.stub(:deliver_order_confirmation_email).and_return(true)
+    end
+
+    it 'udpates adjustments' do
+      @adjustment.should_receive(:update_column).with("state", "closed").and_return(true)
+      @order.finalize!
+    end
+
+    it 'saves self' do
+      @order.should_receive(:save).and_return(true)
+      @order.finalize!
+    end
+
+    it 'updates shipment states' do
+      @order_updater.should_receive(:update_shipment_state).and_return(true)
+      @order.finalize!
+    end
+
+    it 'updates payment states' do
+      @order_updater.should_receive(:update_payment_state).and_return(true)
+      @order.finalize!
+    end
+
+    it 'run hooks through updater' do
+      @order_updater.should_receive(:run_hooks).and_return(true)
+      @order.finalize!
+    end
+
+    it 'sends email' do
+      @order.should_receive(:deliver_order_confirmation_email).and_return(true)
+      @order.finalize!
+    end
+
+    it 'stores state changes' do
+      @state_changes.should_receive(:create).with({:previous_state=>'confirm', :next_state=>"complete", :name=>"order", :user_id=>user.id}, {:without_protection=>true}).and_return(true)
+      @order.finalize!
+    end
+
+    context 'when orders last state was confirm' do
+      before do
+        @order.stub(:previous_states).and_return([:delivery, :payment, :confirm])
+      end
+
+      it 'does not reserve stock' do
+        @order.should_not_receive(:reserve_stock)
+        @order.finalize!
+      end
+    end
+
+    context 'when orders last state was not confirm' do
+      before do
+        @order.stub(:previous_states).and_return([:delivery, :payment])
+        @state_changes.stub(:create).with({:previous_state=>"payment", :next_state=>"complete", :name=>"order", :user_id=>user.id}, {:without_protection=>true}).and_return(true)
+      end
+
+      it 'reserves stock' do
+        @order.should_receive(:reserve_stock)
+        @order.finalize!
+      end
+    end
+  end
+end

data/spec/models/spree/payment_method/unified_payment_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Spree::PaymentMethod::UnifiedPaymentMethod do
+  let(:pending_payment) { mock_model(Spree::Payment, :state => 'pending') }
+  let(:complete_payment) { mock_model(Spree::Payment, :state => 'complete') }
+  let(:void_payment) { mock_model(Spree::Payment, :state => 'void') }
+  before { @unified_payment = Spree::PaymentMethod::UnifiedPaymentMethod.new }
+  it { @unified_payment.actions.should eq(["capture", "void"]) }
+  it { @unified_payment.can_capture?(pending_payment).should be_true }
+  it { @unified_payment.can_capture?(complete_payment).should be_false }
+  it { @unified_payment.can_void?(pending_payment).should be_true }
+  it { @unified_payment.can_void?(void_payment).should be_false }
+  it { @unified_payment.source_required?.should be_false }
+  it { @unified_payment.payment_profiles_supported?.should be_true }
+
+  it 'voids a payment' do
+    ActiveMerchant::Billing::Response.should_receive(:new).with(true, "", {}, {}).and_return(true)
+    @unified_payment.void
+  end
+
+  it 'captures a payment' do
+    ActiveMerchant::Billing::Response.should_receive(:new).with(true, "", {}, {}).and_return(true)
+    @unified_payment.capture
+  end
+end

data/spec/models/spree/store_credit_decorator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Spree::StoreCredit do
+  describe 'attr-accessible' do
+    [:balance, :user, :transactioner, :type].each do |attribute|
+      it { should allow_mass_assignment_of attribute }
+    end
+  end
+
+  it { should belong_to(:unified_transaction).class_name('UnifiedPayment::Transaction').with_foreign_key('unified_transaction_id') }
+end

data/spec/models/spree/user_decorator_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Spree::User do
+  it { should have_many(:unified_payments).class_name('UnifiedPayment::Transaction') }
+
+  describe 'create_unified_transaction_user' do
+    it 'creates a new user' do
+      Spree::User.where(:email => 'new_user@unified.com').should be_blank
+      Spree::User.create_unified_transaction_user('new_user@unified.com').should eq(Spree::User.where(:email => 'new_user@unified.com').first )
+    end
+  end
+end

data/spec/models/unified_payment/transaction_decorator_spec.rb

@@ -0,0 +1,483 @@
+require 'spec_helper'
+
+describe UnifiedPayment::Transaction do
+  
+  [:gateway_order_status, :amount, :currency, :response_status, :pan, :response_description, :order_description, :xml_response, :status].each do |attribute|
+    it { should allow_mass_assignment_of attribute }
+  end
+
+  it { should belong_to(:user).class_name('Spree::User') }
+  it { should belong_to(:order).class_name('Spree::Order') }
+
+  it { should have_one(:store_credit).class_name('Spree::StoreCredit') }
+  let(:order) { mock_model(Spree::Order) }
+  let(:user) { mock_model(Spree::User) }
+
+  before do
+    UnifiedPayment::Transaction.any_instance.stub(:assign_attributes_using_xml).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:notify_user_on_transaction_status).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:complete_order).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:cancel_order).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:wallet_transaction).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:enqueue_expiration_task).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:release_order_inventory).and_return(true)
+    UnifiedPayment::Transaction.any_instance.stub(:payment_valid_for_order?).and_return(true)
+  end
+
+  context 'callbacks' do
+    context 'after and before save' do
+      context 'pending transaction on creation' do
+        before do
+          @pending_card_transaction = UnifiedPayment::Transaction.new(:status => 'pending', :payment_transaction_id => '1234')
+        end
+
+        it { @pending_card_transaction.should_not_receive(:notify_user_on_transaction_status) }
+        it { @pending_card_transaction.should_not_receive(:assign_attributes_using_xml) }
+        it { @pending_card_transaction.should_not_receive(:complete_order) }
+        it { @pending_card_transaction.should_not_receive(:cancel_order) }
+        it { @pending_card_transaction.should_not_receive(:wallet_transaction) }
+        it { @pending_card_transaction.should_not_receive(:release_order_inventory) }
+
+        after do
+          @pending_card_transaction.save!
+        end
+      end
+
+      context 'pending to successful transaction' do
+        before do
+          @successful_card_transaction = UnifiedPayment::Transaction.new(:status => 'pending', :payment_transaction_id => '1234')
+          @successful_card_transaction.save!
+          @successful_card_transaction.status = 'successful'
+        end
+
+        it { @successful_card_transaction.should_receive(:notify_user_on_transaction_status).and_return(true) }
+        it { @successful_card_transaction.should_receive(:assign_attributes_using_xml).and_return(true) }
+        it { @successful_card_transaction.should_not_receive(:release_order_inventory) }
+
+        context 'order inventory released' do
+          before do
+            @successful_card_transaction.stub(:order_inventory_released?).and_return(true)
+          end
+
+          context 'payment valid for order' do
+            it { @successful_card_transaction.should_receive(:wallet_transaction).and_return(true) }
+            it { @successful_card_transaction.should_not_receive(:complete_order) }
+            it { @successful_card_transaction.should_not_receive(:cancel_order) }
+          end
+
+          context 'payment not valid for order' do
+            before { @successful_card_transaction.stub(:payment_valid_for_order?).and_return(false) }
+
+            it { @successful_card_transaction.should_receive(:wallet_transaction).and_return(true) }
+            it { @successful_card_transaction.should_not_receive(:complete_order) }
+            it { @successful_card_transaction.should_not_receive(:cancel_order) }
+          end
+        end
+        
+        context 'order inventory not released and' do
+          before { @successful_card_transaction.stub(:order_inventory_released?).and_return(false) }
+          context 'payment valid for order' do
+            it { @successful_card_transaction.should_receive(:complete_order).and_return(true) }
+            it { @successful_card_transaction.should_not_receive(:wallet_transaction) }
+          end
+
+          context 'payment not valid for order' do
+            before { @successful_card_transaction.stub(:payment_valid_for_order?).and_return(false) }
+            it { @successful_card_transaction.should_receive(:wallet_transaction).and_return(true) }
+            it { @successful_card_transaction.should_not_receive(:complete_order) }
+          end
+         end
+        
+        after do
+          @successful_card_transaction.save!
+        end
+      end
+
+      context 'pending to unsuccessful transaction' do
+        before do
+          @unsuccessful_card_transaction = UnifiedPayment::Transaction.new(:status => 'pending', :payment_transaction_id => '1234')
+          @unsuccessful_card_transaction.save!
+          @unsuccessful_card_transaction.status = 'unsuccessful'
+        end
+
+        context 'order inventory released' do
+          before do
+            @unsuccessful_card_transaction.stub(:order_inventory_released?).and_return(true)
+          end
+          it { @unsuccessful_card_transaction.should_not_receive(:complete_order) }
+        end
+
+        it { @unsuccessful_card_transaction.should_receive(:notify_user_on_transaction_status).and_return(true) }
+        it { @unsuccessful_card_transaction.should_receive(:assign_attributes_using_xml).and_return(true) }
+        it { @unsuccessful_card_transaction.should_not_receive(:complete_order) }
+        it { @unsuccessful_card_transaction.should_receive(:cancel_order).and_return(true) }
+        it { @unsuccessful_card_transaction.should_not_receive(:release_order_inventory) }
+
+        after do
+          @unsuccessful_card_transaction.save!
+        end
+      end
+
+      context 'expire transaction' do
+        before do
+          @pending_card_transaction = UnifiedPayment::Transaction.create!(:status => 'pending', :payment_transaction_id => '1234')
+          @expired_card_transaction = UnifiedPayment::Transaction.create!(:status => 'unsuccessful', :payment_transaction_id => '1234')
+          @expired_card_transaction.expired_at = Time.current
+          @expired_card_transaction.save!
+        end
+
+        it 'should not call release_order_inventory when not expiring a card transaction' do
+          @pending_card_transaction.should_not_receive(:release_order_inventory)
+          @pending_card_transaction.update_attribute(:status, :successful)
+        end
+
+        it 'should not call release_order_inventory for expiring expired card transaction' do
+          @expired_card_transaction.should_not_receive(:release_order_inventory)
+          @expired_card_transaction.update_attribute(:expired_at, Time.now)
+        end
+
+        it 'should call release_order_inventory for expiring pending card transaction' do
+          @pending_card_transaction.should_receive(:release_order_inventory).and_return(true)
+          @pending_card_transaction.update_attribute(:expired_at, Time.now)
+        end
+      end
+    end
+  end
+
+  context 'scopes' do
+    describe 'pending' do
+      before do
+        @successful_card_transaction = UnifiedPayment::Transaction.create!(:status => 'successful', :payment_transaction_id => '1234')
+        @pending_card_transaction = UnifiedPayment::Transaction.create!(:status => 'pending', :payment_transaction_id => '1234')
+      end
+
+      it { UnifiedPayment::Transaction.pending.should eq([@pending_card_transaction]) }
+    end
+  end
+
+  describe '#order_inventory_released?' do
+    before(:all) do 
+      @expired_card_transaction = UnifiedPayment::Transaction.new
+      @expired_card_transaction.expired_at = Time.now
+      @pending_card_transaction = UnifiedPayment::Transaction.new
+    end
+    
+    it { @expired_card_transaction.order_inventory_released?.should be_true }
+    it { @pending_card_transaction.order_inventory_released?.should be_false }
+  end
+
+  describe '#assign_attributes_using_xml' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:assign_attributes_using_xml)
+      @card_transaction_with_message = UnifiedPayment::Transaction.create!(:payment_transaction_id => '123321')
+      @xml_response = '<Message><PAN>123XXX123</PAN><PurchaseAmountScr>200</PurchaseAmountScr><Currency>NGN</Currency><ResponseDescription>TestDescription</ResponseDescription><OrderStatus>OnTest</OrderStatus><OrderDescription>TestOrder</OrderDescription><Status>00</Status><MerchantTranID>12345654321</MerchantTranID><ApprovalCode>123ABC</ApprovalCode></Message>'
+      @card_transaction_with_message.stub(:xml_response).and_return(@xml_response)
+      @gateway_transaction = UnifiedPayment::Transaction.new
+      @card_transaction_with_message.stub(:gateway_transaction).and_return(@gateway_transaction)
+      @card_transaction_without_message = UnifiedPayment::Transaction.new()
+    end
+
+    describe 'method calls' do
+      it { @card_transaction_with_message.should_receive(:xml_response).and_return(@xml_response) }
+      it { @xml_response.should_receive(:include?).with('<Message').and_return(true) } 
+        
+      after do
+        @card_transaction_with_message.send(:assign_attributes_using_xml)
+      end
+    end
+
+    describe 'assigns' do
+      before { @card_transaction_with_message.send(:assign_attributes_using_xml) }
+      it { @card_transaction_with_message.pan.should eq('123XXX123') }
+      it { @card_transaction_with_message.response_description.should eq('TestDescription') }
+      it { @card_transaction_with_message.gateway_order_status.should eq('OnTest') }
+      it { @card_transaction_with_message.order_description.should eq('TestOrder') }
+      it { @card_transaction_with_message.response_status.should eq('00') }
+      it { @card_transaction_with_message.approval_code.should eq('123ABC') }
+      it { @card_transaction_with_message.merchant_id.should eq('12345654321') }
+    end
+  end
+
+  describe '#notify_user_on_transaction_status' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:notify_user_on_transaction_status)
+      @card_transaction = UnifiedPayment::Transaction.new(:status => 'pending', :payment_transaction_id => '1234')
+      @mailer_object = Object.new
+      @mailer_object.stub(:deliver!).and_return(true)
+      Spree::TransactionNotificationMailer.stub(:delay).and_return(Spree::TransactionNotificationMailer)
+      Spree::TransactionNotificationMailer.stub(:send_mail).with(@card_transaction).and_return(@mailer_object)
+    end
+
+    context 'when previous state was not pending' do
+      it { Spree::TransactionNotificationMailer.should_not_receive(:send_mail) }
+    end
+
+    context 'when previous state was pending' do
+      before do
+        @card_transaction.save!
+        @card_transaction.status = 'successful'
+      end
+
+      it { Spree::TransactionNotificationMailer.should_receive(:delay).and_return(Spree::TransactionNotificationMailer) }
+      it { Spree::TransactionNotificationMailer.should_receive(:send_mail).with(@card_transaction).and_return(@mailer_object) }
+    end
+    
+    after do
+      @card_transaction.save!
+    end
+  end
+
+  describe '#complete_order' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:complete_order)
+      @card_transaction = UnifiedPayment::Transaction.new(:status => 'successful', :payment_transaction_id => '1234')
+      @card_transaction.stub(:order).and_return(order)
+      order.stub(:next!).and_return(true)
+      @payment = mock_model(Spree::Payment)
+      @payment.stub(:complete).and_return(true)
+      order.stub(:pending_payments).and_return([@payment])
+    end
+
+    it { order.should_receive(:next!).and_return(true) }
+    it { order.should_receive(:pending_payments).and_return([@payment]) }
+    it { @payment.should_receive(:complete).and_return(true) }
+    
+    after do
+      @card_transaction.send(:complete_order)
+    end
+  end
+
+  describe '#cancel_order' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:cancel_order)
+      @card_transaction = UnifiedPayment::Transaction.new(:status => 'unsuccessful', :payment_transaction_id => '1234')
+      @card_transaction.stub(:order).and_return(order)
+      order.stub(:release_inventory).and_return(true)
+      @payment = mock_model(Spree::Payment)
+      @payment.stub(:update_attribute).with(:state, 'failed').and_return(true)
+      order.stub(:pending_payments).and_return([@payment])
+    end
+
+    context 'when order is completed' do
+      before do
+        order.stub(:completed?).and_return(true)
+      end
+
+      it { order.should_not_receive(:release_inventory) }
+      it { order.should_not_receive(:pending_payments) }
+    
+      after do
+        @card_transaction.send(:cancel_order)
+      end
+    end
+
+    context 'when order is not completed' do
+      before do
+        order.stub(:completed?).and_return(false)
+      end
+
+      context 'inventory released' do
+        before { @card_transaction.stub(:order_inventory_released?).and_return(true) }
+        it { order.should_not_receive(:release_inventory) }
+      end
+
+      context 'inventory not released' do
+        it { order.should_receive(:release_inventory).and_return(true) }
+      end
+
+      it { order.should_receive(:pending_payments).and_return([@payment]) }
+      it { @payment.should_receive(:update_attribute).with(:state, 'failed').and_return(true) }
+      
+      after do
+        @card_transaction.send(:cancel_order)
+      end
+    end
+  end
+  
+  describe '#release_order_inventory' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:release_order_inventory)
+      @order = mock_model(Spree::Order)
+      @order.stub(:release_inventory).and_return(true)
+      @card_transaction = UnifiedPayment::Transaction.new(:status => 'somestatus')
+      @card_transaction.stub(:order).and_return(@order)
+    end
+
+    context 'when order is already completed' do
+      before { @order.stub(:completed?).and_return(true) }
+      it { @order.should_not_receive(:release_inventory) }
+    end
+
+    context 'when order is not completed' do
+      before { @order.stub(:completed?).and_return(false) }
+      it { @order.should_receive(:release_inventory) }
+    end
+
+    after do
+      @card_transaction.send(:release_order_inventory)
+    end
+  end
+
+  describe 'abort!' do
+    before do
+      @time_now = Time.now
+      Time.stub(:now).and_return(@time_now)
+      @card_transaction = UnifiedPayment::Transaction.new(:status => 'somestatus', :payment_transaction_id => '1234')
+      @card_transaction.stub(:release_order_inventory).and_return(true)
+    end
+
+    it 'release inventory' do
+      @card_transaction.should_receive(:release_order_inventory).and_return(true)
+      @card_transaction.abort!
+    end
+
+    it 'assigns expired_at' do
+      @card_transaction.abort!
+      @card_transaction.reload.expired_at.should eq(@time_now.to_s)
+    end
+  end
+
+  describe 'status checks for pening, unsuccessful and successful' do
+    before do
+      @successful_card_transaction = UnifiedPayment::Transaction.create!(:status => 'successful', :payment_transaction_id => '1234')
+      @pending_card_transaction = UnifiedPayment::Transaction.create!(:status => 'pending', :payment_transaction_id => '1234')
+      @unsuccessful_card_transaction = UnifiedPayment::Transaction.create!(:status => 'unsuccessful', :payment_transaction_id => '1234')
+    end
+
+    it { @successful_card_transaction.pending?.should be_false }
+    it { @successful_card_transaction.successful?.should be_true }
+    it { @successful_card_transaction.unsuccessful?.should be_false }
+
+    it { @unsuccessful_card_transaction.successful?.should be_false }
+    it { @unsuccessful_card_transaction.pending?.should be_false }
+    it { @unsuccessful_card_transaction.unsuccessful?.should be_true }
+
+    it { @pending_card_transaction.pending?.should be_true } 
+    it { @pending_card_transaction.successful?.should be_false } 
+    it { @pending_card_transaction.unsuccessful?.should be_false } 
+  end
+
+  describe '#enqueue_expiration_task' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:enqueue_expiration_task)
+      @last_id = UnifiedPayment::Transaction.last.try(:id) || 0
+      current_time = Time.current
+      Time.stub(:current).and_return(current_time)
+      @new_card_transaction = UnifiedPayment::Transaction.new(:status => 'pending')
+      @new_card_transaction.stub(:id).and_return(123)
+    end
+    
+    context 'when transaction id is present' do
+      before { @new_card_transaction.payment_transaction_id = '1234' }
+      it 'enqueue delayed job' do
+        Delayed::Job.should_receive(:enqueue).with(TransactionExpiration.new(@new_card_transaction.id), { :run_at => TRANSACTION_LIFETIME.minutes.from_now }).and_return(true)
+      end
+
+      after do
+        @new_card_transaction.save!
+      end
+    end
+
+    context 'when transaction id is not present' do
+      it 'does not enqueue delayed job' do
+        Delayed::Job.should_not_receive(:enqueue).with(TransactionExpiration.new(@new_card_transaction.id), { :run_at => TRANSACTION_LIFETIME.minutes.from_now })
+      end
+
+      after do
+        @new_card_transaction.save!
+      end
+    end
+  end
+
+  describe '#wallet_transaction' do
+    before do
+      UnifiedPayment::Transaction.any_instance.unstub(:wallet_transaction)
+      @card_transaction = UnifiedPayment::Transaction.create!(:payment_transaction_id => '123454321', :amount => 200)
+      @card_transaction.stub(:user).and_return(user)
+      @card_transaction.stub(:order).and_return(order)
+      user.stub(:store_credits_total).and_return(100)
+      @store_credit_balance = user.store_credits_total + @card_transaction.amount.to_f
+      @store_credit = Object.new
+      @card_transaction.stub(:build_store_credit).with(:balance => @store_credit_balance, :user => user, :transactioner => user, :amount => @card_transaction.amount.to_f, :reason => "transferred from transaction:#{@card_transaction.payment_transaction_id}", :payment_mode => Spree::Credit::PAYMENT_MODE['Payment Refund'], :type => "Spree::Credit").and_return(@store_credit)
+      @store_credit.stub(:save!).and_return(true)
+    end
+
+    it { @card_transaction.should_receive(:build_store_credit).with(:balance => @store_credit_balance, :user => user, :transactioner => user, :amount => @card_transaction.amount.to_f, :reason => "transferred from transaction:#{@card_transaction.payment_transaction_id}", :payment_mode => Spree::Credit::PAYMENT_MODE['Payment Refund'], :type => "Spree::Credit").and_return(@store_credit) }
+    it { user.should_receive(:store_credits_total).and_return(100) }
+    it { @store_credit.should_receive(:save!).and_return(true) }
+    it { @card_transaction.should_not_receive(:associate_user) }
+    
+    context 'when user is nil' do
+      before { user.stub(:nil?).and_return(true) }
+      
+      it { @card_transaction.should_receive(:associate_user).and_return(true) }
+    end
+    
+    after do
+      @card_transaction.wallet_transaction
+    end
+  end
+
+  describe '#associate_user' do
+    before do
+      @card_transaction = UnifiedPayment::Transaction.create!(:payment_transaction_id => '123454321')
+      @card_transaction.stub(:order).and_return(order)
+      order.stub(:email).and_return('test_user@baloo.com')
+      @card_transaction.stub(:save!).and_return(true)
+      @new_user = mock_model(Spree::User)
+    end
+
+    context 'when user with the order email exists' do
+      before do 
+        Spree::User.stub(:where).with(:email => order.email).and_return([user])
+        @card_transaction.stub(:user=).with(user).and_return(true)
+      end
+      
+      describe 'method calls' do
+        it { Spree::User.should_receive(:where).with(:email => order.email).and_return([user]) }
+        it { @card_transaction.should_receive(:user=).with(user).and_return(true) }
+        after do
+          @card_transaction.send(:associate_user)
+        end
+      end
+    end
+
+    context 'when user with the order email does not exist' do
+      before do
+        Spree::User.stub(:where).with(:email => order.email).and_return([]) 
+        Spree::User.stub(:create_unified_transaction_user).with(order.email).and_return(user)
+      end
+
+      describe 'method calls' do
+        it { Spree::User.should_receive(:where).with(:email => order.email).and_return([]) }
+        it { Spree::User.should_receive(:create_unified_transaction_user).with(order.email).and_return(user) }
+        
+        after do
+          @card_transaction.send(:associate_user)
+        end
+      end
+
+      it 'associates a new user' do
+        @card_transaction.user.should be_nil
+        @card_transaction.send(:associate_user)
+        @card_transaction.user.should eq(user)
+      end
+    end
+  end
+
+  describe '#update_transaction_on_query' do
+    before { @card_transaction = UnifiedPayment::Transaction.create!(:payment_transaction_id => '123454321') }
+    
+    context 'status is APPROVED' do
+      it { @card_transaction.should_receive(:assign_attributes).with(:gateway_order_status => 'APPROVED', :status => 'successful').and_return(true) }
+      it { @card_transaction.should_receive(:save).with(:validate => false).and_return(true) }
+      after { @card_transaction.update_transaction_on_query('APPROVED') }
+    end
+
+    context 'status is APPROVED' do
+      it { @card_transaction.should_receive(:assign_attributes).with(:gateway_order_status => 'MyStatus').and_return(true) }
+      it { @card_transaction.should_receive(:save).with(:validate => false).and_return(true) }
+      after { @card_transaction.update_transaction_on_query('MyStatus') }
+    end
+  end
+end