W4D3

Question 1

Raise

Answer 1

Generic way to end runtime. Hardcodes an error given a condition.

raise “Something Went wrong” if some condition

Question 2

Begin/Rescue>Retry Block

Answer 2

Protects against errors resulting from User input.

Wrap a function call in a Begin/Rescue block. Include Retry to loop back to Begin

Question 3

class CustomError < StandardError

raise CustomError.new(“Something went wrong”)

Answer 3

Custom error class ‘CustomError’ is created and inherits from StandardError

creates a new instance to include with a Rescue block.

Question 4

Ensure

Answer 4

Ensure block only runs after a Begin/Rescue block completes. It will ALWAYS run regardless

Question 5

Begin > Rescue > Retry

Interrupting the Retry Loop

Answer 5

Raise a conditional error before the Rescue.

example:
if raise “too many tried” if password_attempts > 2

Question 6

Require bank

Answer 6

require multiple files in a separate file and keep your main class clean

Question 7

Singleton Module

Answer 7

@sentinel = Singleton.instance

can be used to reference a single instance value for any filler spaces

Question 8

loop do

break unless

Answer 8

loop continually and check for break conditions

Question 9

rspec files

Answer 9

require ‘rspec’
require ‘file’

project
lib/
   file.rb
spec/
   file_spec.rb

Question 10

rspec test
describe block
it block

Answer 10

Organizes your test and gives them lables

