wordjelly-auth 0.0.5 → 0.0.8

data/spec/requests/{discount_request_spec.rb → shopping/discount_request_spec.rb}

@@ -25,32 +25,33 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
         @product.save
 
 
-        @c = Auth::Client.new(:resource_id => @u.id, :api_key => "test", :app_ids => ["test_app_id"])
+        @c = Auth::Client.new(:resource_id => @u.id, :api_key => "test", :app_ids => ["testappid"])
         @c.redirect_urls = ["http://www.google.com"]
         @c.versioned_create
-        @u.client_authentication["test_app_id"] = "test_es_token"
+        @u.client_authentication["testappid"] = "testestoken"
         @u.save
-        @u2.client_authentication["test_app_id"] = "test_es_token2"
+        @u2.client_authentication["testappid"] = "testestoken2"
         @u2.save
 
-        @u3.client_authentication["test_app_id"] = "test_es_token3"
+        @u3.client_authentication["testappid"] = "testestoken3"
         @u3.save
 
         @ap_key = @c.api_key
-        @headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u.authentication_token, "X-User-Es" => @u.client_authentication["test_app_id"], "X-User-Aid" => "test_app_id"}
+        @headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u.authentication_token, "X-User-Es" => @u.client_authentication["testappid"], "X-User-Aid" => "testappid"}
         
 
-        @u2_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u2.authentication_token, "X-User-Es" => @u2.client_authentication["test_app_id"], "X-User-Aid" => "test_app_id"}
+        @u2_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u2.authentication_token, "X-User-Es" => @u2.client_authentication["testappid"], "X-User-Aid" => "testappid"}
 
-        @u3_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u3.authentication_token, "X-User-Es" => @u3.client_authentication["test_app_id"], "X-User-Aid" => "test_app_id"}
+        @u3_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u3.authentication_token, "X-User-Es" => @u3.client_authentication["testappid"], "X-User-Aid" => "testappid"}
         
         ### CREATE ONE ADMIN USER
 
         ### It will use the same client as the user.
-        @admin = Admin.new(attributes_for(:admin_confirmed))
-        @admin.client_authentication["test_app_id"] = "test_es_token"
+        @admin = User.new(attributes_for(:user_confirmed))
+        @admin.admin = true
+        @admin.client_authentication["testappid"] = "testestoken4"
         @admin.save
-        @admin_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-Admin-Token" => @admin.authentication_token, "X-Admin-Es" => @admin.client_authentication["test_app_id"], "X-Admin-Aid" => "test_app_id"}
+        @admin_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @admin.authentication_token, "X-User-Es" => @admin.client_authentication["testappid"], "X-User-Aid" => "testappid"}
         
     end
 
@@ -79,7 +80,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 
 				discount = build_discount_for_request(cart)
 				
