Bagaimana anda menguji kod Ruby (RSpec/Minitest)?

Question

Accepted Answer

Ruby mempunyai budaya pengujian yang kuat, dengan dua rangka kerja utama: **RSpec** (DSL ekspresif berasaskan tingkah laku — sangat popular) dan **Minitest** (lebih ringkas, ringan, lalai Rails). Kedua-duanya membolehkan anda menulis ujian yang mengesahkan tingkah laku kod, dengan mocking, fixture, dan assertion yang kaya.

## RSpec — ekspresif, berasaskan tingkah laku

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

DSL `describe`/`it`/`expect` RSpec dibaca hampir seperti bahasa Inggeris ("expect calc.add(2,3) to eq 5"), menjadikan ujian mendokumenkan diri sendiri — keekspresifannya ialah sebab ia disukai ramai.

## Ciri RSpec: matcher, mock, 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 menyediakan **matcher** yang kaya (`eq`, `include`, `raise_error`, predikat `be_*`), **mock/double** (menggantikan kebergantungan dengan tiruan yang boleh dikawal untuk pengasingan), dan `let` untuk data ujian yang kemas.

## Minitest — lebih ringkas, ringan

```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 menggunakan gaya yang lebih ringkas, berasaskan assertion (xUnit) — lebih ringan dan pantas, serta lalai Rails.

## Pengujian dalam 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.
```

## Mengapa ia penting

Pengujian adalah penting untuk aplikasi yang boleh dipercayai, dan Ruby mempunyai **budaya pengujian yang kuat** secara ketara (TDD/BDD diamalkan dan dihargai secara meluas dalam komuniti Ruby), jadi memahami cara menguji kod Ruby adalah penting baik untuk kualiti kod mahupun sebagai jangkaan profesional dalam pembangunan Ruby.

Mengetahui dua rangka kerja utama adalah penting: **RSpec** (rangka kerja berasaskan tingkah laku yang popular dan ekspresif yang DSL `describe`/`it`/`expect`nya dibaca seperti bahasa Inggeris, menjadikan ujian mendokumenkan diri sendiri dan mudah dibaca — keekspresifannya ialah sebab ia disukai) dan **Minitest** (lalai yang lebih ringkas, ringan, berasaskan assertion dalam Rails).

Memahami cara menulis ujian, menggunakan **matcher** (matcher `eq`/`include`/`raise_error`/predikat RSpec yang kaya untuk assertion yang jelas), dan terutamanya **mock/double** (menggantikan kebergantungan dengan tiruan yang boleh dikawal untuk ujian yang pantas dan terasing) serta pembantu data ujian (`let`, factory seperti FactoryBot) merangkumi skop praktikal pengujian Ruby dengan berkesan.

Dalam Rails, sokongan pengujian yang kuat (ujian model, controller/request, dan ujian sistem full-stack) menjadikan pengujian menyeluruh praktikal.

Memandangkan budaya Ruby sangat menekankan pengujian (kod yang diuji dengan baik dijangkakan dalam kerja Ruby profesional), dan kerana aplikasi yang diuji dengan baik menangkap regresi dan membolehkan refactoring dengan yakin, memahami rangka kerja pengujian Ruby (terutamanya RSpec yang popular dan ekspresif serta Minitest yang lebih ringkas), cara menulis ujian yang baik dengan matcher dan mock, serta amalan pengujian yang kuat dalam komuniti Ruby adalah pengetahuan peringkat senior yang penting yang merupakan jangkaan profesional dalam pembangunan Ruby — membezakan pembangun yang membina aplikasi yang teguh dan diuji dengan baik (norma Ruby) daripada mereka yang tidak, serta topik yang kerap relevan yang mencerminkan budaya berpusatkan pengujian yang mencirikan pembangunan Ruby dan Rails yang berkualiti.