როგორ აკეთებთ Ruby კოდის ტესტირებას (RSpec/Minitest)?

Question

Accepted Answer

Ruby-ს აქვს ძლიერი ტესტირების კულტურა, ორი მთავარი ჩარჩოთი: **RSpec** (გამოხატული, ქცევაზე ორიენტირებული DSL — ძალიან პოპულარული) და **Minitest** (უფრო მარტივი, მსუბუქი, Rails-ის ნაგულისხმევი). ორივე გაძლევთ სამჯერობას დაწეროთ ტესტები, რომლებიც ამოწმებენ კოდის ქცევას, mocking-ის, fixtures-ის და მდიდარი assertions-ის სთავზე.

## RSpec — გამოხატული, ქცევაზე ორიენტირებული

```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 თითქმის ინგლისური ენის მსგავსად იკითხება ("expect calc.add(2,3) to eq 5"), რაც ტესტებს თვითოჩანს დოკუმენტირებულს აკეთებს — მისი გამოხატულობა არის ის, თუ რატომ არის ის ფართოდ სიყვარული.

## 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 გთავაზობთ მდიდარ **matchers**-ს (`eq`, `include`, `raise_error`, predicate `be_*`), **mocks/doubles**-ს (კოორდინაციის ჩანაცვლება კონტროლირებული ყალბი მნიშვნელობებით იზოლაციისთვის) და `let`-ს სუფთა ტესტის მონაცემებისთვის.

## Minitest — უფრო მარტივი, მსუბუქი

```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-ზე დაფუძნებულ (xUnit) სტილს — ღრმა და სწრაფი, და Rails-ის ნაგულისხმევი.

## ტესტირება Rails-ში

```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.
```

## რატომ აქვს მნიშვნელობა

ტესტირება არსებითია საიმედო აპლიკაციებისთვის, და Ruby-ს აქვს აღმოჩენილი **ძლიერი ტესტირების კულტურა** (TDD/BDD ფართოდ ვარჯიშდება და ფასდება Ruby-ს საზოგადოებაში), ამიტომ Ruby კოდის ტესტირების ხერხის გაგება მნიშვნელოვანია როგორც კოდის ხარისხის, ისე Ruby-ს განვითარების პროფესიონალური მოლოდინის თვალსაზრისით.

ორი მთავარი ჩარჩოს ცოდნა მნიშვნელოვანია: **RSpec** (პოპულარული, გამოხატული ქცევაზე ორიენტირებული ჩარჩო, რომლის `describe`/`it`/`expect` DSL ინგლისური ენის მსგავსად იკითხება, რაც ტესტებს თვითოჩანს დოკუმენტირებულს და წაკითხვად აკეთებს — მისი გამოხატულობა არის ის, თუ რატომ არის ის სიყვარული) და **Minitest** (უფრო მარტივი, მსუბუქი, assertion-ზე დაფუძნებული Rails-ის ნაგულისხმევი).

ის გაგება, თუ როგორ დავწეროთ ტესტები, გამოვიყენოთ **matchers** (RSpec-ის მდიდარი `eq`/`include`/`raise_error`/predicate matchers ნაწილი assertions-ისთვის), და განსაკუთრებით **mocks/doubles** (კოორდინაციის ჩანაცვლება კონტროლირებული ყალბი მნიშვნელობებით სწრაფი, იზოლირებული ტესტებისთვის) და ტესტის მონაცემების დამხმარე (`let`, factories FactoryBot-ს მსგავსად) მოიცავს Ruby-ს ეფექტური ტესტირების პრაქტიკული ნაკრებს.

Rails-ში, ძლიერი ტესტირების დამხმარე (model, controller/request, და სრულ-სტეკი system tests) აკეთებს ღრმა ტესტირებას პრაქტიკულს.

ღ Ruby-ს კულტურა ძლიერად ხაზს უსვამს ტესტირებას (კარგად-დამტკიცებული კოდი მოსალოდნელია პროფესიონალურ Ruby-ს მუშაობაში), და რადგან კარგად-დამტკიცებული აპლიკაციები ამჩნევს რეგრესიებს და მოწოდებს თავდაჯერებულ რეფაქტორინგს, Ruby-ს ტესტირების ჩარჩოების გაგება (განსაკუთრებით პოპულარული, გამოხატული RSpec და უფრო მარტივი Minitest), როგორ დავწეროთ კარგი ტესტები matchers-ის და mocks-ის გამოყენებით, და Ruby-ს საზოგადოების ძლიერი ტესტირების პრაქტიკა არის მნიშვნელოვანი უმცროსი დონის ცოდნა, რომელიც პროფესიონალური მოლოდინია Ruby-ს განვითარებაში — განასხვავებთ დეველოპერებს, რომლებიც ამტკიცებენ მტკიცე, კარგად-დამტკიცებული აპლიკაციებს (Ruby-ს ნორმა) მათ, რომლებიც არა, და ხშირად-დამაკავშირებელი თემა, რომელიც ასახავს ტესტირებაზე ორიენტირებულ კულტურას, რომელიც ხასიათდება Ruby და Rails განვითარების მაღალი ხარისხით.