-				post shopping_discounts_path,{discount: discount,:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @headers
+				post shopping_discounts_path,{discount: discount,:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
 
 				expect(response.code).to eq("201")
 				expect(Shopping::Discount.count).to eq(1)
@@ -99,7 +100,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				authorize_payment_as_admin(payment,@admin)					
 				discount = create_discount(cart,@u)
 
-				get shopping_discount_path({:id => discount.id.to_s}),{:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json"}					
+				get shopping_discount_path({:id => discount.id.to_s}),{:api_key => @ap_key, :current_app_id => "testappid"}.to_json, { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json"}					
 
 				discount_obj = JSON.parse(response.body)
 
@@ -128,7 +129,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				authorize_payment_as_admin(payment,@admin)					
 				discount = create_discount(cart,@u)
 
-				post create_multiple_shopping_cart_items_path, {:id => discount.id.to_s, discount: { :product_ids => discount.product_ids},:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @u2_headers
+				post create_multiple_shopping_cart_items_path, {:id => discount.id.to_s, discount: { :product_ids => discount.product_ids},:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @u2_headers
 
 				expect(response.code).to eq("200")
 
@@ -157,7 +158,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 
 				expect(Shopping::CartItem.count).to eq(10)
 
-				post shopping_carts_path,{cart: {add_cart_item_ids: multiple_created_cart_items.map{|c| c = c.id.to_s}},:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @u2_headers
+				post shopping_carts_path,{cart: {add_cart_item_ids: multiple_created_cart_items.map{|c| c = c.id.to_s}},:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @u2_headers
 
 				expect(response.code).to eq("201")
 
@@ -186,7 +187,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				add_cart_items_to_cart(multiple_created_cart_items,user_two_cart,@u2)
 
 				
-				post shopping_payments_path, {cart_id: user_two_cart.id.to_s,payment_type: "cash", amount: 0.0, discount_id: discount.id.to_s, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @u2_headers
+				post shopping_payments_path, {cart_id: user_two_cart.id.to_s,payment_type: "cash", amount: 0.0, discount_id: discount.id.to_s, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @u2_headers
 
 				expect(response.code).to eq("201")
 				payment_created = assigns(:auth_shopping_payment)
@@ -215,7 +216,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				
 				discount_payment = create_payment_using_discount(discount,user_two_cart,@u2)
 
-				get shopping_discount_path({:id => discount.id.to_s}),{:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json"}		
+				get shopping_discount_path({:id => discount.id.to_s}),{:api_key => @ap_key, :current_app_id => "testappid"}.to_json, { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json"}		
 
 				discount_obj = JSON.parse(response.body)
 
@@ -250,7 +251,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				discount_payment = create_payment_using_discount(discount,user_two_cart,@u2)
 
 
-				put shopping_discount_path({:id => discount.id.to_s}), {:discount => {:add_verified_ids => [discount_payment.id.to_s]}, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json,@headers
+				put shopping_discount_path({:id => discount.id.to_s}), {:discount => {:add_verified_ids => [discount_payment.id.to_s]}, :api_key => @ap_key, :current_app_id => "testappid"}.to_json,@headers
 
 				puts response.body.to_s
 
@@ -290,7 +291,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				approve_pending_discount_request(discount,discount_payment,@u,user=nil)
 
 				##now call update on the discount payment as user u2, and it should have a payment status as passed.
-				put shopping_payment_path({:id => discount_payment.id.to_s}), {:is_verify_payment => true, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json,@u2_headers
+				put shopping_payment_path({:id => discount_payment.id.to_s}), {:is_verify_payment => true, :api_key => @ap_key, :current_app_id => "testappid"}.to_json,@u2_headers
 
 				expect(response.code).to eq("204")
 				discount_payment = Shopping::Payment.find(discount_payment.id.to_s)
@@ -322,7 +323,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				## now should not create the discount
 				discount = build_discount_for_request(cart)
 				
-				post shopping_discounts_path,{discount: discount,:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @headers
+				post shopping_discounts_path,{discount: discount,:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
 
 				#expect(response.code).to eq("201")
 				response_body = JSON.parse(response.body)
@@ -342,12 +343,12 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 
 			context " -- admin -- " do 
 
-				it " -- creates a discount without a cart, or product ids -- " do
+				it " -- creates a discount without a cart, or product ids -- ", :cartless_discount => true do
 
 					
-					post shopping_discounts_path,{discount: @discount,:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @admin_headers
+					post shopping_discounts_path,{discount: @discount,:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @admin_headers
 
-					#puts response.body.to_s
+					puts response.body.to_s
 
 					#discount_created = Shopping::Discount.find(@discount.id.to_s)
 
@@ -369,7 +370,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 					discount =create_cartless_productless_discount(@admin)
 
 					## now make a payment using the discount id, provided above.
-					post shopping_payments_path, {cart_id: cart.id.to_s,payment_type: "cash", amount: 0.0, discount_id: discount.id.to_s, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @headers
+					post shopping_payments_path, {cart_id: cart.id.to_s,payment_type: "cash", amount: 0.0, discount_id: discount.id.to_s, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
 
 					## expect the payment to have gone through.
 					expect(response.code).to eq("201")
@@ -388,7 +389,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 
 				it "--  cannot create a discount -- " do 
 
-					post shopping_discounts_path,{discount: @discount,:api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @headers
+					post shopping_discounts_path,{discount: @discount,:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
 
 					#puts response.body.to_s
 
@@ -461,7 +462,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 
 				it " -- doesn't allow new payment request to be converted into a verified request -- ", :conv => true do 
 
-					put shopping_discount_path({:id => @discount.id.to_s}), {:discount => {:add_verified_ids => [@discount_payment_three.id.to_s]}, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json,@headers
+					put shopping_discount_path({:id => @discount.id.to_s}), {:discount => {:add_verified_ids => [@discount_payment_three.id.to_s]}, :api_key => @ap_key, :current_app_id => "testappid"}.to_json,@headers
 
 					puts response.body.to_s
 
@@ -522,7 +523,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 				it " -- doesnt allow creation of any discount payments -- ", :conv => true do 
 
 					#@discount_payment_three = create_payment_using_discount(@discount,@user_three_cart,@u3)
-					post shopping_payments_path, {cart_id: @user_three_cart.id.to_s,payment_type: "cash", amount: 0.0, discount_id: @discount.id.to_s, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @u3_headers
+					post shopping_payments_path, {cart_id: @user_three_cart.id.to_s,payment_type: "cash", amount: 0.0, discount_id: @discount.id.to_s, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @u3_headers
 
 					expect(response.code).to eq("201")
 					payment_created = assigns(:auth_shopping_payment)
@@ -573,7 +574,7 @@ RSpec.describe "discount request spec",:discount => true,:shopping => true, :typ
 
             	## now make a refund request
             	## it should fail.
-            	post shopping_payments_path, {cart_id: user_two_cart.id.to_s,payment_type: "cash", refund: true, amount: -10, :api_key => @ap_key, :current_app_id => "test_app_id"}.to_json, @u2_headers   
+            	post shopping_payments_path, {cart_id: user_two_cart.id.to_s,payment_type: "cash", refund: true, amount: -10, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @u2_headers   
 
             	expect(response.code).to eq("422")
             	puts response.body.to_s

data/spec/requests/shopping/payment_request_spec.rb

@@ -0,0 +1,1282 @@
+require "rails_helper"
+
+RSpec.describe "payment request spec",:payment => true, :shopping => true, :type => :request do 
+
+	before(:all) do 
+        Shopping::Product.delete_all
+        @product = Shopping::Product.new(attributes_for(:product))
+        @product.save
+        ActionController::Base.allow_forgery_protection = false
+        User.delete_all
+        Auth::Client.delete_all
+        @u = User.new(attributes_for(:user_confirmed))
+        @u.save
+
+        @c = Auth::Client.new(:resource_id => @u.id, :api_key => "test", :app_ids => ["testappid"])
+        @c.redirect_urls = ["http://www.google.com"]
+        @c.versioned_create
+        @u.client_authentication["testappid"] = "testestoken2"
+        @u.save
+        
+      
+        @ap_key = @c.api_key
+        @headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u.authentication_token, "X-User-Es" => @u.client_authentication["testappid"], "X-User-Aid" => "testappid"}
+        
+        
+        ### CREATE ONE ADMIN USER
+
+        ### It will use the same client as the user.
+        @admin = User.new(attributes_for(:admin_confirmed))
+        @admin.admin = true
+        @admin.client_authentication["testappid"] = "testestoken"
+        @admin.save
+        
+        
+
+        @admin_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @admin.authentication_token, "X-User-Es" => @admin.client_authentication["testappid"], "X-User-Aid" => "testappid"}
+
+    end
+
+
+    context " -- web app requests -- " do 
+
+
+        context " -- gateway payment -- ", :payumoney => true do 
+            
+            before(:example) do 
+                ## create cart items
+                ## create cart
+                ## create a gateway payment.
+                ## then simulate a post request as if its coming from the payment gateway
+                @created_cart_item_ids = []
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.signed_in_resource = @u
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+
+                @cart.prepare_cart
+
+                ## creating payment.    
+                @payment = Shopping::Payment.new
+                @payment.payment_type = "gateway"
+                @payment.cart_id = @cart.id.to_s
+                @payment.amount = @cart.cart_price
+                @payment.signed_in_resource = @u
+                @payment.resource_class = @u.class.name
+                @payment.resource_id = @u.id.to_s
+                @payment.firstname = "bhargav"
+                @payment.email = "bhargav.r.raut@gmail.com"
+                @payment.phone = "9561137096"
+                @payment.productinfo = "hello world"
+               
+                puts "payment save result:"
+                puts @payment.save.to_s
+                puts @payment.errors.full_messages.to_s
+
+               
+
+            end 
+
+            after(:example) do 
+                Shopping::Cart.delete_all
+                Shopping::CartItem.delete_all
+                Shopping::Payment.delete_all
+            end
+
+            context " -- gateway does post call to the app -- " do 
+
+                before(:example) do 
+                   expect_any_instance_of(Shopping::Payment).to receive(:gateway_callback).and_return(true)
+                   expect_any_instance_of(Shopping::Payment).to receive(:verify_payment).and_return(nil) 
+                end
+                
+                
+                it " -- triggers gateway callback, but returns from the verify_payment callback -- ", :first_gateway_test do 
+                    
+                    sign_in @u
+                    
+
+                    post "/shopping/payments/#{@payment.id.to_s}", PayumoneySupport.payment_callback_params(@payment)
+
+
+                end
+
+               
+            end
+
+            context " -- user does refresh payment -- " do 
+
+                before(:example) do 
+                   expect_any_instance_of(Shopping::Payment).to receive(:gateway_callback).and_return(nil)
+                   expect_any_instance_of(Shopping::Payment).to receive(:verify_payment).and_return(true)
+                end
+
+                it " -- does not trigger gateway callback , because .verify_payment attr_accessor is set -- " do 
+
+                    sign_in @u
+                    
+                    put "/shopping/payments/#{@payment.id.to_s}", {:is_verify_payment => true}
+
+                end
+
+            end 
+
+            
+
+            context " -- user interrupts callback -- " do 
+
+
+                it " -- calls verify_payment if the payment status is pending, and the user passes is_verify_payment -- " do 
+
+                    expect_any_instance_of(Shopping::Payment).to receive(:verify_payment).and_return(true)
+
+                    expect(@payment.payment_status).to be_nil
+
+                    sign_in @u
+                    
+                    put "/shopping/payments/#{@payment.id.to_s}", {:is_verify_payment => true}
+
+                end
+
+                it " -- doesnt call verify_payment if the status is not pending, and even if the user passes is_verify_payment -- ", :sss => true do 
+
+                    ## change the payment status to 0
+                    ## and then calling this will not work.
+                    
+
+                    @payment.payment_status = 0
+                    @payment.signed_in_resource = @admin
+                    @payment.resource_id = @u
+                    @payment.resource_class = @u.class.to_s
+                    ## setting this as true so that it doesn't do the gateway callback(that happens automatically otherwise, and it will lead to an error.)
+                    ## just set this is_verify_payment to avoid the gateway callback, there is no other significance, i would have liked to do skip_callback somehow, but too tired.
+                    @payment.is_verify_payment = true
+                    
+                    sign_in @u
+                    
+                    expect_any_instance_of(Shopping::Payment).to receive(:verify_payment).and_return(nil)
+
+                    put "/shopping/payments/#{@payment.id.to_s}", {:is_verify_payment => true}                    
+
+                end
+            end
+
+        end
+
+    end
+
+    context " -- JSON specs -- " do 
+
+        before(:all) do 
+            User.delete_all
+            @u = User.new(attributes_for(:user_confirmed))
+            @u.save
+            @u.client_authentication["testappid"] = "testestoken2"
+            @u.save
+            @headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @u.authentication_token, "X-User-Es" => @u.client_authentication["testappid"], "X-User-Aid" => "testappid"}
+            @admin = User.new(attributes_for(:admin_confirmed))
+            @admin.admin = true
+            @admin.client_authentication["testappid"] = "testestoken"
+            @admin.save
+            
+            
+
+            @admin_headers = { "CONTENT_TYPE" => "application/json" , "ACCEPT" => "application/json", "X-User-Token" => @admin.authentication_token, "X-User-Es" => @admin.client_authentication["testappid"], "X-User-Aid" => "testappid"}
+
+        end
+        
+        context " -- cash, card, cheque payment -- " do 
+
+            
+
+            before(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+                
+               
+                @created_cart_item_ids = []
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.signed_in_resource = @u
+                    cart_item.save
+                    puts cart_item.errors.full_messages
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+               
+            end
+
+            after(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+            end
+
+
+            it " -- creates a payment to the cart-- ", :cr => true do 
+
+                
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: 10, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
+                        
+                expect(Shopping::Payment.count).to eq(1)
+            
+            end
+
+            it " -- produces a validation error if payment is less than minimum payment amount -- " do 
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: 5, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
+                
+                payment_made = assigns(:auth_shopping_payment)
+                expect(payment_made.errors.full_messages).not_to be_empty
+
+                expect(Shopping::Payment.count).to eq(0)   
+
+            end
+
+            it " -- sets all cart items as accepted, if payment amount is sufficient for all the cart items. ",:br => true do 
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: 50.00, :api_key => @ap_key, :current_app_id => "testappid", :payment_status => 1, :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                
+                puts response.body.to_s
+
+                expect(Shopping::Payment.count).to eq(1)
+                
+                @created_cart_item_ids.each do |id|
+                    cart_item = Shopping::CartItem.find(id)
+                    expect(cart_item.accepted).to be_truthy
+                end
+
+
+            end
+
+
+            
+            it " -- if payment status is set as failed, cart item statuses are also updated -- ", :payment_cart_item_reversal do 
+        
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 50.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                ## need to set the signed in resource as admin, because we are setting the payment status, and that cannot be done as user.
+                payment.signed_in_resource = @admin
+                ## this is setting the payment as successfully.
+                payment.payment_status = 1
+                ps = payment.save
+
+
+                ## now all the cart items should be accepted
+                @created_cart_item_ids.each do |id|
+                    cart_item = Shopping::CartItem.find(id)
+                    expect(cart_item.accepted).to be_truthy
+                end
+
+                
+                put shopping_payment_path({:id => payment.id}), {payment: {payment_status: 0},:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+
+
+
+                @created_cart_item_ids.each do |id|
+                    cart_item = Shopping::CartItem.find(id)
+                    expect(cart_item.accepted).not_to be_truthy
+                end
+
+            end
+
+            
+            it " -- payment update can retrospectively accept cart items -- ", :retro => true do 
+
+                ## now make a payment to the cart of the amount equal to all the cart items.
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 10.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                payment.signed_in_resource = @admin
+                payment.payment_status = 1
+                ps = payment.save
+                puts payment.errors.full_messages.to_s
+                expect(ps).to be_truthy
+
+                ## then remove some cart items from the cart
+                cart_item_to_remove = Shopping::CartItem.first
+                cart_item_to_remove.signed_in_resource = @admin
+                k = cart_item_to_remove.unset_cart
+                expect(cart_item_to_remove.parent_id).to be_nil
+                expect(k).to be_truthy
+
+                ## now add one cart item back into the cart
+                ## what if we add back the same cart item.
+                ## it will already be accepted
+                ## so when you add a cart item to the cart, set its accepted as null by default.
+                cart_item_to_remove = Shopping::CartItem.find(cart_item_to_remove.id.to_s)
+                cart_item_to_remove.signed_in_resource = @admin
+                r = cart_item_to_remove.set_cart_and_resource(@cart)
+                
+                expect(r).to be_truthy
+
+                ## now this cart item will be accepted = null, even though the cart has enough credit in it.
+                cart_item_to_remove = Shopping::CartItem.find(cart_item_to_remove.id.to_s)
+                expect(cart_item_to_remove.accepted).to be_nil
+                expect(cart_item_to_remove.parent_id).to eq(@cart.id.to_s)
+
+
+                res = payment.save
+                expect(res).to be_truthy
+
+                Shopping::CartItem.all.each do |citem|
+                    if citem.parent_id == @cart.id.to_s
+                        expect(citem.accepted).to be_truthy
+                    end
+                end
+
+                ## add another cart item.
+                cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                cart_item.resource_id = @u.id.to_s
+                cart_item.resource_class = @u.class.name
+                cart_item.parent_id = @cart.id
+                cart_item.signed_in_resource = @u
+                res = cart_item.save
+                #puts cart_item.errors.full_messages
+                expect(res).to be_truthy
+               
+                ## now call update on the payment, and the last cart item should be marked as accepted.
+                put shopping_payment_path({:id => payment.id}), {:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
+
+                expect(response.code).to eq("204")
+
+                ## this is failing for some reason.
+                latest_added_citem = Shopping::CartItem.find(cart_item.id.to_s)
+                expect(latest_added_citem.accepted).not_to be_truthy
+                
+            end
+
+
+            it " -- sequence -- ", :sequence => true do 
+
+                ## make a successfull payment.
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 50.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                payment.signed_in_resource = @admin
+                ## this is setting the payment as successfully.
+                payment.payment_status = 1
+                ps = payment.save
+                expect(ps).to be_truthy
+
+                ## now remove an item from the cart.
+                ## you cannot remove an item once a payment has been made, unless you are an admin.
+                cart_item_to_remove = Shopping::CartItem.first
+                cart_item_to_remove.signed_in_resource = @admin
+                k = cart_item_to_remove.unset_cart
+                
+                ## now make a refund request.
+                refund_request = Shopping::Payment.new
+                refund_request.payment_type = "cash"
+                refund_request.refund = true
+                ## the amount doesnt matter.
+                refund_request.amount = -10
+                refund_request.resource_id = @u.id.to_s
+                refund_request.resource_class = @u.class.name.to_s
+                refund_request.cart_id = @cart.id.to_s
+                refund_request.signed_in_resource = @u
+                ## this is setting the payment as successfully.
+                ref_res = refund_request.save
+                ## then accept that request.
+                #puts refund_request.errors.full_messages.to_s
+                expect(ref_res).to be_truthy
+
+                ## now suppose earlier payment fails.
+                ## all cart items should be set as accepted false.
+
+                ## only admin can update a payment.
+                #payment = Shopping::Payment.find(payment.id)
+                #payment.payment_type = "cash"
+                #payment.amount = 50.00
+                #payment.resource_id = @u.id.to_s
+                #payment.resource_class = @u.class.name.to_s
+                #payment.cart_id = @cart.id.to_s
+                #payment.signed_in_resource = @admin
+                ## this is setting the payment as successfully.
+                #payment.payment_status = 0
+                #ps = payment.save
+
+                
+
+                put shopping_payment_path({:id => payment.id}), {payment: {payment_status: 0},:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+
+                #expect(ps).to be_truthy
+                payment = Shopping::Payment.find(payment.id)
+                expect(payment.payment_status).to eq(0)
+
+
+
+                @cart = Shopping::Cart.find(payment.cart_id)
+                @cart.prepare_cart
+                ## now all the remaining items should be set as not accepted.
+                @cart.get_cart_items.each do |citem|
+                    expect(citem.accepted).not_to be_truthy
+                end
+
+                ## so first we made a payment of 50, then removed one item, now payment has gone false, so now the pending balance should be -40
+                cart = Shopping::Cart.find(@cart.id)
+                cart.prepare_cart
+                expect(cart.cart_pending_balance).to eq(40)
+
+            end
+
+
+
+        end
+
+
+        context " -- excess payment -- " do 
+            before(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+                @created_cart_item_ids = []
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.price = 10.00
+                    cart_item.signed_in_resource = @u
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+            end
+
+            after(:example) do 
+                 Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+            end
+
+            it " -- cash payment should set amount to pending balance, and pass, with change being calculated -- ", :cash_payment_excess => true do 
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: 55.00, :api_key => @ap_key, :current_app_id => "testappid", :payment_status => 1, :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                        
+                expect(Shopping::Payment.count).to eq(1)
+
+                payment = assigns(:auth_shopping_payment)
+                expect(payment.cash_change).to eq(5.00)
+
+            end
+
+            it " -- cheque payment should fail, saying amount is excessive -- ", :cheque_payment_excess => true do 
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cheque", amount: 55.00, :api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                
+                puts response.body.to_s
+                expect(Shopping::Payment.count).to eq(0)
+
+                payment = assigns(:auth_shopping_payment)
+                expect(payment.errors.full_messages).not_to be_empty
+
+            end
+
+            it " -- card payment should fail, saying amount is excessive -- ", :card_payment_excess do 
+
+                ## this is same as for cheque, just change the payment type.
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "card", amount: 55.00, :api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                
+                puts response.body.to_s
+                expect(Shopping::Payment.count).to eq(0)
+
+                payment = assigns(:auth_shopping_payment)
+                expect(payment.errors.full_messages).not_to be_empty
+
+            end
+
+        end
+
+
+
+
+        context " -- payment validations. -- ", :payment_validations => true do 
+
+            before(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+                @created_cart_item_ids = []
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.signed_in_resource = @u
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+
+
+            end
+
+            after(:example) do 
+                 Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+            end
+
+            it " -- doesnt allow payment to be created if cart is empty -- ", :payment_into_empty_cart do 
+
+                #Shopping::CartItem.all.each do |citem|
+                #    citem.signed_in_resource = @admin
+                #    citem.unset_cart
+                #end
+
+                new_cart = Shopping::Cart.new
+                new_cart.resource_id = @u.id.to_s
+                new_cart.resource_class = @u.class.name
+                new_cart.save
+
+
+                post shopping_payments_path, {cart_id: new_cart.id.to_s,payment_type: "cash", amount: 10.00, :api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                        
+                expect(Shopping::Payment.count).to eq(0)
+
+                puts response.body.to_s
+
+                #expect(payment.errors.full_messages).not_to be_empty
+
+
+            end
+
+            it " -- payment amount must be greater than zero. -- ", :payment_greater_than => true do
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: -10.00, :api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                        
+                expect(Shopping::Payment.count).to eq(0)
+
+                payment = assigns(:auth_shopping_payment)
+
+                expect(payment.errors.full_messages).not_to be_empty
+
+            end
+
+            
+
+        end
+
+
+
+        ## note also need to check this in case of cart controller, when we add or remove cart items.
+        ## set cart item accepted specs.
+        context " -- transactional issues in multiple cart items being marked as accepted -- " do 
+
+            before(:example) do 
+
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+                @created_cart_item_ids = []
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.signed_in_resource = @u
+                    cart_item.price = 10.00
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+
+               
+                allow_any_instance_of(Shopping::CartItem).to receive(:set_accepted).and_return(false)
+      
+
+            end
+
+            after(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+
+                
+                            
+            end
+
+            it " -- shows a validation error if, all cart items cannot be successfully updated ", :cart_item_update_payment_failure do 
+
+                ## so how to simulate this?
+                ## override set_accepted method in payment_concern to return false.
+                
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: 50, :api_key => @ap_key, :current_app_id => "testappid", :payment_status => 1, :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+
+                expect(Shopping::Payment.count).to eq(0)
+
+                payment = assigns(:auth_shopping_payment)
+                expect(payment.errors.full_messages).not_to be_empty
+            end
+
+            it " -- can recover from situation where all cart items couldnt be accepted -- " do 
+
+                ## so basically the cart item gets marked as being accepted by a payment that doesnt exist.
+
+                ## so basically should have a function that can check for such a scene.
+
+                ## should be able to call update on a cart item, and in doing so, search for the payment, if it doesn't exist, then it should update the cart item as not being accepted.
+
+
+
+            end
+
+        end
+     
+        context " -- payment receipt -- " do 
+
+            before(:example) do 
+
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+                @created_cart_item_ids = []
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.signed_in_resource = @u
+                    cart_item.price = 10.00
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+
+               
+               
+      
+
+            end
+
+            after(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+
+                
+                      
+            end
+
+
+            it " -- generates receipt after payment is saved -- ", :failure => true do 
+
+                ## proposed plan for successfull payment.
+                ## cart should prepare cart
+                ## it should also show the receipt of the latest payment.
+                ## so basically a hash with two keys should be generated
+                ## cart => {with all its attributes}
+                ## curr_payment => {with cart item ids, that it has paid for.}
+
+                ## expect the payment_receipt hash to be present.
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", amount: 50.00, :api_key => @ap_key, :current_app_id => "testappid", :payment_status => 1, :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+                
+                assigned_p = assigns(:auth_shopping_payment)
+
+                expect(Shopping::Payment.count).to eq(1)
+                
+                @created_cart_item_ids.each do |id|
+                    cart_item = Shopping::CartItem.find(id)
+                    expect(cart_item.accepted).to be_truthy
+                end
+
+                puts JSON.pretty_generate(assigned_p.payment_receipt)
+
+
+
+            end
+        end
+
+        context " -- refund -- ", :refund => true do 
+            
+            before(:example) do 
+
+            	Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+
+                ## create a cart
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+
+                ## create five cart items and add them to the cart.
+                @created_cart_item_ids = []
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.signed_in_resource = @u
+                    cart_item.price = 10.00
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+
+                ## create a payment to the cart
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 50.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                payment.signed_in_resource = @admin
+                payment.payment_status = 1
+                ps = payment.save
+               
+
+            end
+
+            after(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+            end
+
+
+
+
+            it " -- creates a refund request if the cart pending balance is negative -- ", :create_refund do 
+
+                @cart = Shopping::Cart.find(@cart.id)
+                @cart.prepare_cart            
+                expect(@cart.cart_pending_balance).to eq(0.00)
+
+                 
+                ## now basically remove a cart item from the cart.
+                last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                ## only admin can unset an item , after a payment has already been made
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+                ## now the pending balance should be -ve
+                @cart.prepare_cart
+                expect(@cart.cart_pending_balance).to eq(-10.00)
+
+
+                ## so basically here we are just creating a refund request.
+                ## here it only checks that the amount is negative and not what is the amount sent in by the refund.
+                ## this has to be equal to the cart_pending_balance at the time of accepting the refund.
+                ## so here sent as 10 but this is actually wrong.
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", refund: true, amount: 10, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers        
+                
+                puts response.body.to_s
+
+                expect(response.code).to eq("201")
+                
+               
+
+            end
+
+            it " -- does not create a refund request if the cart pending balance is positive or zero -- ", :pending_balance do 
+
+                ## add an item to the cart.
+                cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                cart_item.resource_id = @u.id.to_s
+                cart_item.resource_class = @u.class.name
+                cart_item.parent_id = @cart.id
+                cart_item.signed_in_resource = @u
+                cart_item.price = 10.00
+                cart_item.save            
+
+                ## prepare the cart again.
+                @cart.prepare_cart
+                expect(@cart.cart_pending_balance).to eq(10.00)
+
+                ## now try to create a refund request, and it should fail
+
+                post shopping_payments_path, {cart_id: @cart.id.to_s,payment_type: "cash", refund: true, amount: 10, :api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers        
+                
+
+
+
+                expect(response.code).to eq("422")
+
+
+            end
+
+
+            it " -- accepts a valid refund if the user is an administrator -- ", :pd => true do 
+
+            	last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+                ## create a new refund request and set it as pending.
+                payment = Shopping::Payment.new
+                
+                ## this doesn't matter while creating refunds.
+                payment.payment_type = "cheque"
+                
+                
+                payment.amount = -10.00
+                payment.refund = true
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                
+                ## need to assign this because we are bypassing the controller.
+                payment.signed_in_resource = @u
+                ps = payment.save
+                
+                ##now first assert that a refund exists whose refund status is null.
+                payment = Shopping::Payment.find(payment.id.to_s)
+                expect(payment.payment_status).to eq(nil)
+
+                ## now use the admin user to create a put request to the above payment.
+
+                ## it should set the status of the payment as accepted.
+
+                put shopping_payment_path({:id => payment.id}), {payment: {payment_status: 1, amount: -10},:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+              
+                puts response.body.to_s
+
+                payment = Shopping::Payment.find(payment.id)
+
+                expect(payment.payment_status).to eq(1)
+
+            end
+    	
+
+            it " -- before accepting a refund as an administrator it checks that there is negative pending balance -- ", :admin_negative => true do 
+
+                ## remove an item from the cart.
+                last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                ## only admin can unset, once payment has already been made.
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+                ## create a new refund request and set it as pending.
+                payment = Shopping::Payment.new
+                
+                ## this doesn't matter while creating refunds.
+                payment.payment_type = "cheque"
+                
+                ## this also doesnt matter while creating refunds.
+                payment.amount = -10.00
+                payment.refund = true
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                
+                ## need to assign this because we are bypassing the controller.
+                payment.signed_in_resource = @u
+                ps = payment.save
+                
+                ##now first assert that a refund exists whose refund status is null.
+                payment = Shopping::Payment.find(payment.id.to_s)
+                expect(payment.payment_status).to eq(nil)
+
+                ## at this stage, check the cart and expect it to have a negative balance : i.e the user deserves a refund.
+                @cart = Shopping::Cart.find(@cart.id)
+                @cart.prepare_cart
+                expect(@cart.cart_pending_balance < 0).to be_truthy
+
+
+                ## now again add another item to the cart so that the balance is no longer negative.
+                cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                cart_item.resource_id = @u.id.to_s
+                cart_item.resource_class = @u.class.name
+                cart_item.parent_id = @cart.id
+                cart_item.price = 10.00
+                cart_item.signed_in_resource = @u
+                cart_item.save            
+
+
+                ## now use the admin user to create a put request to the above payment.
+
+                ## it should not allow the payment status to be changed to anything, since the balance is now positive. basically wont allow the admin to change the status to 
+
+                put shopping_payment_path({:id => payment.id}), {payment: {payment_status: 1},:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+              
+                puts response.body.to_s
+
+                payment = Shopping::Payment.find(payment.id)
+
+                expect(payment.payment_status).to be_nil
+
+
+            end
+
+
+            it " -- after accepting a refund as an administrator, will update all pending refunds as failed" do 
+
+
+                ## remove an item from the cart.
+                last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+
+                ## now we create three refunds
+                refunds_expected_to_have_failed = []
+                3.times do 
+                    payment = Shopping::Payment.new
+                    payment.payment_type = "cheque"
+                    payment.amount = -10
+                    payment.refund = true
+                    payment.resource_id = @u.id.to_s
+                    payment.resource_class = @u.class.name.to_s
+                    payment.cart_id = @cart.id.to_s
+                    payment.signed_in_resource = @u
+                    ps = payment.save
+                    refunds_expected_to_have_failed << payment
+                end
+
+
+                ## then we accept the last one, by sending in a put request as the admin.
+
+                put shopping_payment_path({:id => refunds_expected_to_have_failed.last.id}), {payment: {payment_status: 1},:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+
+
+                ## we only keep the first two because the last one will not be deleted, we are going to be accepting the last one. 
+                refunds_expected_to_have_failed.map!{|c| c = c.id.to_s}
+                refunds_expected_to_have_failed.pop
+                ## all previous payments should be marked as successfull.
+                ## for this an after update callback can be added?
+                ## but then that will be 
+                refunds_expected_to_have_failed.each do |ref_id|
+                    expect(Shopping::Payment.find(ref_id).payment_status).to eq(0)
+                end
+
+            end
+
+                
+            it " -- attempting to 'show' a refund, if a subsequent refund was accepted, then will redirect to update this refund as failed -- ", :only_failure => true do 
+
+                ## remove an item from the cart.
+                last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+
+                ## now we create three refunds
+                refunds_expected_to_have_failed = []
+                3.times do 
+                    payment = Shopping::Payment.new
+                    payment.payment_type = "cheque"
+                    payment.amount = -10.00
+                    payment.refund = true
+                    payment.resource_id = @u.id.to_s
+                    payment.resource_class = @u.class.name.to_s
+                    payment.cart_id = @cart.id.to_s
+                    payment.signed_in_resource = @u
+                    ps = payment.save
+                    refunds_expected_to_have_failed << payment
+                end
+
+                ## sleep so that there is some time lag between creating the refunds and updating the last one as a success.
+                sleep(2)
+                
+
+                ## update the last refund as successfull. 
+                successfull_refund = refunds_expected_to_have_failed.pop 
+                successfull_refund.amount = -10
+                successfull_refund.signed_in_resource = @admin
+                successfull_refund.refund_success
+              
+                res1 = successfull_refund.save
+                
+               
+
+                ## convert the remaining two refunds into their ids.
+                refunds_expected_to_have_failed.map!{|c| c = c.id.to_s}
+                
+                ## now update the last one as nil, i.e we simulate that somehow it didnt get converted to a failure payment status when the successfull refund was accepted.
+                last_refund = Shopping::Payment.find(refunds_expected_to_have_failed.last)
+                last_refund.payment_status = nil
+                last_refund.signed_in_resource = @admin
+                last_refund.skip_callbacks = {:before_save => true, :after_save => true}
+                res = last_refund.save
+                puts "second res: #{res.to_s}"
+                ## now do update on this last refund, so that it will call refund_refresh, and we now expect it to have a 0 payment status.
+                put shopping_payment_path({:id => last_refund.id}), {:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @headers
+
+                puts response.body.to_s
+
+                last_refund = Shopping::Payment.find(last_refund.id.to_s)
+
+                expect(last_refund.payment_status).to eq(0)
+
+            end
+            
+            
+            it " -- remaining cart items are not affected after refund is approved. -- ", :refund_cart_item_status do 
+                
+
+                last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+                ## create a new refund request and set it as pending.
+                payment = Shopping::Payment.new
+                
+                ## this doesn't matter while creating refunds.
+                payment.payment_type = "cheque"
+                
+                
+                payment.amount = -10
+                payment.refund = true
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                
+                ## need to assign this because we are bypassing the controller.
+                payment.signed_in_resource = @u
+                ps = payment.save
+                
+                ##now first assert that a refund exists whose refund status is null.
+                payment = Shopping::Payment.find(payment.id.to_s)
+                expect(payment.payment_status).to eq(nil)
+
+                put shopping_payment_path({:id => payment.id}), {payment: {payment_status: 1},:api_key => @ap_key, :current_app_id => "testappid", :proxy_resource_class => @u.class.name.to_s, :proxy_resource_id => @u.id.to_s}.to_json, @admin_headers
+
+                ## take all the cart items.
+                payment = Shopping::Payment.find(payment.id.to_s)
+                expect(payment.payment_status).to eq(1) 
+                
+                Shopping::CartItem.all.each do |c_item|
+                    if c_item.id.to_s != last_cart_item.id.to_s
+                        expect(c_item.accepted).to be_truthy
+                    end
+                end           
+
+            end
+
+
+        end
+
+        context " --- update, delete, payment and refund by user -- ", :update_payment do 
+
+            before(:example) do 
+                Shopping::CartItem.delete_all
+                Shopping::Cart.delete_all
+                Shopping::Payment.delete_all
+
+                ## create a cart
+                @cart = Shopping::Cart.new
+                @cart.resource_id = @u.id.to_s
+                @cart.resource_class = @u.class.name
+                @cart.save
+
+
+                ## create five cart items and add them to the cart.
+                @created_cart_item_ids = []
+                5.times do 
+                    cart_item = Shopping::CartItem.new(attributes_for(:cart_item))
+                    cart_item.resource_id = @u.id.to_s
+                    cart_item.resource_class = @u.class.name
+                    cart_item.parent_id = @cart.id
+                    cart_item.price = 10.00
+                    cart_item.signed_in_resource = @u
+                    cart_item.save
+                    @created_cart_item_ids << cart_item.id.to_s
+                end
+            end
+
+
+
+            it " -- user cannot update a payment once made -- ", :update_payment => true do 
+
+                ## create a payment.
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 50.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.signed_in_resource = @u
+                payment.cart_id = @cart.id.to_s
+                ps = payment.save
+
+
+                ## now try to update it.
+                put shopping_payment_path({:id => payment.id}), {payment: {amount: 10.00},:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
+
+
+
+                payment = Shopping::Payment.find(payment.id.to_s)
+                expect(payment.amount).to eq(50.00)
+
+
+
+            end 
+
+            it " -- user cannot update a refund once created -- ", :update_refund => true do 
+
+                ## create a payment.
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 50.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                payment.signed_in_resource = @admin
+                payment.payment_status = 1
+                ps = payment.save
+                expect(ps).to be_truthy
+                
+
+                ## remove an item from the cart
+                last_cart_item = Shopping::CartItem.find(@created_cart_item_ids.last.to_s)
+                last_cart_item.signed_in_resource = @admin
+                last_cart_item.unset_cart
+
+                cart = Shopping::Cart.find(payment.cart_id)
+                cart.prepare_cart
+                #puts "teh cart pending balance. is."
+                #puts cart.cart_pending_balance.to_s
+
+                ## create a refund
+                ref = Shopping::Payment.new
+                ref.payment_type = "cash"
+                ref.amount = 50.00
+                ref.refund = true
+                ref.resource_id = @u.id.to_s
+                ref.resource_class = @u.class.name.to_s
+                ref.signed_in_resource = @u
+                ref.cart_id = @cart.id.to_s
+                rs = ref.save
+                #puts ref.errors.full_messages.to_s
+                expect(rs).to be_truthy
+
+                ## now try to update it.
+                put shopping_payment_path({:id => ref.id}), {payment: {refund: false},:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
+
+                ref = Shopping::Payment.find(ref.id.to_s)
+                expect(ref.refund).to be_truthy
+
+            end
+
+            it " -- user cannot delete a payment once made -- ", :delete_payment do 
+
+                ## create a payment.
+                payment = Shopping::Payment.new
+                payment.payment_type = "cash"
+                payment.amount = 50.00
+                payment.resource_id = @u.id.to_s
+                payment.resource_class = @u.class.name.to_s
+                payment.cart_id = @cart.id.to_s
+                payment.signed_in_resource = @admin
+                ps = payment.save
+                expect(ps).to be_truthy
+
+                ## now try to update it.
+                delete shopping_payment_path({:id => payment.id}),{:api_key => @ap_key, :current_app_id => "testappid"}.to_json, @headers
+
+                expect(Shopping::Payment.count).to eq(1)
+
+            end
+
+        end
+
+        context " -- payment stores accepted cart items  -- " do 
+            
+            
+        end
+
+    end
+
+end
+
+
+=begin
+
+-so basically it boils down to this->
+
+-1. 
+    before_remove - check if status is accepted, if yes, then 
+    it cannot be removed, provide a hook to override this method as per the needs.
+
+    - here only there is fork - that if removal fails, then provide:
+    on_cannot_remove_item_hook
+
+-2. 
+    after_remove - this is not done automatically. He has to request a refund, by creating a refund request.
+
+-3. provide a method to cancel all the tests in the cart, this is done by calling destroy cart - if call destroy cart, then where will we show the refund?
+    - refund should also be shown in the cart.
+
+    so you cannot destroy the cart if payments have already been made to it.
+    you can only remove items from the cart, i.e all the items.
+    and there you can show the refunds.
+
+    so before destroy cart - check if payments have been made, and if yes, then don't destroy the cart.
+
+
+-4. basically we have to make a payment to the user.
+    thats the essence.
+    so the payment should have a pay_to
+    it will also have a type, this will be the same as the last payment made by the user.
+    it will have to be done by the business seperately.
+    notification behaviour has to be defined, for eg: 
+    
+    refund can be by cheque only at this stage. 
+    the refund is successfull if the cheque is ready.
+
+    After refund success, a callback has to notify the payee, that his cheque can be picked up,
+
+    at this stage the acknowledgement proof can be picked up, saying that his payment was successfully received.
+    
+- 5. refund lifecycle.
+
+    a. first the refund is created, by the user.
+    b. before_creating the refund, check if the pending_balance is -ve, only then create the refund, otherwise not.
+    c. refund now has a status of 0, i.e pending.
+    d. before_updating refund, if the refund is being set as accepted, then it has to check if there is any negative balance and only then update it.
+       while changing such a status, it has to set the amount of the refund, and also delete any other refund requests, created before now.
+
+=end
+
+
+
+
+