Rabbit Slide Show

Self-testing Code in Ruby



This talk explains the concept of self-testing code with practices in ruby using rspec.


Page: 1

Self-testing Code in
Giovanni Sakti

Page: 2

What is Self-testing code?

Page: 3

Self-testing code
Code that have built-in tests
The tests serve as a binding contract
The tests can be run arbitrarily

Page: 4

What is TDD? How it differs from self-
testing code?

Page: 5

Practices of writing tests before the
Ensure that the code is self-tested
It is, however, optional to do TDD to
write self-testing code

Page: 6

But some companies enforce TDD
because TDD enforces YAGNI principle

Page: 7

We'll see why...

Page: 8

TDD Steps
Write a test
Run the test, it should fail
Write code just enough to pass the
Run the test

Page: 9

Because we only write just enough code
to pass the test, there will be no
unnecessary codes

Page: 10

Test in Ruby
There are several tools for doing testing
in ruby

Page: 11

Test in Ruby

Page: 12

Test in Ruby
Let's try using RSpec

Page: 13

RSpec Install
% gem install rspec

Page: 14

RSpec Help
% rspec --help

Page: 15

Now let's do TDD practice using RSpec

Page: 16

TDD with RSpec (1)
Create a simple test of program that we
want to create
# game_spec.rb
RSpec.describe Game do
describe "#score" do
it "returns 0 for new game" do
game = Game.new
expect(game.score).to eq(0)

Page: 17

TDD with RSpec (2)
Run the example and watch it fail
% rspec game_spec.rb
uninitialized constant Object::Game (NameError)

Page: 18

TDD with RSpec (3)
Now write just enough code to make it
# game.rb
class Game
attr_reader :score
def initialize
@score = 0

Page: 19

TDD with RSpec (3) cont'd
Now write just enough code to make it
# game_spec.rb
require './game'

Page: 20

TDD with RSpec (4)
Run the example and the test shall pass
% rspec game_spec.rb --color --format doc
returns 0 for all gutter game
Finished in 0.00057 seconds
1 example, 0 failures

Page: 21

TDD with RSpec (5)
Repeat with new features

Page: 22

Some important RSpec APIs

Page: 23

Basic Matchers
# equality
expect('x'+'y').to eq('xy')
expect('x'+'y').to eql('xy')
expect('x'+'y').not_to be('xy')
# strings
# a == b
# a.eql?(b)
# a.equal?(b)
start_with 'ab'
end_with 'cd'
match /[a-z]+/
# collections
expect([1, 2, 3]).to include(1, 3)
expect([1, 2, 3]).to contain_exactly(3, 2, 1) # order not important
expect({ a: 1, b: 2 }).to include(b: 2)

Page: 24

Basic Matchers cont'd
# booleans and nil
expect(true).to be true
expect(false).to be false
expect('abc').to be_truthy
expect(nil).to be_falsey
expect(nil).to be_nil
# numeric
expect(5).to be > 4
expect(5).to be >= 4
expect(5).to be < 6
expect(5).to be <= 6
expect(5).to be_between(4, 6).exclusive
expect(5).to be_between(5, 6).inclusive
expect(4.99).to be_within(0.02).of(5)
# errors (exceptions)
expect{ 5 / 0 }.to raise_error(ZeroDivisionError)
expect{ 5 / 0 }.to raise_error("divided by 0")
expect{ 5 / 0 }.to raise_error(ZeroDivisionError, "divided by 0")

Page: 25

Predicate Matchers
Predicate matchers are a little DSL for
calling predicate methods. Predicate
methods are methods that:
return a boolean value; and
have a name that ends with ?

Page: 26

Predicate Matchers cont'd
# array
expect([]).to be_empty
# hash
expect({a: 1}).to have_key(:a)
expect({a: 1}).to have_value(1)
# [].empty?
# {a: 1}.has_key?(:a)
# {a: 1}.has_value?(1)
# object
expect(5).not_to be_nil
expect(5).to be_instance_of Fixnum
expect(5).to be_kind_of Numeric
# 'hi'.nil?
# 5.instance_of?(Fixnum)
# 5.kind_of?(Numeric)

Page: 27

Predicate Matchers cont'd
Predicate matchers work on all objects,
including custom classes

Page: 28

Now let's do some exercises...

Page: 29

TDD Exercises (1)
Create a Sentence from Words
Without using "Array#each" iterator,
create a method that will return a
sentence when given an array of words.
create_sentence(["hello", "world"])
# will return: "hello world"

Page: 30

TDD Exercises (2)
Find Palindromes
Write a method that receives two
positive integers "m" and "n" and returns
an array of "n" palindrome numbers after
"m" (including "m" itself).
find_palindrome(100, 2)
# will return [101, 111]
find_palindrome(22, 3)
# will return [22, 33, 44]

Page: 31

TDD Exercises (3)
Descending Order
Create a method that receives an
integer as an argument and rearrange it
to generate biggest possible value.
descending(21445) # will return 54421
descending(145263) # will return 654321
descending(1254859723) # will return 9875543221

Page: 32

TDD Exercises (4)
Deep Count
Create a method called deep_count that
will return the number of elements in an
array, including the number of elements
of its sub arrays.

Page: 33

TDD Exercises (4) cont'd
deep_count([]) # will return 0
deep_count([1, 2, 3]) # will return 3
deep_count(["x", "y", ["z"]])
# will return 3 elements ("x", "y", ["z"]) in main array
# plus 1 element ("z") in sub array
# total = 4 elements
deep_count([1, 2, [3, 4, [5]]])
# total = 7 elements
# total = 8 elements

Page: 34

TDD Exercises (5)
Letter Count
Create a method that receives a string
as its argument and returns a hash that
shows the number of occurrence of
each letter in that string.

Page: 35

TDD Exercises (5) cont'd
# will return {:g=>1, :o=>1, :j=>1, :e=>1, :k=>1}
# will return {:k=>1, :o=>1, :l=>2, :a=>1}
# will return {:s=>2, :c=>1, :h=>2, :o=>1, :l=>1, :a=>1, :r=>1, :i=>1, :p=>1}

Page: 36


Other slides