Why testing is central to Ruby culture - See It in Action

Why Testing is Central to Ruby Culture

📖 Scenario: Imagine you are part of a team building a small Ruby program that manages a list of tasks. To make sure your program works well and keeps working as you add new features, you will write tests. Testing is a big part of Ruby culture because it helps catch mistakes early and makes coding more fun and reliable.

🎯 Goal: You will create a simple Ruby class to hold tasks, set up a test configuration, write a test to check your code, and finally run the test to see the result. This will show why testing is important and how it fits naturally in Ruby programming.

📋 What You'll Learn

Create a Ruby class called TaskList with an empty array called tasks

Add a configuration variable max_tasks set to 5

Write a method add_task that adds a task only if the list has fewer than max_tasks

Write a test using minitest to check that add_task works correctly

Print the test result to show if the test passed or failed

💡 Why This Matters

🌍 Real World

Testing is used in real Ruby projects to make sure code works well before sharing with others or adding new features.

💼 Career

Ruby developers often write tests as part of their daily work to keep code quality high and avoid bugs.

1

Create the TaskList class with tasks array

Create a Ruby class called TaskList with an instance variable @tasks initialized as an empty array inside the initialize method.

Ruby

class TaskList
  def initialize
    # Your code here
  end
end

Hint

Use @tasks = [] inside the initialize method to create an empty list.

2

Add max_tasks configuration variable

Inside the TaskList class, add an instance variable @max_tasks set to 5 inside the initialize method.

Ruby

class TaskList
  def initialize
    @tasks = []
    # Your code here
  end
end

Hint

Set @max_tasks = 5 inside the initialize method.

3

Write add_task method with limit check

Add a method add_task to the TaskList class that takes a task parameter and adds it to @tasks only if the number of tasks is less than @max_tasks.

Ruby

class TaskList
  def initialize
    @tasks = []
    @max_tasks = 5
  end

  # Your code here
end

Hint

Use if @tasks.size < @max_tasks to check before adding the task.

4

Write and run a test for add_task method

Write a test using minitest that creates a TaskList object, adds a task, and uses assert_equal to check that the task was added. Then print the test result.

Ruby

require 'minitest/autorun'

# Your code here

Hint

Use assert_equal(['Buy milk'], list.tasks) inside a test_add_task method.

Practice

1. Why is testing considered central to Ruby culture?

easy

A. It is required by the Ruby language syntax.

B. It helps find mistakes early and ensures code works correctly.

C. It makes Ruby code run faster.

D. It replaces the need for writing code comments.

Solution

1. Step 1: Understand the purpose of testing in Ruby

   Testing is used to catch errors early and confirm that code behaves as expected.

2. Step 2: Compare options with Ruby culture

   Ruby culture emphasizes writing tests to build trust and maintain code quality, not speed or syntax rules.

3. Final Answer:

   It helps find mistakes early and ensures code works correctly. -> Option B

4. Quick Check:

   Testing = Early error detection [OK]

Hint: Testing finds bugs early and keeps code reliable [OK]

Common Mistakes:

• Thinking testing makes code faster
• Confusing testing with language syntax
• Believing tests replace comments

2. Which of the following is the correct way to start a simple test in Ruby using Minitest?

easy

A. class TestExample < Minitest::Test; def test_add; assert_equal 4, 2+2; end; end

B. def test_add; assert_equal 4, 2+2; end

C. test 'add' do; assert_equal 4, 2+2; end

D. class TestExample; def test_add; assert_equal 4, 2+2; end; end

Solution

1. Step 1: Identify correct Minitest class structure

   Minitest tests are defined inside a class inheriting from Minitest::Test.

2. Step 2: Check method and assertion syntax

   Test methods start with 'test_' and use assertions like assert_equal.

3. Final Answer:

   class TestExample < Minitest::Test; def test_add; assert_equal 4, 2+2; end; end -> Option A

4. Quick Check:

   Minitest class inherits Minitest::Test [OK]

Hint: Minitest tests inherit Minitest::Test class [OK]

Common Mistakes:

• Omitting inheritance from Minitest::Test
• Not prefixing test methods with 'test_'
• Using wrong test block syntax

3. What will be the output when running this Minitest code?

require 'minitest/autorun'

class TestMath < Minitest::Test
  def test_multiply
    assert_equal 15, 3 * 5
  end

  def test_fail
    assert_equal 10, 2 + 2
  end
end

medium

A. 1 test passed, 1 test failed

B. All tests passed

C. Syntax error

D. No tests run

Solution

1. Step 1: Analyze each test method

   test_multiply checks if 3*5 equals 15 (true), test_fail checks if 2+2 equals 10 (false).

2. Step 2: Determine test results

   One test passes, one test fails, so output shows 1 pass and 1 fail.

3. Final Answer:

   1 test passed, 1 test failed -> Option A

4. Quick Check:

   One true, one false test = 1 pass, 1 fail [OK]

Hint: Check each assertion result to find pass/fail count [OK]

Common Mistakes:

• Assuming all tests pass
• Expecting syntax error without error
• Thinking no tests run

4. Identify the error in this Ruby test code snippet:

require 'minitest/autorun'

class TestString < Minitest::Test
  def test_length
    assert_equal 5, 'hello'.length
  end

  def test_uppercase
    assert_equal 'HELLO', 'hello'.upcase
  end

  def test_fail
    assert_equal 4, 'test'.length
end

medium

A. Missing 'end' keyword for the class definition

B. Wrong inheritance from Minitest::Test

C. Missing 'end' keyword for the test_fail method

D. Incorrect assertion method used

Solution

1. Step 1: Count opening and closing blocks

   1 class + 3 defs opened (4 total), but only 3 'end' keywords; the last method 'test_fail' is missing its closing 'end'.

2. Step 2: Confirm methods have closings

   All other methods properly closed; error is missing 'end' for 'test_fail' method.

3. Final Answer:

   Missing 'end' keyword for the test_fail method -> Option C

4. Quick Check:

   Missing method 'end' causes syntax error [OK]

Hint: Count 'end' keywords to match methods and classes [OK]

Common Mistakes:

• Confusing missing method end with class end
• Thinking assertion method is wrong
• Assuming inheritance is incorrect

5. You want to ensure your Ruby code handles empty strings correctly. Which test best applies Ruby's testing culture to check this?

def reverse_string(str)
  str.reverse
end

hard

A. def test_reverse_empty
assert_equal nil, reverse_string('')
end

B. def test_reverse_empty
assert_equal false, reverse_string('')
end

C. def test_reverse_empty
assert_equal ' ', reverse_string('')
end

D. def test_reverse_empty
assert_equal '', reverse_string('')
end

Solution

1. Step 1: Understand function behavior with empty string

   Calling reverse on an empty string returns an empty string.

2. Step 2: Choose assertion matching expected output

   Test should expect '' (empty string), not nil, space, or false.

3. Final Answer:

   def test_reverse_empty assert_equal '', reverse_string('') end -> Option D

4. Quick Check:

   Empty string reversed is empty string [OK]

Hint: Test expected output exactly, empty string reverses to empty string [OK]

Common Mistakes:

• Expecting nil instead of empty string
• Using space or false as expected result
• Not testing edge cases like empty input