razorpay 2.4.1 → 3.0.0

data/test/razorpay/test_fund_account.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::FundAccount
+  class RazorpayFundAccountTest < Minitest::Test
+    def setup
+      @customer_id = 'cust_J3oSNi1KgzqVEX'
+      @fund_account_id = 'fa_J8B38pGr1Tfv8k'
+    end
+
+    def test_fund_account_should_be_defined
+      refute_nil Razorpay::FundAccount
+    end
+
+    def test_fund_account_should_be_created
+
+      param_attr = {
+        "customer_id": "cust_Aa000000000001",
+        "account_type": "bank_account",
+        "bank_account": {
+          "name": "Gaurav Kumar",
+          "account_number": "11214311215411",
+          "ifsc": "HDFC0000053"
+        }
+      }   
+
+      stub_post(/fund_accounts$/, 'fake_fund_account', param_attr.to_json)
+      fund_account = Razorpay::FundAccount.create param_attr.to_json
+      assert_equal @customer_id, fund_account.customer_id
+      assert_equal @fund_account_id, fund_account.id
+    end
+    
+    def test_fetch_all_fund_accounts
+      
+      para_attr = {"customer_id": @customer_id}
+      stub_get(/fund_accounts/, 'fund_collection', para_attr.to_json)
+      fund_accounts = Razorpay::FundAccount.all(para_attr.to_json)
+      assert_instance_of Razorpay::Collection, fund_accounts, 'FundAccounts should be an array'
+      assert !fund_accounts.items.empty?, 'FundAccounts should be more than one'
+    end
+  end
+end

data/test/razorpay/test_invoice.rb

@@ -5,7 +5,7 @@ module Razorpay
   class RazorpayInvoiceTest < Minitest::Test
     def setup
       @invoice_id = 'inv_6vRZmJYFAG1mNq'
-
+      @medium = "email"
       # Any request that ends with invoices/invoice_id
       stub_get(%r{invoices/#{@invoice_id}$}, 'fake_invoice')
     end
@@ -117,7 +117,6 @@ module Razorpay
       refute_nil invoice.invoice_number
     end
 
-    private
 
     def assert_invoice_details(invoice)
       assert_equal 'cust_6vRXClWqnLhV14', invoice.customer_id
@@ -126,5 +125,19 @@ module Razorpay
       assert_equal 'Test description', invoice.description
       assert_equal 'invoice', invoice.type
     end
+
+    def test_delete_specific_invoice
+      stub_delete(%r{invoices/#{@invoice_id}$}, 'empty')
+      invoice = Razorpay::Invoice.delete(@invoice_id)
+      assert_instance_of Razorpay::Entity, invoice, 'invoice not an instance of Razorpay::Invoice class'
+      refute_nil invoice
+    end
+
+    def test_invoice_notifyBy
+      stub_post(%r{invoices/#{@invoice_id}/notify_by/#{@medium}$}, 'success', {})
+      invoice = Razorpay::Invoice.notify_by(@invoice_id,@medium)
+      assert_instance_of Razorpay::Entity, invoice, 'invoice not an instance of Razorpay::Invoice class'
+      assert invoice
+    end
   end
 end

data/test/razorpay/test_item.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::Item
+  class RazorpayItemTest < Minitest::Test
+    def setup
+      @item_id = 'item_JDcbIdX9xojCje'
+
+      # Any request that ends with items/item_id
+      stub_get(%r{items/#{@item_id}$}, 'fake_item')
+      stub_get(/items$/, 'item_collection')
+    end
+
+    def test_item_should_be_defined
+      refute_nil Razorpay::Item
+    end
+
+    def test_item_should_be_created
+      
+      param_attr = {
+        "name": "Book / English August",
+        "description": "An indian story, Booker prize winner.",
+        "amount": 20000,
+        "currency": "INR"
+      } 
+
+      stub_post(/items$/, 'fake_item', param_attr.to_json)
+      items = Razorpay::Item.create(param_attr.to_json)
+      assert_equal @item_id, items.id
+      assert_equal true, items.active
+    end
+
+    def test_edit_items
+      
+       param_attr = {
+        "name": "Book / English August",
+        "description": "An indian story, Booker prize winner.",
+        "amount": 20000,
+        "currency": "INR"
+       }
+
+      stub_patch(%r{items/#{@item_id}$}, 'fake_item', param_attr.to_json)
+      item = Razorpay::Item.edit(@item_id, param_attr.to_json)
+      assert_instance_of Razorpay::Entity, item
+      assert_equal @item_id, item.id, 'Item IDs do not match'
+    end
+
+    def test_fetch_all_items
+      items = Razorpay::Item.all
+      assert_instance_of Razorpay::Collection, items, 'Items should be an array'
+      refute_empty items.items, 'Items should be more than one'
+    end
+
+    def test_fetch_specific_item
+      item = Razorpay::Item.fetch(@item_id)
+      assert_instance_of Razorpay::Entity, item
+      assert_equal @item_id, item.id, 'Item IDs do not match'
+    end
+ 
+    def test_delete_item
+      stub_delete(%r{items/#{@item_id}$}, 'empty')
+      item = Razorpay::Item.delete(@item_id)
+      assert_instance_of Razorpay::Entity, item
+    end
+  end
+end

data/test/razorpay/test_order.rb

@@ -5,7 +5,7 @@ module Razorpay
   class RazorpayOrderTest < Minitest::Test
     def setup
       @order_id = 'order_50sX9hGHZJvjjI'
-
+      @transfer_id = 'trf_DSkl2lXWbiADZG'
       # Any request that ends with orders/order_id
       stub_get(%r{orders/#{@order_id}$}, 'fake_order')
     end
@@ -44,5 +44,28 @@ module Razorpay
       assert !payments.items.empty?, 'payments should be more than one'
       assert_equal 'pay_50sbkZA9AcyE5a', payments.items[0]['id'], 'payment id should match'
     end
+
+   def test_edit_order
+      param_attr = {
+        "notes": {
+          "key1": "value3",
+          "key2": "value2"
+        }
+      }
+     
+      stub_patch(%r{orders/#{@order_id}$}, 'fake_order', param_attr.to_json)
+      order = Razorpay::Order.edit(@order_id, param_attr.to_json)
+      assert_instance_of Razorpay::Order, order, 'order not an instance of Razorpay::Order class'
+      assert_equal @order_id, order.id, 'order IDs do not match'
+   end
+
+   def test_fetch_order_transfers
+    stub_get("#{BASE_URI}orders/#{@order_id}/?expand[]=transfers&status", 'fake_order_transfers')
+    order = Razorpay::Order.fetch_transfer_order(@order_id)
+    assert_instance_of Razorpay::Order, order, 'order not an instance of Razorpay::Order class'
+    assert_equal @order_id, order.id, 'order IDs do not match'
+    refute_empty order.transfers["items"]
+    assert_equal @transfer_id, order.transfers["items"][0]["id"]
+   end 
   end
 end

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,64 @@ module Razorpay
       payment = Razorpay::Payment.capture(@payment_id, amount: 5100)
       assert_equal 'captured', payment.status
     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
+
+    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
+   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_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_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}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