【保存版】初心者のためのRSpec入門！書き方・使い方を丁寧に解説

gem install rspec

rspec --init

rspec

$ rspec
.

Finished in 0.001 seconds (files took 0.083 seconds to load)
1 example, 0 failures

$ rspec
F

Failures:

  1) Calculator adds two numbers
     Failure/Error: expect(calculator.add(2, 3)).to eq(5)

       expected: 5
            got: 6

       (compared using ==)
     # ./calculator_spec.rb:5:in `block (2 levels) in <top (required)>'

Finished in 0.001 seconds (files took 0.083 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./calculator_spec.rb:4 # Calculator adds two numbers

describe "Calculator" do
  # テストケースを記述
end

it "adds two numbers" do
  # テストケースの実装
end

expect(actual_value).to eq(expected_value)

describe "Calculator" do
  it "adds two numbers" do
    calculator = Calculator.new
    result = calculator.add(2, 3)
    expect(result).to eq(5)
  end
end

describe "Calculator" do
  it "adds two numbers" do
    # テストケースの実装
  end

  it "subtracts two numbers" do
    # テストケースの実装
  end

  it "multiplies two numbers" do
    # テストケースの実装
  end
end

describe "Calculator" do
  before do
    # セットアップコード
  end

  it "adds two numbers" do
    # テストケースの実装
  end

  it "subtracts two numbers" do
    # テストケースの実装
  end

  it "multiplies two numbers" do
    # テストケースの実装
  end
end

class Calculator
  def add(a, b)
    a + b
  end

  def subtract(a, b)
    a - b
  end
end

describe "Calculator" do
  before do
    @calculator = Calculator.new
  end

  it "adds two numbers" do
    result = @calculator.add(2, 3)
    expect(result).to eq(5)
  end

  it "subtracts two numbers" do
    result = @calculator.subtract(5, 2)
    expect(result).to eq(3)
  end
end

def メソッド名
  # 共通の処理
end

class Calculator
  def add(a, b)
    a + b
  end

  def subtract(a, b)
    a - b
  end
end

def create_calculator
  Calculator.new
end

before do
  @calculator = create_calculator
end

it "adds two numbers" do
  result = @calculator.add(2, 3)
  expect(result).to eq(5)
end

it "subtracts two numbers" do
  result = @calculator.subtract(5, 2)
  expect(result).to eq(3)
end

let(:変数名) { 値 }

class Calculator
  def add(a, b)
    a + b
  end

  def subtract(a, b)
    a - b
  end
end

let(:calculator) { Calculator.new }

it "adds two numbers" do
  result = calculator.add(2, 3)
  expect(result).to eq(5)
end

it "subtracts two numbers" do
  result = calculator.subtract(5, 2)
  expect(result).to eq(3)
end

describe "Calculator" do
  it "adds two numbers" do
    calculator = Calculator.new
    result = calculator.add(2, 3)
    expect(result).to eq(5)
  end

  it "subtracts two numbers" do
    calculator = Calculator.new
    result = calculator.subtract(5, 2)
    expect(result).to eq(3)
  end

  it "adds two numbers again" do
    calculator = Calculator.new
    result = calculator.add(7, 8)
    expect(result).to eq(15)
  end
end

describe "Calculator" do
  before do
    @calculator = Calculator.new
  end

  it "adds two numbers" do
    result = @calculator.add(2, 3)
    expect(result).to eq(5)
  end

  it "subtracts two numbers" do
    result = @calculator.subtract(5, 2)
    expect(result).to eq(3)
  end

  it "adds two numbers again" do
    result = @calculator.add(7, 8)
    expect(result).to eq(15)
  end
end

describe "Calculator" do
  context "when adding numbers" do
    it "returns the sum of two positive numbers" do
      # テストケースの実装
    end

    it "returns zero when adding zero to a number" do
      # テストケースの実装
    end
  end

  context "when subtracting numbers" do
    it "returns the difference of two positive numbers" do
      # テストケースの実装
    end
  end
end

describe "Calculator" do
  context "when adding numbers" do
    context "with positive numbers" do
      it "returns the sum of two positive numbers" do
        # テストケースの実装
      end
    end

    context "with negative numbers" do
      it "returns the sum of two negative numbers" do
        # テストケースの実装
      end
    end
  end

  context "when subtracting numbers" do
    it "returns the difference of two positive numbers" do
      # テストケースの実装
    end
  end
end

describe "Calculator" do
  before do
    # テストのセットアップ
  end

  after do
    # テストのクリーンアップ
  end

  it "adds two numbers" do
    # テストケースの実装
  end

  it "subtracts two numbers" do
    # テストケースの実装
  end
end

describe "Calculator" do
  context "when adding numbers" do
    before do
      # テストのセットアップ
    end

    after do
      # テストのクリーンアップ
    end

    it "returns the sum of two positive numbers" do
      # テストケースの実装
    end

    it "returns zero when adding zero to a number" do
      # テストケースの実装
    end
  end
end

describe "Calculator" do
  before(:context) do
    # 共通のセットアップ
  end

  after(:context) do
    # 共通のクリーンアップ
  end

  context "when adding numbers" do
    it "returns the sum of two positive numbers" do
      # テストケースの実装
    end

    it "returns zero when adding zero to a number" do
      # テストケースの実装
    end
  end

  context "when subtracting numbers" do
    it "returns the difference of two positive numbers" do
      # テストケースの実装
    end
  end
end

describe "Calculator" do
  before(:context) do
    @calculator = Calculator.new
  end

  context "when adding numbers" do
    it "returns the sum of two positive numbers" do
      expect(@calculator.add(1, 2)).to eq(3)
    end

    it "returns zero when adding zero to a number" do
      expect(@calculator.add(1, 0)).to eq(1)
    end
  end

  context "when subtracting numbers" do
    it "returns the difference of two positive numbers" do
      expect(@calculator.subtract(5, 3)).to eq(2)
    end
  end
end

describe "Calculator" do
  context "when working with positive numbers" do
    before do
      # セットアップ
    end

    it "adds two numbers" do
      # テストケースの実装
    end

    context "and subtracting numbers" do
      before do
        # 追加のセットアップ
      end

      it "returns the difference of two numbers" do
        # テストケースの実装
      end
    end
  end
end

describe "Calculator" do
  let(:number) { 5 }

  context "when working with positive numbers" do
    let(:number) { 10 }

    it "doubles the number" do
      expect(number * 2).to eq(20)
    end
  end
end

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    expect(subject.add(2, 3)).to eq(5)
  end
end

describe Calculator do
  subject { described_class.new }

  it "adds two numbers" do
    expect(subject.add(2, 3)).to eq(5)
  end
end

shared_examples "addition" do
  it "adds two numbers" do
    expect(subject.add(2, 3)).to eq(5)
  end
end

describe Calculator do
  subject { Calculator.new }

  it_behaves_like "addition"
end

shared_examples_for "addition and subtraction" do
  it "adds two numbers" do
    expect(subject.add(2, 3)).to eq(5)
  end

  it "subtracts two numbers" do
    expect(subject.subtract(5, 2)).to eq(3)
  end
end

describe Calculator do
  subject { Calculator.new }

  it_behaves_like "addition and subtraction"
end

shared_context "calculator context" do
  let(:calculator) { Calculator.new }
end

describe Calculator do
  include_context "calculator context"

  it "adds two numbers" do
    expect(calculator.add(2, 3)).to eq(5)
  end
end

describe Calculator do
  it { is_expected.to respond_to(:add).with(2).arguments }
  it { expect(subject.add(2, 3)).to eq(5) }
end

describe Calculator do
  it "responds to add with 2 arguments" do
    expect(subject).to respond_to(:add).with(2).arguments
  end

  it "adds two numbers" do
    expect(subject.add(2, 3)).to eq(5)
  end
end

shared_context "calculator context" do
  let(:calculator) { Calculator.new }
end

describe Calculator do
  include_context "calculator context"

  it "adds two numbers" do
    expect(calculator.add(2, 3)).to eq(5)
  end
end

expect(result).to eq(5)
expect(result).to eql(5)

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    # 2 + 3 が 5 と等しいことを検証する
    expect(subject.add(2, 3)).to eq(5)
  end
end

expect(result).to equal(5)
expect(result).to be(5)

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    # 2 + 3 が 5 と等しいことを検証する
    expect(subject.add(2, 3)).to be(5)
  end
end

expect(result).not_to eq(5)

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    # 2 + 3 が 5 と等しくないことを検証する
    expect(subject.add(2, 3)).not_to eq(6)
  end
end

expect(result).to be > 5
expect(result).to be >= 5
expect(result).to be < 10
expect(result).to be <= 10

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    # 2 + 3 が 5 より大きいことを検証する
    expect(subject.add(2, 3)).to be > 5
  end
end

expect(result).to be > 5
expect(result).to be_between(1, 10).inclusive
expect(result).to be_within(0.5).of(5.0)

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    # 2 + 3 が 5 以上 10 以下であることを検証する
    expect(subject.add(2, 3)).to be_between(5, 10).inclusive
  end
end

expect(result).to be_odd
expect(result).to be_even

describe Calculator do
  subject { Calculator.new }

  it "adds two numbers" do
    # 2 + 3 が奇数であることを検証する
    expect(subject.add(2, 3)).to be_odd
  end
end

expect(array).to all(be_positive)
expect(array).to all(be_an(Integer))

describe Array do
  subject { [1, 2, 3] }

  it "has all positive numbers" do
    # 配列のすべての要素が正の数であることを検証する
    expect(subject).to all(be_positive)
  end
end

expect(result).to be(true)
expect(result).to be(false)
expect(result).to be(nil)

describe BeTest do
  subject { BeTest.new }

  it "returns true" do
    # true を返すことを検証する
    expect(subject.true_value).to be(true)
  end

  it "returns false" do
    # false を返すことを検証する
    expect(subject.false_value).to be(false)
  end

  it "returns nil" do
    # nil を返すことを検証する
    expect(subject.nil_value).to be(nil)
  end
end

expect(result).to be_truthy
expect(array).to all(be_an(Integer).and(be_positive))
expect(result).to be_a(String).and(start_with("Hello"))

describe MultipleMatchers do
  subject { MultipleMatchers.new }

  it "returns a string starting with 'Hello'" do
    # 文字列であり、"Hello" で始まることを検証する
    expect(subject.greeting).to be_a(String).and(start_with("Hello"))
  end

  it "returns a string containing the user's name" do
    # 文字列であり、ユーザーの名前を含むことを検証する
    expect(subject.greeting).to be_a(String).and(include("John"))
  end

  it "returns an array starting with 'Hello'" do
    # 配列であり、"Hello" で始まることを検証する
    expect(subject.greetings).to be_an(Array).and(start_with("Hello"))
  end

  it "returns an array containing the user's name" do
    # 配列であり、ユーザーの名前を含むことを検証する
    expect(subject.greetings).to be_an(Array).and(include("John"))
  end
end

expect { object.method }.to change(object, :attribute).from(old_value).to(new_value)
expect { object.method }.to change { object.attribute }.from(old_value).to(new_value)

describe ChangeTest do
  subject { ChangeTest.new }

  it "changes the value of the attribute" do
    # メソッドの呼び出しによって属性の値が変化することを検証する
    expect { subject.change_value }.to change(subject, :value).from(1).to(2)
  end

  it "changes the value of the attribute using a block" do
    # メソッドの呼び出しによって属性の値が変化することを検証する
    expect { subject.change_value }.to change { subject.value }.from(1).to(2)
  end
end

expect { object.method }.to change(Model, :count).by(1)

expect(array).to contain_exactly(1, 2, 3)
expect(array).to contain_exactly(*expected_array)

describe Array do
  subject { [1, 2, 3] }

  it "contains exactly the elements" do
    # 配列が指定された要素を正確に含むことを検証する
    expect(subject).to contain_exactly(1, 2, 3)
  end
end

expect(string).to start_with("Hello")
expect(array).to start_with(1, 2, 3)
expect(string).to end_with("World")
expect(array).to end_with(3, 4, 5)

describe StartEndWith do
  subject { "Hello World" }

  it "starts with 'Hello'" do
    # 文字列が "Hello" で始まることを検証する
    expect(subject).to start_with("Hello")
  end

  it "starts with 'Hello' and ends with 'World'" do
    # 文字列が "Hello" で始まり、"World" で終わることを検証する
    expect(subject).to start_with("Hello").and end_with("World")
  end
end

expect(object).to have_attributes(name: "John", age: 30)

describe HaveAttributes do
  subject { HaveAttributes.new }

  it "has the specified attributes" do
    # オブジェクトが指定された属性を持つことを検証する
    expect(subject).to have_attributes(name: "John", age: 30)
  end

  it "has the specified name" do
    # オブジェクトが指定された名前を持つことを検証する
    expect(subject).to have_attributes(name: "John")
  end
end

expect(array).to include(1, 2, 3)

describe Include do
  subject { [1, 2, 3] }

  it "includes the specified elements" do
    # 配列が指定された要素を含むことを検証する
    expect(subject).to include(1)
  end
end

expect { raise StandardError }.to raise_error(StandardError)
expect { object.method }.to raise_error(CustomError)

describe RaiseError do
  subject { RaiseError.new }

  it "raises an error" do
    # エラーが発生することを検証する
    expect { subject.raise_error }.to raise_error(StandardError)
  end

  it "raises a custom error" do
    # カスタムエラーが発生することを検証する
    expect { subject.raise_custom_error }.to raise_error(CustomError)
  end
end

# オブジェクトが指定されたメソッドを持つことを検証する
expect(object).to respond_to(:method)

# オブジェクトが指定されたメソッドを持ち、引数を1つ取ることを検証する
expect(object).to respond_to(:method).with(1).argument

describe RespondTo do
  subject { RespondTo.new }

  it "responds to the specified methods" do
    # オブジェクトが指定されたメソッドを持つことを検証する
    expect(subject).to respond_to(:method)
  end

  it "responds to the specified methods with arguments" do
    # オブジェクトが指定されたメソッドを持ち、引数を1つ取ることを検証する
    expect(subject).to respond_to(:method).with(1).argument
  end
end

expect(result).to be > 5
expect(result).to be_between(1, 10).inclusive
expect(result).to be_within(0.5).of(5.0)
expect(array).to all(be_an(Integer).and(be_positive))
expect(result).to be_a(String).and(start_with("Hello"))

class MovieRatingCalculator
  def initialize(movie)
    @movie = movie
  end

  def calculate
    # 映画の評価を計算する
  end
end

class MovieDatabase
  def find(id)
    # データベースから映画を取得する
  end
end

describe MovieRatingCalculator do
  subject { MovieRatingCalculator.new(movie) }

  let(:movie) { MovieDatabase.new.find(1) }

  it "calculates the movie rating" do
    # 映画の評価を計算する
    expect(subject.calculate).to eq(5)
  end
end

calculator_mock = double("calculator")

expect(calculator_mock).to receive(:add).with(2, 3).and_return(5)

expect(calculator_double).to receive(:add).with(2, 3).and_return(5)

let(:calculator_mock) { double("calculator") }

before do
  allow(Calculator).to receive(:new).and_return(calculator_mock)
end

expect(calculator_mock).to receive(:add).with(2, 3).exactly(3).times

allow(calculator_mock).to receive(:add).and_return(5)

expect(calculator_mock).to receive(:add).with(an_instance_of(Integer), be > 0).and_return(5)

calculator_double = instance_double(Calculator, add: 5)

calculator_class_double = class_double(Calculator, new: calculator_double)

calculator_spy = spy("calculator")
expect(calculator_spy).to receive(:add).with(2, 3).and_return(5)

group :development, :test do
  gem 'rspec-rails', '~> 5.0'
end

group :test do
  gem 'capybara'
  gem 'webdrivers'
end

require 'capybara/rspec'

require 'rails_helper'

RSpec.describe 'Posts', type: :system do
  let(:user) { create(:user) } # テストユーザーを作成

  before do
    # ログインする
    visit login_path
    fill_in 'Email', with: user.email
    fill_in 'Password', with: user.password
    click_button 'Log in'
  end

  it '新規投稿を作成する' do
    # 新規投稿ページに遷移する
    visit new_post_path
    fill_in 'Title', with: 'New Post'
    fill_in 'Content', with: 'Lorem ipsum dolor sit amet.'
    click_button 'Create Post'

    # 投稿が成功したことを検証する
    expect(page).to have_content 'Post was successfully created.'
    expect(page).to have_content 'New Post'
  end
end

fill_in "Title", with: "New Post"  # タイトルフィールドに"New Post"と入力します。
fill_in "Content", with: "Lorem ipsum dolor sit amet."  # コンテンツフィールドに"Lorem ipsum dolor sit amet."と入力します。
click_button "Create Post"         # "Create Post"ボタンをクリックします。

expect(page).to have_content("Post was successfully created.")  # 成功メッセージが表示されていることを確認します。
expect(page).to have_content("New Post")  # 入力したタイトルが表示されていることを確認します。

require 'rails_helper'

RSpec.describe 'Posts', type: :system do
  let(:user) { create(:user) }

  before do
    # ログインする
    visit login_path
    fill_in 'Email', with: user.email
    fill_in 'Password', with: user.password
    click_button 'Log in'
  end

  it '新規投稿に成功する' do
    # 新規投稿ページに移動する
    visit new_post_path
    fill_in 'Title', with: 'New Post'
    fill_in 'Content', with: 'Lorem ipsum dolor sit amet.'
    click_button 'Create Post'

    # 投稿が成功したことを検証する
    expect(page).to have_content 'Post was successfully created.'
    expect(page).to have_content 'New Post'
  end

  it '投稿の編集に成功する' do
    # 投稿を作成する
    post = create(:post, user: user)

    # 投稿を編集する
    visit edit_post_path(post)
    fill_in 'Title', with: 'Updated Post'
    fill_in 'Content', with: 'Updated content'
    click_button 'Update Post'

    # 投稿が更新されたことを検証する
    expect(page).to have_content 'Post was successfully updated.'
    expect(page).to have_content 'Updated Post'
  end

  it '投稿の削除に成功する' do
    # 投稿を作成する
    post = create(:post, user: user)

    # 投稿を削除する
    visit posts_path
    click_link 'Destroy'

    # 投稿が削除されたことを検証する
    expect(page).to have_content 'Post was successfully destroyed.'
    expect(page).not_to have_content post.title
  end
end

click_link "New Post"  # "New Post"リンクをクリックします。
expect(page).to have_current_path(new_post_path)  # 新しい投稿のページにリダイレクトされていることを検証します。

require 'rails_helper'

# リンクが正しく機能しているかをテストする
RSpec.describe 'Links', type: :system do
  let(:user) { create(:user) }

  it '新規投稿ページに遷移する' do
    # ログインする
    visit login_path
    fill_in 'Email', with: user.email
    fill_in 'Password', with: user.password
    click_button 'Log in'

    # "New Post"リンクをクリックする
    click_link 'New Post'

    # 新しい投稿のページにリダイレクトされていることを検証する
    expect(page).to have_current_path(new_post_path)
  end

  it 'ログインページにリダイレクトされる' do
    visit posts_path

    # ログインページにリダイレクトされていることを検証する
    expect(page).to have_current_path(login_path)
  end
end

allow(ExternalService).to receive(:call).and_return(true)  # 外部サービスの呼び出しをスタブ化し、常にtrueを返すように設定します。

result = ExternalService.call  # スタブ化したメソッドを呼び出します。
expect(result).to be_truthy  # 結果がtrueであることを検証します。

require 'rails_helper'

# 外部サービスとの連携をテストする
RSpec.describe 'ExternalService', type: :system do
  it '外部サービスとの連携をテストする' do
    # 外部サービスの呼び出しをスタブ化し、常にtrueを返すように設定する
    allow(ExternalService).to receive(:call).and_return(true)

    # 外部サービスを呼び出す
    result = ExternalService.call

    # 結果がtrueであることを検証する
    expect(result).to be_truthy
  end
end

# リクエストスペックの例
post "/posts", params: { post: { title: "New Post", content: "Lorem ipsum dolor sit amet." } }  # 新しい投稿を作成するリクエストを送信します。
expect(response).to have_http_status(:created)  # レスポンスステータスが201（作成済み）であることを検証します。

# レスポンススペックの例
get "/posts/1"  # 投稿の詳細ページにアクセスします。
expect(response.body).to include("New Post")  # レスポンスボディに"New Post"が含まれていることを検証します。

require 'rails_helper'

# リクエストとレスポンスが正しく機能しているかをテストする
RSpec.describe 'Requests and Responses', type: :system do
  let(:user) { create(:user) }
  let(:post) { create(:post, user: user) }

  it 'shows the post list' do
    # ログインする
    visit login_path
    fill_in 'Email', with: user.email
    fill_in 'Password', with: user.password
    click_button 'Log in'

    # 投稿一覧ページにアクセスする
    get "/posts"

    # レスポンスステータスが200（成功）であることを検証する
    expect(response).to have_http_status(:ok)
  end

  it 'shows the post' do
    # 投稿の詳細ページにアクセスする
    get "/posts/#{post.id}"

    # レスポンスボディに"New Post"が含まれていることを検証する
    expect(response.body).to include("New Post")
  end

  it 'redirects to the login page' do
    # 投稿一覧ページにアクセスする
    get "/posts"

    # 未ログイン時、レスポンスステータスが302（一時的なリダイレクト）であることを検証する
    expect(response).to have_http_status(:found)
  end

  it 'creates a new post' do
    # 新しい投稿を作成するリクエストを送信する
    post "/posts", params: { post: { title: "New Post", content: "Lorem ipsum dolor sit amet." } }

    # レスポンスステータスが201（作成済み）であることを検証する
    expect(response).to have_http_status(:created)
  end
end

require 'rails_helper'

# ビューのテストを行う
RSpec.describe 'Posts', type: :system do
  let(:user) { create(:user) }
  let(:post) { create(:post, user: user) }

  it 'shows the post' do
    # 投稿の詳細ページをレンダリングする
    render template: "posts/show", locals: { post: post }

    # レンダリングされたビューに"New Post"が含まれていることを検証する
    expect(rendered).to match /New Post/
  end
end

@post = Post.new(title: "New Post", content: "Lorem ipsum dolor sit amet.")  # 新しい投稿を作成します。

expect(@post).to be_valid  # 投稿が有効であることを検証します。
expect(@post.title).to eq "New Post"  # タイトルが正しく設定されていることを検証します。

require 'rails_helper'

# モデルのテストを行う
RSpec.describe Post, type: :model do
  let(:user) { create(:user) }

  # タイトルと内容があれば有効な状態であること
  it 'タイトルと内容があれば有効な状態であること' do
    # 新しい投稿を作成する
    post = Post.new(title: "New Post", content: "てすと")

    # 投稿が有効であることを検証する
    expect(post).to be_valid
  end

  it 'タイトルがなければ無効な状態であること' do
    # タイトルがない投稿を作成する
    post = Post.new(title: nil, content: "てすと")

    # タイトルがない投稿が無効であることを検証する
    expect(post).to be_invalid
  end

  it '内容がなければ無効な状態であること' do
    # 内容がない投稿を作成する
    post = Post.new(title: "New Post", content: nil)

    # 内容がない投稿が無効であることを検証する
    expect(post).to be_invalid
  end

  it '重複したタイトルの投稿は無効な状態であること' do
    # 重複したタイトルの投稿を作成する
    Post.create(title: "New Post", content: "てすと")
    post = Post.new(title: "New Post", content: "てすと")

    # 重複したタイトルの投稿が無効であることを検証する
    expect(post).to be_invalid
  end

  it 'タイトルが50文字以内であること' do
    # 51文字のタイトルの投稿を作成する
    post = Post.new(title: "a" * 51, content: "てすと")

    # 51文字のタイトルの投稿が無効であることを検証する
    expect(post).to be_invalid
  end
end