आप Ruby code (RSpec/Minitest) को कैसे test करते हैं?

Question

Accepted Answer

Ruby में एक मजबूत testing culture है, जिसमें दो मुख्य frameworks हैं: **RSpec** (एक expressive, behavior-driven DSL — बहुत लोकप्रिय) और **Minitest** (सरल, lightweight, Rails का default)। दोनों आपको code behavior को verify करने वाले tests लिखने देते हैं, mocking, fixtures, और rich assertions के साथ।

## RSpec — expressive, behavior-driven

```ruby
# RSpec uses describe/it with a readable, English-like DSL
RSpec.describe Calculator do
  describe "#add" do
    it "adds two numbers" do
      calc = Calculator.new
      expect(calc.add(2, 3)).to eq(5)        # expressive expectation
    end

it "handles negatives" do
      expect(Calculator.new.add(-1, 1)).to eq(0)
    end
  end
end
```

RSpec का `describe`/`it`/`expect` DSL लगभग English की तरह पढ़ता है ("expect calc.add(2,3) to eq 5"), tests को self-documenting बनाता है — इसकी expressiveness ही कारण है कि यह व्यापक रूप से पसंद किया जाता है।

## RSpec features: matchers, mocks, let

```ruby
expect(result).to eq(5)              # equality
expect(list).to include("item")       # inclusion
expect { risky }.to raise_error(ArgumentError)   # exceptions
expect(user).to be_valid              # predicate matchers (be_*)

# mocking / doubles
mailer = double("Mailer")
allow(mailer).to receive(:send).and_return(true)   # stub a method
expect(mailer).to receive(:send).once               # set an expectation

# let — lazily-evaluated, memoized test data
let(:user) { User.new(name: "Ann") }
```

RSpec rich **matchers** (`eq`, `include`, `raise_error`, predicate `be_*`), **mocks/doubles** (isolation के लिए dependencies को controllable fakes से बदलना), और clean test data के लिए `let` प्रदान करता है।

## Minitest — सरल, lightweight

```ruby
require "minitest/autorun"
class CalculatorTest < Minitest::Test
  def test_add
    assert_equal 5, Calculator.new.add(2, 3)    # assertion-style (xUnit)
  end
end
```

Minitest एक सरल, assertion-based (xUnit) style का उपयोग करता है — हल्का और तेज़, और Rails का default।

## Rails में testing

```text
Rails has strong testing support: model tests, controller/request tests, system tests
(full-stack, browser-driven), fixtures/factories (FactoryBot) for test data.
Ruby's culture STRONGLY values testing — TDD/BDD are widely practiced.
```

## यह क्यों महत्वपूर्ण है

Testing विश्वसनीय applications के लिए आवश्यक है, और Ruby में एक उल्लेखनीय रूप से **मजबूत testing culture** है (TDD/BDD व्यापक रूप से अभ्यास और महत्व दिए जाते हैं Ruby community में), इसलिए Ruby code को कैसे test करें यह समझना code quality और Ruby development में एक professional अपेक्षा दोनों के लिए महत्वपूर्ण है।

दो मुख्य frameworks को जानना मायने रखता है: **RSpec** (लोकप्रिय, expressive behavior-driven framework जिसका `describe`/`it`/`expect` DSL English की तरह पढ़ता है, tests को self-documenting और readable बनाता है — इसकी expressiveness ही कारण है कि यह प्रिय है) और **Minitest** (सरल, lightweight, assertion-based default Rails में)।

Tests कैसे लिखें, **matchers** का उपयोग कैसे करें (RSpec के rich `eq`/`include`/`raise_error`/predicate matchers स्पष्ट assertions के लिए), और विशेष रूप से **mocks/doubles** (fast, isolated tests के लिए dependencies को controllable fakes से बदलना) और test-data helpers (`let`, FactoryBot जैसे factories) को समझना Ruby को प्रभावी ढंग से test करने के practical scope को कवर करता है।

Rails में, मजबूत testing support (model, controller/request, और full-stack system tests) thorough testing को practical बनाता है।

चूँकि Ruby की culture testing पर भारी जोर देती है (professional Ruby काम में well-tested code की उम्मीद की जाती है), और चूँकि well-tested applications regressions को पकड़ती हैं और confident refactoring को सक्षम बनाती हैं, Ruby के testing frameworks (विशेष रूप से लोकप्रिय, expressive RSpec और सरल Minitest), matchers और mocks के साथ अच्छे tests कैसे लिखें, और Ruby community की मजबूत testing practices को समझना महत्वपूर्ण senior-level ज्ञान है जो Ruby development में एक professional अपेक्षा है — जो उन developers को अलग करता है जो robust, well-tested applications बनाते हैं (Ruby का norm) उनसे जो नहीं बनाते, और एक बार-बार relevant topic है जो उस testing-centric culture को दर्शाता है जो quality Ruby और Rails development की विशेषता है।