คุณทดสอบโค้ด Ruby อย่างไร (RSpec/Minitest)?

Question

Accepted Answer

Ruby มีวัฒนธรรมการทดสอบที่แข็งแกร่ง โดยมีเฟรมเวิร์กหลักสองตัว: **RSpec** (DSL แบบ behavior-driven ที่สื่อความหมายได้ดี — เป็นที่นิยมมาก) และ **Minitest** (เรียบง่ายกว่า, เบา, เป็นค่าเริ่มต้นของ Rails) ทั้งคู่ให้คุณเขียนการทดสอบที่ตรวจสอบพฤติกรรมของโค้ด พร้อม mocking, fixture และ assertion ที่หลากหลาย

## RSpec — สื่อความหมายได้ดี, 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
```

DSL `describe`/`it`/`expect` ของ RSpec อ่านได้เกือบเหมือนภาษาอังกฤษ ("expect calc.add(2,3) to eq 5") ทำให้การทดสอบอธิบายตัวเองได้ — ความสามารถในการสื่อความหมายของมันคือเหตุผลที่มันได้รับความนิยมอย่างกว้างขวาง

## คุณสมบัติของ 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 มี **matcher** ที่หลากหลาย (`eq`, `include`, `raise_error`, predicate `be_*`), **mock/double** (แทนที่ dependency ด้วยของปลอมที่ควบคุมได้เพื่อความเป็นเอกเทศ) และ `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** (เฟรมเวิร์ก behavior-driven ที่เป็นที่นิยมและสื่อความหมายได้ดี ซึ่ง DSL `describe`/`it`/`expect` อ่านได้เหมือนภาษาอังกฤษ ทำให้การทดสอบอธิบายตัวเองได้และอ่านง่าย — ความสามารถในการสื่อความหมายคือเหตุผลที่มันเป็นที่รัก) และ **Minitest** (ค่าเริ่มต้นใน Rails ที่เรียบง่ายกว่า, เบา, อิง assertion)

การเข้าใจวิธีเขียนการทดสอบ, การใช้ **matcher** (matcher `eq`/`include`/`raise_error`/predicate ที่หลากหลายของ RSpec สำหรับ assertion ที่ชัดเจน) และโดยเฉพาะ **mock/double** (แทนที่ dependency ด้วยของปลอมที่ควบคุมได้เพื่อการทดสอบที่รวดเร็วและเป็นเอกเทศ) และตัวช่วยข้อมูลทดสอบ (`let`, factory อย่าง FactoryBot) ครอบคลุมขอบเขตเชิงปฏิบัติของการทดสอบ Ruby อย่างมีประสิทธิภาพ

ใน Rails การสนับสนุนการทดสอบที่แข็งแกร่ง (model, controller/request และ system test แบบ full-stack) ทำให้การทดสอบอย่างละเอียดเป็นไปได้จริง

เนื่องจากวัฒนธรรมของ Ruby เน้นการทดสอบอย่างมาก (โค้ดที่ทดสอบอย่างดีเป็นที่คาดหวังในงาน Ruby ระดับมืออาชีพ) และเนื่องจากแอปพลิเคชันที่ทดสอบอย่างดีจับ regression และทำให้สามารถ refactor ได้อย่างมั่นใจ การเข้าใจเฟรมเวิร์กการทดสอบของ Ruby (โดยเฉพาะ RSpec ที่เป็นที่นิยมและสื่อความหมายได้ดี และ Minitest ที่เรียบง่ายกว่า), วิธีเขียนการทดสอบที่ดีด้วย matcher และ mock และแนวปฏิบัติการทดสอบที่แข็งแกร่งของชุมชน Ruby จึงเป็นความรู้ระดับ senior ที่สำคัญซึ่งเป็นความคาดหวังระดับมืออาชีพในการพัฒนา Ruby — แยกแยะนักพัฒนาที่สร้างแอปพลิเคชันที่แข็งแกร่งและทดสอบอย่างดี (บรรทัดฐานของ Ruby) จากผู้ที่ไม่ทำ และเป็นหัวข้อที่เกี่ยวข้องบ่อยครั้งซึ่งสะท้อนวัฒนธรรมที่เน้นการทดสอบซึ่งเป็นลักษณะของการพัฒนา Ruby และ Rails ที่มีคุณภาพ