razorpay 2.4.0 → 3.2.4

data/test/razorpay/test_payment.rb

@@ -5,7 +5,10 @@ module Razorpay
   class RazorpayPaymentTest < Minitest::Test
     def setup
       @payment_id = 'fake_payment_id'
-
+      @downtime_id = 'fake_downtime_id'
+      @card_id = 'card_7EZLhWkDt05n7V'
+      @transfer_id = 'trf_J0FrZYPql4riDx'
+      @refund_id = 'fake_refund_id'
       # Any request that ends with payments/payment_id
       stub_get(%r{payments\/#{@payment_id}$}, 'fake_payment')
       stub_get(/payments$/, 'payment_collection')
@@ -23,6 +26,111 @@ module Razorpay
       assert_equal 'card', payment.method, 'Payment method is accessible'
     end
 
+    def test_payments_fetch_downtime
+      stub_get( %r{payments/downtimes$}, 'downtimes_collection')
+      payments = Razorpay::Payment.fetch_payment_downtime
+      assert_instance_of Razorpay::Collection, payments, 'Payments should be an array'
+      refute_empty payments.items, 'payments should be more than one'
+    end
+    
+    def test_payments_fetch_downtime_by_id
+      stub_get( %r{payments/downtimes/#{@downtime_id}$}, 'fake_downtime')
+      payment = Razorpay::Payment.fetch_payment_downtime_by_id(@downtime_id)
+      assert_instance_of Razorpay::Entity, payment, 'Payment not an instance of Razorpay::Payment class'
+      assert_equal @downtime_id , payment.id
+    end
+    
+    def test_payments_fetch_card_details
+      stub_get( %r{payments/#{@payment_id}/card$}, 'fake_card')
+      card = Razorpay::Payment.fetch_card_details(@payment_id)
+      assert_instance_of Razorpay::Card, card, 'Card not an instance of Razorpay::Card class'
+      assert_equal @card_id , card.id
+    end 
+
+    def test_payments_fetch_multiple_refund_for_payment
+      stub_get( %r{payments/#{@payment_id}/refunds$}, 'refund_collection',{})
+      payments = Razorpay::Payment.fetch_multiple_refund(@payment_id,{})
+      assert_instance_of Razorpay::Collection, payments, 'Payment not an instance of Razorpay::Payment class'
+      assert !payments.items.empty?, 'payments should be more than one'
+    end
+
+    def test_payments_fetch_transfers
+      stub_get(%r{payments/#{@payment_id}/transfers$}, 'transfers_collection')
+      transfers = Razorpay::Payment.fetch(@payment_id).fetch_transfer
+      assert_instance_of Razorpay::Collection, transfers, 'Transfers should be an array'
+      assert !transfers.items.empty?, 'transfers should be more than one'
+    end 
+
+    def test_payments_post_transfers
+      param_attr = {
+        "transfers": [
+          {
+            "account": "acc_CPRsN1LkFccllA",
+            "amount": 100,
+            "currency": "INR",
+            "notes": {
+              "name": "Gaurav Kumar",
+              "roll_no": "IEC2011025"
+            },
+            "linked_account_notes": [
+              "roll_no"
+            ],
+            "on_hold": true,
+            "on_hold_until": 1671222870
+          },
+          {
+            "account": "acc_CNo3jSI8OkFJJJ",
+            "amount": 100,
+            "currency": "INR",
+            "notes": {
+              "name": "Saurav Kumar",
+              "roll_no": "IEC2011026"
+            },
+            "linked_account_notes": [
+              "roll_no"
+            ],
+            "on_hold": false
+          }
+        ]
+      }
+
+      stub_post(%r{payments/#{@payment_id}/transfers$}, 'fake_transfer', param_attr.to_json)
+      transfer = Razorpay::Payment.fetch(@payment_id).transfer(param_attr.to_json)
+      assert_instance_of Razorpay::Transfer, transfer, 'Transfer not an instance of Razorpay::Transfer class'
+      assert transfer.on_hold
+    end 
+
+    def test_payments_fetch_refunds
+      stub_get(%r{payments/#{@payment_id}/refunds/#{@refund_id}$}, 'fake_refund')
+      refund = Razorpay::Payment.fetch(@payment_id).fetch_refund(@refund_id)
+      assert_instance_of Razorpay::Refund, refund, 'Refund not an instance of Razorpay::Refund class'
+      assert_equal @refund_id, refund.id
+    end
+
+    def test_payment_create_recurring
+      
+       payment_attr = {
+          "email": "gaurav.kumar@example.com",
+          "contact": "9123456789",
+          "amount": 1000,
+          "currency": "INR",
+          "order_id": "order_1Aa00000000002",
+          "customer_id": "cust_1Aa00000000001",
+          "token": "token_1Aa00000000001",
+          "recurring": "1",
+          "description": "Creating recurring payment for Gaurav Kumar",
+          "notes": {
+            "note_key 1": "Beam me up Scotty",
+            "note_key 2": "Tea. Earl Gray. Hot."
+          }
+       }
+      
+       stub_post(%r{payments/create/recurring$}, 'fake_recurring', payment_attr.to_json) 
+       payment = Razorpay::Payment.create_recurring_payment payment_attr.to_json
+       assert_equal 'pay_1Aa00000000001', payment.razorpay_payment_id
+      
+    end
+
     def test_all_payments
       payments = Razorpay::Payment.all
       assert_instance_of Razorpay::Collection, payments, 'Payments should be an array'
@@ -40,7 +148,7 @@ module Razorpay
       stub_post(%r{payments/#{@payment_id}/refund$}, 'fake_refund', {})
       refund = Razorpay::Payment.fetch(@payment_id).refund
       assert_instance_of Razorpay::Refund, refund
-      assert_equal refund.payment_id, @payment_id
+      assert_equal refund.payment_id, "pay_FFX5FdEYx8jPwA"
     end
 
     def test_payment_refund!
@@ -56,21 +164,30 @@ module Razorpay
       stub_post(%r{payments/#{@payment_id}/refund$}, 'fake_refund', 'amount=2000')
       refund = Razorpay::Payment.fetch(@payment_id).refund(amount: 2000)
       assert_instance_of Razorpay::Refund, refund
-      assert_equal refund.payment_id, @payment_id
+      assert_equal refund.payment_id, "pay_FFX5FdEYx8jPwA"
       assert_equal refund.amount, 2000
     end
 
     def test_payment_capture
-      stub_post(%r{payments/#{@payment_id}/capture$}, 'fake_captured_payment', 'amount=5100')
-      payment = Razorpay::Payment.fetch(@payment_id)
-      payment = payment.capture(amount: 5100)
+
+      para_attr = {
+        amount: 1000,
+        currency: 'INR'
+      }
+
+      stub_post(%r{payments/#{@payment_id}/capture$}, 'fake_captured_payment', para_attr.to_json)
+      payment = Razorpay::Payment.fetch(@payment_id).capture(para_attr.to_json)
       assert_equal 'captured', payment.status
     end
 
     def test_payment_capture!
-      stub_post(%r{payments/#{@payment_id}/capture$}, 'fake_captured_payment', 'amount=5100')
+      para_attr = {
+       amount: 1000,
+       currency: "INR"
+      }
+      stub_post(%r{payments/#{@payment_id}/capture$}, 'fake_captured_payment', para_attr.to_json)
       payment = Razorpay::Payment.fetch(@payment_id)
-      payment.capture!(amount: 5100)
+      payment.capture!(para_attr.to_json)
       assert_equal 'captured', payment.status
     end
 
@@ -79,5 +196,130 @@ module Razorpay
       payment = Razorpay::Payment.capture(@payment_id, amount: 5100)
       assert_equal 'captured', payment.status
     end
-  end
+
+    def test_otp_generate
+      payment_id = 'pay_FVmAstJWfsD3SO'
+      stub_post(%r{payments/#{payment_id}/otp_generate$}, 'fake_otp_generate', {})
+      payment = Razorpay::Payment.otp_generate(payment_id)
+      assert_equal payment_id, payment.razorpay_payment_id
+    end
+
+    def test_otp_submit
+      param_attr = {
+        otp: "123456"
+      }
+      stub_post(%r{payments/#{@payment_id}/otp/submit$}, 'fake_otp_submit', param_attr.to_json)
+      payment = Razorpay::Payment.fetch(@payment_id).otp_submit(param_attr.to_json)
+      assert_equal @payment_id, payment.razorpay_payment_id
+    end
+
+    def test_otp_resend
+      stub_post(%r{payments/#{@payment_id}/otp/resend$}, 'fake_otp_resend', {})
+      payment = Razorpay::Payment.fetch(@payment_id).otp_resend
+      assert_equal @payment_id, payment.razorpay_payment_id
+    end 
+
+    def test_payment_edit
+
+      payment_attr = {
+        "notes": {
+          "notes_key_1": 'Beam me up Scotty.',
+          "notes_key_2": 'Engage'
+        }
+      }
+      stub_patch(%r{payments\/#{@payment_id}$}, 'fake_update_payment', payment_attr.to_json)
+      payment = Razorpay::Payment.fetch(@payment_id).edit(payment_attr.to_json)
+      assert_equal 'payment', payment.entity
+      assert_equal 'Beam me up Scotty.', payment.notes["notes_key_1"]
+    end
+
+    def test_payment_create_payment_json
+
+      payment_attr = {
+        amount: '100',
+        currency: 'INR',
+        email: 'gaurav.kumar@example.com',
+        contact: '9123456789',
+        order_id: 'order_EAkbvXiCJlwhHR',
+        method: 'card',
+        card: {
+          number: '4854980604708430',
+          cvv: '123',
+          expiry_month: '12',
+          expiry_year: '21',
+          name: 'Gaurav Kumar'
+        }
+      }
+
+      stub_post(%r{payments/create/json$}, 'create_json_payment',payment_attr.to_json) 
+      payment = Razorpay::Payment.create_json_payment payment_attr.to_json 
+      assert_equal 'pay_FVmAstJWfsD3SO', payment.razorpay_payment_id
+     end
+     def test_create_upi
+
+      param_attr = {
+        "amount": 200,
+        "currency": "INR",
+        "order_id": "order_GAWRjlWkVcRh0V",
+        "email": "gaurav.kumar@example.com",
+        "contact": "9123456789",
+        "method": "upi",
+        "customer_id": "cust_EIW4T2etiweBmG",
+        "save": 1,
+        "ip": "192.168.0.103",
+        "referer": "http",
+        "user_agent": "Mozilla/5.0",
+        "description": "Test flow",
+        "notes": {
+          "note_key": "value1"
+        },
+        "upi": {
+          "flow": "collect",
+          "vpa": "gauravkumar@exampleupi",
+          "expiry_time": 5
+        }
+      }
+
+      stub_post(%r{payments/create/upi$}, 'fake_create_upi_payment',param_attr.to_json) 
+      payment = Razorpay::Payment.create_upi param_attr.to_json 
+      assert_equal 'pay_FVmAstJWfsD3SO', payment.razorpay_payment_id
+    end
+
+    def test_payment_methods
+      stub_get(/methods$/, 'payment_methods_collection') 
+      methods = Razorpay::PaymentMethods.all
+      assert_equal 'methods', methods.entity
+    end
+    
+    def test_validate_vpa
+      param_attr = {
+        "vpa": "gauravkumar@exampleupi"
+      }
+      stub_post(%r{payments/validate/vpa$}, 'fake_validate_vpa',param_attr.to_json) 
+      payment = Razorpay::Payment.validate_vpa param_attr.to_json 
+      assert_equal param_attr[:vpa], payment.vpa
+    end
+    
+    def test_expand_details_emi
+      stub_get("#{BASE_URI}/v1/payments/#{@payment_id}/?expand[]=emi", 'fake_payment_expanded_details')
+      payment = Razorpay::Payment.expand_details @payment_id
+      assert_equal @payment_id, payment.id
+    end
+
+    def test_expand_details_card
+      stub_get("#{BASE_URI}/v1/payments/#{@payment_id}/?expand[]=card", 'fake_payment_expanded_details')
+      payment = Razorpay::Payment.expand_details @payment_id
+      assert_equal @payment_id, payment.id
+    end
+
+    def test_expand_details_failure
+      stub_get(%r{payments\/#{@payment_id}$}, 'payment_error')
+      assert_raises(Razorpay::Error) do
+        payment = Razorpay::Payment.expand_details(@payment_id)
+        if payment.error
+            raise Razorpay::Error.new, payment.error['code']
+        end
+      end 
+    end
+  end 
 end

data/test/razorpay/test_payment_link.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::PaymentLink
+  class RazorpayPaymentLinkTest < Minitest::Test
+    def setup
+      @payment_link_id = 'plink_J9feMU9xqHQVWX'
+
+      # Any request that ends with payment_link/payment_link_id
+      stub_get(%r{payment_links/#{@payment_link_id}$}, 'fake_payment_link')
+      stub_get(/payment_links$/, 'payment_link_collection')
+    end
+
+    def test_payment_link_should_be_defined
+      refute_nil Razorpay::PaymentLink
+    end
+
+    def test_payment_link_should_be_created
+      param_attr = {
+        "amount": 2244,
+        "currency": "INR",
+        "accept_partial": true,
+        "first_min_partial_amount": 100,
+        "description": "For XYZ purpose",
+        "customer": {
+          "name": "Gaurav Kumar",
+          "email": "gaurav.kumar@example.com",
+          "contact": "+919999999999"
+        },
+        "notify": {
+          "sms": true,
+          "email": true
+        },
+        "reminder_enable": true,
+        "notes": {
+          "policy_name": "Jeevan Bima"
+        },
+        "callback_url": "https://example-callback-url.com/",
+        "callback_method": "get"
+      }
+
+      stub_post(/payment_links$/, 'fake_payment_link', param_attr.to_json)
+      payment_link = Razorpay::PaymentLink.create param_attr.to_json 
+      assert_equal @payment_link_id, payment_link.id
+    end
+
+    def test_edit_payment_link
+      para_attr ={
+        "reference_id": "TS35",
+        "expire_by": 1653347540,
+        "reminder_enable":false,
+        "notes":{
+          "policy_name": "Jeevan Saral"
+        }
+      } 
+
+      stub_patch(%r{payment_links/#{@payment_link_id}$}, 'fake_payment_link', para_attr.to_json)
+      payment_link = Razorpay::PaymentLink.edit(@payment_link_id,para_attr.to_json)
+      assert_instance_of Razorpay::Entity, payment_link
+      assert true, payment_link.accept_partial
+    end
+
+    def test_fetch_all_payment_link
+      stub_get(/payment_links$/, 'payment_link_collection')
+      payment_link = Razorpay::PaymentLink.all
+      assert_instance_of Razorpay::Collection, payment_link
+    end
+
+    def test_fetch_specific_payment
+      stub_get(%r{payment_links/#{@payment_link_id}$}, 'fake_payment_link')  
+      payment_link = Razorpay::PaymentLink.fetch(@payment_link_id)
+      assert_instance_of Razorpay::Entity, payment_link
+      assert_equal payment_link.id, @payment_link_id
+    end
+    
+   def test_notify_by_id
+      stub_post(%r{payment_links/#{@payment_link_id}/notify_by/email$}, 'payment_link_response',{})  
+      payment_link = Razorpay::PaymentLink.notify_by(@payment_link_id,"email")
+      assert_instance_of Razorpay::Entity, payment_link
+      assert true, payment_link.success
+   end
+  end
+end

data/test/razorpay/test_plan.rb

@@ -42,9 +42,9 @@ module Razorpay
         notes: { identifier: 'plan_monthly_1000' }
       }
 
-      stub_post(/plans$/, 'fake_plan', create_plan_stub_url_params)
+      stub_post(/plans$/, 'fake_plan', plan_attrs.to_json)
 
-      plan = Razorpay::Plan.create plan_attrs
+      plan = Razorpay::Plan.create plan_attrs.to_json
 
       assert_equal 1, plan.interval, 'Plan interval is accessible'
       assert_equal 'monthly', plan.period, 'Plan period is accessible'

data/test/razorpay/test_product.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::Product
+  class RazorpayProductonTest < Minitest::Test
+    class Product < Razorpay::Entity; end
+
+    def setup
+      @product_id = 'acc_prd_00000000000001'
+      @account_id = 'acc_00000000000001'
+      @product_name = 'payment_gateway'
+      @tnc_id = 'tnc_map_00000000000001'
+      # Any request that ends with product_id
+      stub_get(%r{/v2/accounts\/#{Regexp.quote(@account_id)}/products\/#{Regexp.quote(@product_id)}$}, 'fake_product')
+    end
+
+    def test_product_should_be_defined
+      refute_nil Razorpay::Product
+    end
+
+    def test_product_should_be_available
+      product = Razorpay::Product.fetch(@account_id, @product_id)
+      assert_instance_of Razorpay::Entity, product, 'product not an instance of Entity class'
+      assert_equal @product_id, product.id, 'Product IDs do not match'
+      assert_equal @product_name, product.product_name, 'product name is accessible'
+    end
+
+    def test_product_request_product_configuration
+
+      payload = create_product_payload()
+      stub_post(%r{accounts/#{@account_id}/products$}, 'fake_product', payload.to_json)
+
+      product = Razorpay::Product.request_product_configuration(@account_id, payload.to_json)
+      assert_instance_of Razorpay::Entity, product, 'Product not an instance of Entity class'
+      assert_equal @product_id, product.id, 'Product IDs do not match'
+      assert_equal @product_name, product.product_name, 'product name is accessible'
+    end
+
+    def test_product_edit
+
+      payload = create_product_payload()
+      stub_patch(%r{accounts/#{@account_id}/products/#{@product_id}$}, 'fake_product', payload.to_json)
+
+      product = Razorpay::Product.edit(@account_id, @product_id, payload.to_json)
+      assert_instance_of Razorpay::Entity, product, 'Product not an instance of Entity class'
+      assert_equal @product_id, product.id, 'Product IDs do not match'
+      assert_equal @product_name, product.product_name, 'product name is accessible'
+    end
+
+    def test_product_fetchTnc
+      product_name = "payments"  
+
+      stub_get("#{BASE_URI}/v2/products/#{product_name}/tnc", 'fetch_tnc')  
+      product = Razorpay::Product.fetch_tnc(product_name)
+      assert_instance_of Razorpay::Entity, product, 'Product not an instance of Entity class'
+      assert_equal @tnc_id, product.id, 'Product IDs do not match'
+    end
+
+    def create_product_payload
+        return {
+          "product_name": "payment_gateway",
+          "tnc_accepted": true,
+          "ip": "233.233.233.234"
+        }
+    end
+  end
+end

data/test/razorpay/test_qr_code.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::QrCode
+  class RazorpayQrCodeTest < Minitest::Test
+    def setup
+      @qrcode_id = 'qr_HMsVL8HOpbMcjU'
+      @customer_id = 'cust_HKsR5se84c5LTO'
+      # Any request that ends with qrcode/qrcode_id
+      stub_get(%r{payments/qr_codes/#{@qrcode_id}$}, 'fake_qrcode')
+      stub_get(%r{payments/qr_codes$}, 'qrcode_collection')
+    end
+
+    def test_qrcode_should_be_defined
+      refute_nil Razorpay::QrCode
+    end
+
+    def test_qrcode_should_be_created
+      para_attr = {
+        "type": "upi_qr",
+        "name": "Store_1",
+        "usage": "single_use",
+        "fixed_amount": true,
+        "payment_amount": 300,
+        "description": "For Store 1",
+        "customer_id": "cust_HKsR5se84c5LTO",
+        "close_by": 1681615838,
+        "notes": {
+          "purpose": "Test UPI QR code notes"
+        }
+      }  
+      stub_post(%r{/payments/qr_codes$}, 'fake_qrcode', para_attr.to_json)
+      qr_code = Razorpay::QrCode.create(para_attr.to_json)
+
+       assert_equal @qrcode_id, qr_code.id
+       assert_equal @customer_id, qr_code.customer_id
+    end
+
+    def test_fetch_all_qcode
+      qr_code = Razorpay::QrCode.all
+      assert_instance_of Razorpay::Collection, qr_code
+    end
+
+    def test_fetch_specific_qrcode
+      qr_code = Razorpay::QrCode.fetch(@qrcode_id)
+      assert_instance_of Razorpay::QrCode, qr_code
+      assert_equal qr_code.id, @qrcode_id
+    end
+
+    def test_qrcode_close
+      stub_post(%r{payments/qr_codes/#{@qrcode_id}/close$}, 'fake_qrcode_close',{})  
+      qr_code = Razorpay::QrCode.fetch(@qrcode_id).close
+      assert_instance_of Razorpay::QrCode, qr_code
+      assert_equal qr_code.id, @qrcode_id
+    end
+
+    def test_qrcode_fetch_payments
+      stub_get(%r{payments/qr_codes/#{@qrcode_id}/payments$}, 'qrcode_payments_collection',{})  
+      qr_code = Razorpay::QrCode.fetch(@qrcode_id).fetch_payments()
+      assert_instance_of Razorpay::Collection, qr_code
+    end
+  end
+end

data/test/razorpay/test_razorpay.rb

@@ -22,7 +22,7 @@ module Razorpay
       stub_get(/$/, 'hello_response')
       Razorpay.headers = custom_headers
       Razorpay::Request.new('dummy').make_test_request
-      user_agent = "Razorpay-Ruby/#{Razorpay::VERSION}"
+      user_agent = "Razorpay-Ruby/#{Razorpay::VERSION}; Ruby/#{RUBY_VERSION}"
       headers = { 'User-Agent' => user_agent, 'Authorization' => 'Basic a2V5X2lkOmtleV9zZWNyZXQ=' }
       headers = headers.merge(custom_headers)
       assert_requested :get, 'https://api.razorpay.com/',
@@ -43,11 +43,28 @@ module Razorpay
     def test_auth_header_and_user_agent
       stub_get(/$/, 'hello_response')
       Razorpay::Request.new('dummy').make_test_request
-      user_agent = "Razorpay-Ruby/#{Razorpay::VERSION}"
+      user_agent = "Razorpay-Ruby/#{Razorpay::VERSION}; Ruby/#{RUBY_VERSION}"
       headers = { 'User-Agent' => user_agent, 'Authorization' => 'Basic a2V5X2lkOmtleV9zZWNyZXQ=' }
       assert_requested :get, 'https://api.razorpay.com/',
                        headers: headers,
                        times: 1
     end
+
+    def test_oauth_setup
+      Razorpay.setup_with_oauth('access_token')
+      assert_equal 'access_token', Razorpay.access_token
+    end
+
+    # # We mock this request
+    def test_auth_header_and_user_agent_for_oauth
+      stub_get(/$/, 'hello_response')
+      Razorpay.setup_with_oauth('access_token')
+      Razorpay::Request.new('dummy').make_test_request
+      user_agent = "Razorpay-Ruby/#{Razorpay::VERSION}; Ruby/#{RUBY_VERSION}"
+      headers = { 'User-Agent' => user_agent, 'Authorization' => 'Bearer access_token' }
+      assert_requested :get, 'https://api.razorpay.com/',
+                       headers: headers,
+                       times: 1
+    end
   end
 end

data/test/razorpay/test_refund.rb

@@ -36,7 +36,21 @@ module Razorpay
       stub_post(/refunds$/, 'fake_refund', "payment_id=#{@payment_id}")
       refund = Razorpay::Refund.create(payment_id: @payment_id)
       assert_instance_of Razorpay::Refund, refund
-      assert_equal refund.payment_id, @payment_id
+      assert_equal refund.id, @refund_id
+    end
+
+    def test_edit_refund
+      para_attr = {
+        "notes": {
+          "notes_key_1":"Beam me up Scotty.",
+          "notes_key_2":"Engage"
+        }
+      }
+      stub_patch(%r{/refunds/#{@refund_id}$}, 'fake_refund', para_attr.to_json)
+      refund = Razorpay::Refund.fetch(@refund_id).edit(para_attr.to_json)
+      assert_instance_of Razorpay::Refund, refund
+      assert_equal refund.id, @refund_id
     end
-  end
+  end  
 end
+

data/test/razorpay/test_settlement.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::Settlement
+  class RazorpaySettlementTest < Minitest::Test
+    class Item < Razorpay::Entity; end
+
+    def setup
+      @settlement_id = 'setl_DGlQ1Rj8os78Ec'
+      @settlement_ondemand_id = 'setlod_FNj7g2YS5J67Rz'
+      @addon_id = 'ao_IrSY3UIqDRx7df'
+
+      # Any request that ends with settlement/settlement_id
+      stub_get(%r{settlements\/#{Regexp.quote(@settlement_id)}$}, 'fake_settlement')
+    end
+
+    def test_settlement_should_be_defined
+      refute_nil Razorpay::Settlement
+    end
+
+    def test_settlement_should_be_available
+      settlement = Razorpay::Settlement.fetch(@settlement_id)
+      assert_instance_of Razorpay::Settlement, settlement, 'Settlement not an instance of Settlement class'
+      assert_equal @settlement_id, settlement.id, 'Settlement IDs do not match'
+    end
+
+    def test_fetch_all_settlement
+      stub_get(/settlements$/, 'settlement_collection')
+      settlement = Razorpay::Settlement.all
+      assert_instance_of Razorpay::Collection, settlement, 'Settlement should be an array'
+      refute_empty settlement.items, 'Settlement should be more than one'
+    end
+
+    def test_settlement_reports
+      para_attr = {
+        "year": 2022,
+        "month":12
+      }  
+      stub_get("#{BASE_URI}/v1/settlements/recon/combined?month=12&year=2022", 'settlement_report_collection')
+      settlement = Razorpay::Settlement.reports(para_attr)
+      assert_instance_of Razorpay::Collection, settlement, 'Settlement not an instance of Settlement class'
+      refute_empty settlement.items, 'Settlement should be more than one'
+    end
+
+    def test_settlement_should_be_created_on_demand
+        para_attr = {
+            "amount": 1221,
+            "settle_full_balance": false,
+            "description": "Testing",
+            "notes": {
+              "notes_key_1": "Tea, Earl Grey, Hot",
+              "notes_key_2": "Tea, Earl Grey… decaf."
+            }
+          }
+
+        stub_post( %r{settlements/ondemand$},'fake_settlement_on_demand',para_attr.to_json)
+        settlement = Razorpay::Settlement.create para_attr.to_json
+        assert_instance_of Razorpay::Settlement, settlement, 'Settlement should be an array'
+        assert_equal @settlement_id , settlement.id
+    end
+    
+    def test_fetch_all_instant_settlement
+      stub_get(%r{settlements/ondemand$}, 'settlement_instant_collection')
+      settlement = Razorpay::Settlement.fetch_all_ondemand_settlement
+      assert_instance_of Razorpay::Collection, settlement, 'Settlement should be an array'
+      refute_empty settlement.items, 'Settlement should be more than one'
+    end
+
+    def test_fetch_ondemand_settle_by_id
+      stub_get(%r{settlements/ondemand/#{@settlement_id}$}, 'fake_instant_settlement')  
+      settlement = Razorpay::Settlement.fetch_ondemand_settlement_by_id(@settlement_id)
+      assert_equal @settlement_ondemand_id, settlement.id, 'Settlement IDs do not match'
+      refute settlement.settle_full_balance  
+    end
+  end
+end