razorruby 3.0.1

data/test/razorpay/test_invoice.rb

@@ -0,0 +1,143 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::Invoice
+  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
+
+    def test_invoice_should_be_defined
+      refute_nil Razorpay::Invoice
+    end
+
+    def test_invoice_should_be_created
+      stub_post(/invoices$/, 'fake_invoice', 'customer_id=cust_6vRXClWqnLhV14&'\
+                'amount=100&currency=INR&description=Test%20description&type=link')
+      invoice = Razorpay::Invoice.create customer_id: 'cust_6vRXClWqnLhV14',
+                                         amount: 100, currency: 'INR',
+                                         description: 'Test description',
+                                         type: 'link'
+
+      assert_equal 'cust_6vRXClWqnLhV14', invoice.customer_id
+      assert_equal 100, invoice.amount
+      assert_equal 'INR', invoice.currency
+      assert_equal 'Test description', invoice.description
+      assert_equal 'link', invoice.type
+    end
+
+    def test_invoices_should_be_fetched
+      invoice = Razorpay::Invoice.fetch(@invoice_id)
+      assert_instance_of Razorpay::Invoice, invoice, 'invoice not an instance of Razorpay::Invoice class'
+      assert_equal @invoice_id, invoice.id, 'invoice IDs do not match'
+    end
+
+    def test_fetching_all_invoices
+      stub_get(/invoices$/, 'invoice_collection')
+      invoices = Razorpay::Invoice.all
+      assert_instance_of Razorpay::Collection, invoices, 'Invoices should be an array'
+      assert !invoices.items.empty?, 'invoices should be more than one'
+    end
+
+    def test_invoice_can_be_issued_by_invoice_id
+      stub_post(%r{invoices\/#{@invoice_id}\/issue$}, 'issue_invoice', {})
+      invoice = Razorpay::Invoice.issue(@invoice_id)
+
+      assert_equal 'issued', invoice.status
+      refute_nil invoice.issued_at
+
+      assert_invoice_details(invoice)
+    end
+
+    def test_invoice_can_be_issued_by_invoice_instance
+      stub_post(%r{invoices\/#{@invoice_id}\/issue$}, 'issue_invoice', {})
+      invoice = Razorpay::Invoice.fetch(@invoice_id)
+
+      assert_instance_of Razorpay::Invoice, invoice, 'invoice not an instance of Razorpay::Invoice class'
+
+      invoice = invoice.issue
+
+      assert_equal 'issued', invoice.status
+      refute_nil invoice.issued_at
+
+      assert_invoice_details(invoice)
+    end
+
+    def test_invoice_can_be_issued_by_invoice_instance!
+      stub_post(%r{invoices\/#{@invoice_id}\/issue$}, 'issue_invoice', {})
+      invoice = Razorpay::Invoice.fetch(@invoice_id)
+      invoice.issue!
+      assert_equal 'issued', invoice.status
+      refute_nil invoice.issued_at
+    end
+
+    def test_invoice_can_be_cancelled_by_invoice_id
+      stub_post(%r{invoices\/#{@invoice_id}\/cancel$}, 'cancel_invoice', {})
+      invoice = Razorpay::Invoice.cancel(@invoice_id)
+
+      assert_equal 'cancelled', invoice.status
+      refute_nil invoice.cancelled_at
+
+      assert_invoice_details(invoice)
+    end
+
+    def test_invoice_can_be_cancelled_by_invoice_instance
+      stub_post(%r{invoices\/#{@invoice_id}\/cancel$}, 'cancel_invoice', {})
+      invoice = Razorpay::Invoice.fetch(@invoice_id)
+
+      assert_instance_of Razorpay::Invoice, invoice, 'invoice not an instance of Razorpay::Invoice class'
+
+      invoice = invoice.cancel
+
+      assert_equal 'cancelled', invoice.status
+      refute_nil invoice.cancelled_at
+
+      assert_invoice_details(invoice)
+    end
+
+    def test_invoice_can_be_cancelled_by_invoice_instance!
+      stub_post(%r{invoices\/#{@invoice_id}\/cancel$}, 'cancel_invoice', {})
+      invoice = Razorpay::Invoice.fetch(@invoice_id)
+      invoice.cancel!
+      assert_equal 'cancelled', invoice.status
+      refute_nil invoice.cancelled_at
+    end
+
+    def test_edit_invoice!
+      invoice = Razorpay::Invoice.fetch(@invoice_id)
+      assert_instance_of Razorpay::Invoice, invoice, 'invoice not an instance of Razorpay::Invoice class'
+      assert_nil invoice.invoice_number
+      update_invoice_data = { invoice_number: '12345678' }
+      stub_patch(%r{invoices/#{@invoice_id}$}, 'update_invoice', update_invoice_data)
+      invoice.edit!(update_invoice_data)
+      assert_instance_of Razorpay::Invoice, invoice, 'invoice not an instance of Razorpay::Invoice class'
+      refute_nil invoice.invoice_number
+    end
+
+
+    def assert_invoice_details(invoice)
+      assert_equal 'cust_6vRXClWqnLhV14', invoice.customer_id
+      assert_equal 100, invoice.amount
+      assert_equal 'INR', invoice.currency
+      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

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::Order
+  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
+
+    def test_order_should_be_defined
+      refute_nil Razorpay::Order
+    end
+
+    def test_order_should_be_created
+      stub_post(/orders$/, 'fake_order', 'amount=5000&currency=INR&receipt=TEST')
+      order = Razorpay::Order.create amount: 5000, currency: 'INR', receipt: 'TEST'
+
+      assert_equal 5000, order.amount
+      assert_equal 'INR', order.currency
+      assert_equal 'TEST', order.receipt
+    end
+
+    def test_orders_should_be_fetched
+      order = Razorpay::Order.fetch(@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'
+    end
+
+    def test_fetching_all_orders
+      stub_get(/orders$/, 'order_collection')
+      orders = Razorpay::Order.all
+      assert_instance_of Razorpay::Collection, orders, 'Orders should be an array'
+      assert !orders.items.empty?, 'orders should be more than one'
+    end
+
+    def test_order_payments_should_be_fetched
+      stub_get(%r{orders/#{@order_id}/payments$}, 'order_payments')
+
+      payments = Razorpay::Order.fetch(@order_id).payments
+      assert_instance_of Razorpay::Collection, payments, 'Payments should be an array'
+      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

@@ -0,0 +1,303 @@
+require 'test_helper'
+
+module Razorpay
+  # Tests for Razorpay::Payment
+  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')
+    end
+
+    def test_payment_should_be_defined
+      refute_nil Razorpay::Payment
+    end
+
+    def test_payments_should_be_available
+      payment = Razorpay::Payment.fetch(@payment_id)
+      assert_instance_of Razorpay::Payment, payment, 'Payment not an instance of Payment class'
+      assert_equal @payment_id, payment.id, 'Payment IDs do not match'
+      assert_equal 500, payment.amount, 'Payment amount is accessible'
+      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'
+      assert !payments.items.empty?, 'Payments should be more than one'
+    end
+
+    def test_all_payments_with_options
+      query = { 'count' => 1 }
+      stub_get(/payments\?count=1$/, 'payment_collection_with_one_payment')
+      payments = Razorpay::Payment.all(query)
+      assert_equal query['count'], payments.items.size, 'Payments array size should match'
+    end
+
+    def test_payment_refund
+      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, "pay_FFX5FdEYx8jPwA"
+    end
+
+    def test_payment_refund!
+      payment = Razorpay::Payment.fetch(@payment_id)
+      stub_get(%r{payments/#{@payment_id}$}, 'fake_refunded_payment')
+      stub_post(%r{payments/#{@payment_id}/refund$}, 'fake_refund', {})
+      payment.refund!
+      assert_equal 'refunded', payment.status
+    end
+
+    def test_partial_refund
+      # For some reason, stub doesn't work if I pass it a hash of post body
+      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, "pay_FFX5FdEYx8jPwA"
+      assert_equal refund.amount, 2000
+    end
+
+    def test_payment_capture
+
+      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!
+      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!(para_attr.to_json)
+      assert_equal 'captured', payment.status
+    end
+
+    def test_payment_capture_without_fetch
+      stub_post(%r{payments/#{@payment_id}/capture$}, 'fake_captured_payment', 'amount=5100')
+      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
+    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  
+  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