describe “#method_name” do
it “returns ‘Something!” do
expect(method_name).to eq(“Something!”

Question 11

describe

Answer 11

DESCRIBE the “Subject” > do
IT “tests the case” do
EXPECT( {CODE} ).TO

Class do
“::class_method” “#instance_method” do

Question 12

Nesting describe

Answer 12

Nest ‘describe’ or its alias ‘context’

Question 13

expect

Answer 13

does the work of testing your code

Match between a value generated and an expected value

Question 14

expect values

Answer 14

expect(test_value).to

expect(test_value).to_not

Question 15

expect() AND expect{ }

Answer 15

expecting operations vs expecting errors

Question 16

RSPEC matchers

Answer 16

.to eq(expected_val) and .to be(expected_val)

== or is the same object

Question 17

Rspec Expectations

Answer 17

lets you express expected outcomes on an obect in an example

install rspec

Question 18

Want to run against the main branch? You’ll need to include the dependent RSpec repos as well. Add the following to your Gemfile:

Answer 18

%w[rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
gem lib, :git => “https://github.com/rspec/#{lib}.git”, :branch => ‘main’
end

Question 19

Built-in Matchers -Equivalence

Answer 19

expect(actual).to eq(expected) # passes if actual == expected
expect(actual).to eql(expected) # passes if actual.eql?(expected)
expect(actual).not_to eql(not_expected) # passes if not(actual.eql?(expected))

Question 20

Built-in Matchers -

Identity

Answer 20

expect(actual).to be(expected) # passes if actual.equal?(expected)
expect(actual).to equal(expected) # passes if actual.equal?(expected)

Question 21

Built-in Matchers - Comparisons

Answer 21

expect(actual).to be >  expected
expect(actual).to be >= expected
expect(actual).to be <= expected
expect(actual).to be <  expected
expect(actual).to be_within(delta).of(expected)

Question 22

Built-in Matchers - Types/classes

Answer 22

expect(actual).to be_an_instance_of(expected) # passes if actual.class == expected
expect(actual).to be_a(expected) # passes if actual.kind_of?(expected)
expect(actual).to be_an(expected) # an alias for be_a
expect(actual).to be_a_kind_of(expected) # another alias

Question 23

Built-in Matchers - Truthiness

Answer 23

expect(actual).to be_truthy # passes if actual is truthy (not nil or false)
expect(actual).to be true # passes if actual == true
expect(actual).to be_falsy # passes if actual is falsy (nil or false)
expect(actual).to be false # passes if actual == false
expect(actual).to be_nil # passes if actual is nil
expect(actual).to_not be_nil # passes if actual is not nil

Question 24

Built-in Matchers - Expecting errors

Answer 24

expect { … }.to raise_error
expect { … }.to raise_error(ErrorClass)
expect { … }.to raise_error(“message”)
expect { … }.to raise_error(ErrorClass, “message”)

Question 25

Built-in Matchers - Expecting throws

Answer 25

expect { … }.to throw_symbol
expect { … }.to throw_symbol(:symbol)
expect { … }.to throw_symbol(:symbol, ‘value’)

Question 26

Built-in Matchers others

Answer 26

Yielding, Predicate matchers, Ranges (Ruby >= 1.9 only),

Question 27

Built-in Matchers - Collection membership

Answer 27

# exact order, entire collection
expect(actual).to eq(expected)

exact order, partial collection (based on an exact position)
expect(actual).to start_with(expected)
expect(actual).to end_with(expected)

# any order, entire collection
expect(actual).to match_array(expected)

# You can also express this by passing the expected elements
# as individual arguments
expect(actual).to contain_exactly(expected_element1, expected_element2)

 # any order, partial collection
expect(actual).to include(expected)

expect([1, 2, 3]).to eq([1, 2, 3]) # Order dependent equality check
expect([1, 2, 3]).to include(1) # Exact ordering, partial collection matches
expect([1, 2, 3]).to include(2, 3) #
expect([1, 2, 3]).to start_with(1) # As above, but from the start of the collection
expect([1, 2, 3]).to start_with(1, 2) #
expect([1, 2, 3]).to end_with(3) # As above but from the end of the collection
expect([1, 2, 3]).to end_with(2, 3) #
expect({:a => ‘b’}).to include(:a => ‘b’) # Matching within hashes
expect(“this string”).to include(“is str”) # Matching within strings
expect(“this string”).to start_with(“this”) #
expect(“this string”).to end_with(“ring”) #
expect([1, 2, 3]).to contain_exactly(2, 3, 1) # Order independent matches
expect([1, 2, 3]).to match_array([3, 2, 1]) #

Order dependent compound matchers
expect(
[{:a => ‘hash’},{:a => ‘another’}]
).to match([a_hash_including(:a => ‘hash’), a_hash_including(:a => ‘another’)])

Question 28

Built-in Matchers - Compound Matcher Expressions

Answer 28

expect(alphabet).to start_with(“a”).and end_with(“z”)

expect(stoplight.color).to eq(“red”).or eq(“green”).or eq(“yellow”)

Question 29

RSPEC - Before block

Answer 29

describe Chess do
let(:board) { Board.new }

  describe '#checkmate?' do
    context 'when in checkmate' do
      before(:each) do
        board.make_move([3, 4], [2, 3])
        board.make_move([1, 2], [4, 5])
        board.make_move([5, 3], [5, 1])
        board.make_move([6, 3], [2, 4])
      end

Question 30

before(:each) do

Answer 30

execute the block of code before each spec in that describe block

Question 31

describe ‘#valid_move?’ do
it ‘should return false for wrong colored pieces’
it ‘should return false for moves that are off the board’
it ‘should return false for moves that put you in check’
end

Answer 31

Leave off the do…end from the it. for pending specs

Question 32

RSPEC, instantiate an instance of an Object

Answer 32

Subject and It

describe Robot do
subject(:robot) { Robot.new }

it “position should start at [0, 0]” do
expect(robot.position).to eq([0, 0])
end

  describe "move methods" do
    it "moves left" do
      robot.move_left
      expect(robot.position).to eq([-1, 0])
    end
  end
end

Question 33

Subject block

Answer 33

defines the subject of the test

subject also accepts a block that constructs the subject. You can do any necessary setup inside the block.

there can only be one unnamed subject

Question 34

Let block

Answer 34

defines the helper objects that interact with the subject

there can be multiple helper objects

Question 35

let does not persist state

Answer 35

You might read that let memoizes its return value. Memoization means that the first time the method is invoked, the return value is cached and that same value is returned every subsequent time the method is invoked within the same scope. Since every it is a different scope, let does not persist state between those specs.