RSpec_guide_temp

목차
* Configuration
* Style Guide Rules
* Controller
* Model
* Helpers
* Examples

Configuration
…

Style Guide Rules

* 하나의 클래스 당 하나의 RSpec 문서를 원칙으로 한다.
* 각 클래스의 테스트 코드는 해당 클래스의 동작만을 테스트 한다. 
만약 해당 클래스에서 외부 클래스를 사용할 경우 외부 클래스를 정상적으로 이용하는 지에 대해서만 테스트 한다. 
(외부 클래스의 내부 동작이 정상적인 지에 대해서는 해당 클래스 테스트에서 테스트한다.)
* 해당 클래스의 public method 전체에 대하여 테스트 한다. (발생할 수 있는 모든 예외 상황에 대해 테스트 케이스를 작성한다)
* private method 는 테스트 하지 않는다. (해당 private method 를 호출하는 public method 가 정상 동작하여 문제가 없다면 내부 구현 사항 또한 정상적으로 동작하는 것이라고 판단한다.)
* 테스트 코드 설명은 원칙 상 한글로 작성한다. 한글로 작성할 수 없는 경우에는 영어로 표기한다. (이 문서의 더미 코드 예시는 편의상 영어가 섞여 있습니다.)
* 발견한 버그에 대해서는 해당 버그 재발을 방지하기 위해 테스트 케이스를 추가한다.

* feature, context, describe 다음 줄은 붙여쓴다.
# Bad Example
describe Article do

  describe ‘#summary’ do

    context ‘when there is a summary’ do

      it ‘returns the summary’ do
        # …
      end
    end
  end
end

# Good Example
describe Article do
  describe ‘#summary’ do
    context ‘when there is a summary’ do
      it ‘returns the summary’ do
        # …
      end
    end
  end
end

* let, subject, before/after 블록 다음 줄은 한 줄 띈다.
# Bad Example
describe Article do
  subject { FactoryGirl.create(:some_article) }
  describe ‘#summary’ do
    # …
  end
end

# Good Example
describe Article do
  subject { FactoryGirl.create(:some_article) }

  describe ‘#summary’ do
    # …
  end
end

* let, subject 는 서로 붙여 쓰고, before 및 after 블록 사이에는 한 줄 띄어쓴다.
# Bad Example
describe Article do
  subject { FactoryGirl.create(:some_article) }
  let(:user) { FactoryGirl.create(:user) }
  before do
    # …
  end
  after do
    # …
  end
  describe ‘#summary’ do
    #…
  end
end

# Good Example
describe Article do
  subject { FactoryGirl.create(:some_article) }
  let(:user) { FactoryGirl.create(:user) }

  before do
    # …
  end

  after do
    # …
  end

  describe ‘#summary’ do
    # …
  end
end

* it 블록 사이에는 한 줄 띈다.
# Bad Example
describe ‘#summary’ do
  let(:item) { double(‘something’) }

  it ‘returns the summary’ do
    # …
  end
  it ‘does something else’ do
    # …
  end
  it ‘does another thing’ do
    # …
  end
end

# Good Example
describe ‘#summary’ do
  let(:item) { double(‘something’) }
  
  it ‘returns the summary’ do
    # …
  end

  it ‘does something else’ do
    # …
  end

  it ‘does another thing’ do
    # …
  end
end

* it 블록 하나 당 한 개의 expect 만 사용한다. 
(복수 개의 expect 가 필요한 경우 서로 다른 테스크 케이스로 분리하여 각각 테스트한다)
# Bad Example
describe ArticlesController do
  # …

  describe ‘GET new’ do
    it ‘assigns new article and renders the new article template’ do
      get :new
      expect(assigns[:article]).to be_a(Article)
      expect(response).to render_template :new
    end
  end

  # …
end

# Good Example
describe ArticlesController do
  # …

  describe ‘GET new’ do
    it ‘assigns a new article’ do
      get :new
      
      expect(assigns[:article]).to be_a(Article)
    end

    it ‘renders the new article template’ do
      get :new
      
      expect(response).to render_template :new
    end
  end
end

* context 블록은 항상 반대되는 케이스를 가져야 한다. (context는 describe의 alias 이다)
# Bad Example

# This is a case where refactoring is the correct choice
describe ‘#attributes’ do
  context ‘the returned hash’ do
    it ‘includes the display name’ do
      # …
    end
  
    it ‘includes the creation time’ do
      # …
    end
  end
end

# This is a case where the negative case needs to be tested, but wasn’t
describe ‘#attributes’ do
  context ‘when display name is present’ do
    before do
      subject.display_name = ‘something’
    end

    it ‘includes the display name’ do
      # …
    end
  end
end

# Good Example

# Refactored
describe ‘#attributes’ do
  subject { FactoryGirl.create(:article) }
  
  it { expect(subject.attributes).to include subject.display_name }
  it { expect(subject.attributes).to include subject.created_at }
end

# Added the negative case
describe ‘#attributes’ do
  context ‘when display name is present’ do
    before do
      subject.display_name = ‘something’
    end

    it ‘includes the display name’ do
      # …
    end
  end

  context ‘when display name is not present’ do
    before do
      subject.display_name = nil
    end

    it ‘does not include the display name’ do
      # …
    end
  end
end

* context 블록의 설명은 항상 ‘~경우’, '~할 때’ 로 서술되어야 한다.
# Bad Example
context ‘파일 이름이 존재하지 않음’ do
  # …
end

# Good Example
context ‘파일 이름이 존재하지 않는 경우’ do
  # …
end

* it 블록의 설명에는 상황을 가정하는 조건이 들어가서는 안된다. (상황을 가정하는 조건이 들어갈 경우 context 블록을 사용해야 한다.)
# Bad Example
it ‘returns the display name if it is present’ do
  # …
end

# Good Example
context ‘when display name is present’ do
  it ‘returns the display name’
end

context ‘when display name is not present’ do
  it ‘returns nil’
end

* describe 블록은 public method 를 설명할 때 사용하는 것을 기본으로 한다.
인스턴스 메소드의 경우 ‘#method’, 클래스 메소드의 경우 ‘.method’ 로 설명을 서술한다.
class Article
  def summary
    # …
  end

  def self.latest
    # …
  end
end

# Bad Example
describe Article do
  describe ‘summary’ do
    # …
  end

  describe ‘latest’ do
    # …
  end
end

# Good Example
describe Article do
  describe ‘#summary’ do
    # …
  end
  
  describe ‘.latest’ do
    # …
  end
end

* 반대되는 상황을 테스트할 필요가 없거나, 존재하지 않을 경우, 테스트 케이스를 묶을 때 describe를 사용한다.
describe ‘텍스트 메시지’ do
  it ‘새로운 message 를 저장한다’

  it ‘201 HTTP Response 를 응답한다’
end

describe ‘이미지 첨부 메시지’ do
  it ‘새로운 message 를 저장한다’

  it ‘201 HTTP Response 를 응답한다’
end

* 테스트를 생성할 때 iterator 를 사용하지 않는다. 만약 새로운 요소가 해당 iterator item 에 추가될 경우, 분기를 나누어 코드를 수정해야하는 경우가 생길 수 있다.
따라서 각각의 경우에 대해 따로 따로 테스트를 생성한다.
# Bad Example
[:new, :show, :index].each do |action|
  it ‘returns 200’ do
    get action
    
    expect(response).to be_ok
  end
end

# Good Example
describe ‘GET new’ do
  it ‘returns 200’ do
    get :new
    
    expect(response).to be_ok
  end
end

describe ‘GET show’ do
  it ‘returns 200’ do
    get :show

    expect(response).to be_ok
  end
end

describe ‘GET index’ do
  it ‘returns 200’ do
    get :index

    expect(response).to be_ok
  end
end

* expect 문과 그 이전 코드 사이에는 한 줄 띈다.
# Bad Example
it ‘returns 200’ do
  get :new
  expect(response).to be_ok
end

# Good Example
it ‘returns 200’ do
  get :new

  expect(response).to be_ok
end

* Fixture 대신 Factory Girl 을 사용한다.
subject { FactoryGirl.create(:some_article) }

* 현재 테스트하는 클래스에서 해당 클래스 외부에 존재하는 메소드를 이용하는 경우 해당 메소드의 호출이 정상적인지 만을 테스트한다.
(해당 메소드의 내부 동작이 정상적인 지에 대해서는 해당 메소드가 속해 있는 클래스의 테스트 코드에서 테스트 한다)
describe 'Messenger::MessageCreateService 클래스' do
  let(:expected_pack) { Pack::MessageCreate.new room: room, member: member,
                                                channel: 'in-app', type: 'general', text: '반갑습니다.’ }
  before do
    log_out_user
  end

  it ‘#new 메소드를 정상적으로 호출함' do
    expect(Messenger::MessageCreateService)
        .to receive(:new)
            .with(eq_message_create_pack(expected_pack))
                .and_call_original

    post :create, valid_create_params.merge(member_id: member.id.to_s)
  end

  it ‘#create_general 메소드를 정상적으로 호출함' do
    expect_any_instance_of(Messenger::MessageCreateService)
        .to receive(:create_general)
            .and_call_original

    post :create, valid_create_params.merge(member_id: member.id.to_s)
  end
end

* Time, Date 에 대해 stub 하지 않는다. Timecop 을 사용한다.
# Bad Example
it ‘offsets the time 2 days into the future’ do
  current_time = Time.now
  allow(Time).to receive(:now).and_return(current_time)

  expect(subject.get_offset_time).to be_the_same_time_as (current_time + 2.days)
end

# Good Example
it ‘offsets the time 2 days into the future’ do
  Timecop.freeze(Time.now) do
    expect(subject.get_offset_time).to be_the_same_time_as 2.days.from_now
  end
end
            (#be_the_same_time_as 는 커스텀 matcher)

* 변수 초기화 시 let 블록을 before 블록 대신 사용한다.
# use this:
let(:article) { FactoryGirl.create(:article) }

# … instead of this:
before { @article = FactoryGirl.create(:article) }

* let! 는 가능한 한 사용하지 않는다. (let의 lazy evaluation 을 최대한 활용한다, describe, context 블록 내에서만 사용되는 요소의 경우 해당 블록 내에 let 으로 선언한다) 
describe TalkController do
  let(valid_create_params) { { room_id: room.id, channel: 'in-app', type: 'general', text: '반갑습니다.' } }

  # ...

  describe 'text 값이 존재하지 않음’ do
    # 필요한 블록 내에서만 선언하여 사용한다
    let(:invalid_create_params) { valid_create_params.except(:text) }

    it '새로운 message 가 저장되지 않는다' do
      expect { post :create, invalid_create_params }
          .to change { Messenger::Message.count }.by 0
    end

    it '400 HTTP Response 를 응답한다' do
      post :create, invalid_create_params

      expect(response).to have_http_status(:bad_request)
    end
  end
  # describe 블록 종료 시 선언된 let의 이용 및 lazy evaluation 불가능

  # ...
end

* subject 는 가능한 한 사용한다. (DRY)
describe Article do
  subject { FactoryGirl.create(:article) }

  it ‘is not published on creation’ do
    expect(subject).not_to be_published
  end
end

* 테스트 생성 시 Incidental state 를 최소화 한다.
# Bad Example
it ‘published the article’ do
  article.publish

  # Creating another shared Article test object above would cause this test to break
  expect(Article.count).to eq(2)
end

# Good Example
it ‘published the article’ do
  expect{ article.publish }.to change(Article, :count).by(1)
end


Controller

* 스펙 문서를 바탕으로 각각의 요청 파라미터에 대해 각각의 HTTP Response 가 정상적으로 생성되는 지 테스트한다.
    * 스펙 상 잘못된 요청인 경우 HTTP Response 테스트
        * 로그인 등의 Pre-condition 충족 여부
        * 요청에 필수 파라미터 포함 여부
        * 허용되지 않은 파라미터 값 여부
    * 스펙 상 올바른 요청인 경우 HTTP Response 테스트
        * ex) MessageController
            * 텍스트 메시지 생성
            * 이미지 메시지 생성
            * 파일 메시지 생성
            * 명함 전달 메시지 생성
* 데이터 저장 여부를 테스트 할 때는 HTTP 요청을 실제로 날리고 모델의 count 변화 여부를 테스트 한다.
it '새로운 message 를 생성한다' do
  expect { post :create, valid_create_params }
      .to change { Messenger::Message.count }.by 1
end

* 컨트롤러가 담당하는 역할의 수행이 정상적인 지에 대해서만 테스트한다 (이외의 세부 로직은 외부 클래스(Concern, Service, Model)로 분리하여 구현하고 해당 클래스 테스트 코드에서 테스트 한다)
    * Execution of particular methods
    * Data returned from the action - assigns, saves, etc.
    * Result from the action - template render, redirect, HTTP Response, etc.
describe MessageController do
  describe ‘#index’ do
    context ‘올바른 요청인 경우’ do
      it ‘200 HTTP Response 를 응답한다’

      it ‘생성 시간의 역순으로 메시지 리스트를 돌려준다’
    end

    context ‘올바르지 않은 요청인 경우’ do
      describe ‘로그인이 되어있지 않음’ do
        it ‘401 HTTP Response 를 응답한다’
      end

      describe ‘대화방이 존재하지 않음’ do
        it ‘404 HTTP Response 를 응답한다’
      end

      describe ‘대화방에 사용자가 참여하고 있지 않음’ do
        it ‘401 HTTP Response 를 응답한다’
      end

      describe ‘대화방을 나간 사용자인 경우’ do
        it ‘401 HTTP Response 를 응답한다’
      end
    end
  end

  describe ‘#create’ do
    context ‘올바른 요청인 경우’ do
      describe ‘텍스트 메시지’ do
        it ‘새로운 message 를 저장한다’

        it ‘201 HTTP Response 를 응답한다’
      end

      describe ‘이미지 첨부 메시지’ do
        it ‘새로운 message 를 저장한다’

        it ‘201 HTTP Response 를 응답한다’
      end

      describe ‘파일 첨부 메시지’ do
        it ‘새로운 message 를 저장한다’

        it ‘201 HTTP Response 를 응답한다’
      end

      describe ‘명함 전달 메시지’ do
        it ‘새로운 message 를 저장한다’
    
        it ‘201 HTTP Response 를 응답한다’
      end

      describe ‘이메일 메시지’ do
        it ‘새로운 message 를 저장한다’
    
        it ‘201 HTTP Response 를 응답한다’
      end

      describe ‘로그인이 되어있지 않아 member_id 로 처리’ do
        it ‘201 HTTP Response 를 응답한다’
      end
    end
    
    context ‘올바르지 않은 요청인 경우’ do
      describe ‘로그인이 되어있지 않고 member_id 가 올바르지 않음’ do
        it ‘새로운 message 가 저장되지 않는다'

        it ‘401 HTTP Response 를 응답한다’
      end
    
      describe ‘type 값이 존재하지 않음’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘400 HTTP Response 를 응답한다’
      end

      describe ‘type 값이 올바르지 않음’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘400 HTTP Response 를 응답한다’
      end

      describe ‘text 값이 존재하지 않음’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘400 HTTP Response 를 응답한다’
      end

      describe ‘text 값이 빈 문자열’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘400 HTTP Response 를 응답한다’
      end

      describe ‘1:1 대화면서 수신자가 메시지 수신 가능한 채널이 없음’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘400 HTTP Response 를 응답한다’
      end

      describe ‘대화방이 존재하지 않음’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘404 HTTP Response 를 응답한다’
      end

      describe ‘대화방에 사용자가 참여하고 있지 않음’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘401 HTTP Response 를 응답한다’
      end

      describe ‘대화방을 나간 사용자인 경우’ do
        it ‘새로운 message 가 저장되지 않는다’

        it ‘401 HTTP Response 를 응답한다’
      end
    end
  end
end



Model

* 모델의 테스트 코드에서 해당 모델을 mock 하여 사용하지 않도록 한다.
* FactoryGirl.create 를 사용하여 실제 객체를 만들어서 테스트하거나, subject 를 이용하여 저장되지 않은 인스턴스를 이용하여 테스트한다.
describe Article do
  # FactoryGirl 을 이용하여 실제 객체를 만들어서 사용하거나
  let(:article) { FactoryGirl.create(:article) }

  # subject 를 통해 저장되지 않은 인스턴스를 이용하여 테스트 한다
  # (subject 를 새로 선언하기 전의 ‘subject’는 ‘Article.new’와 동일하다)
  it ‘is an instance of Article’ do
    expect(subject).to be_an Article
  end
  
  it ‘is not persisted’ do
    expect(subject).to_not be_persisted
  end
end

* 다른 모델의 mock 은 사용해도 된다.
* 모든 테스트 케이스에서 모델 객체를 새로 생성하여 테스트한다. (let 또는 subject 이용)
* FactoryGirl.created model 을 사용할 경우 해당 모델이 유효한 지 검사하는 테스트 케이스를 추가해야 한다.
describe Article do
  let(:article) { FactoryGirl.create(:article) }

  it ‘is valid with valid attributes’ do
    expect(article).to be_valid)
  end
end

* validation 테스트의 경우 expect(model.errors[:attribute].size).to eq(x) 를 사용한다. (be_valid 의 경우 에러 발생 원인이 해당 attribute인지 확신할 수 없다.) 
# Bad Example
describe ‘#title’ do
  it ‘is required’ do
    article.title = nil

    expect(article).to_not be_valid
  end
end

# Good Example
describe ‘#title’ do
  it ‘is required’ do
    article.title = nil
    article.valid?

    expect(article.errors[:title].size).to eq(1)
  end
end

* 각각의 attribute 의 validation 에 대하여 describe 를 작성한다. 
module Blog
  class Article
    # …
    validates :title, presence: true
    validates :content, presence: true
    # … 
  end
end

# RSpec
describe ‘Validations’ do
  describe ‘#title’ do
    it ‘is required’
  end

  describe ‘#content’ do
    it ‘is required’
  end
end

* uniqueness 를 테스트 할 경우 새로운 객체를 another_object 와 같은 이름으로 생성하여 테스트 한다.
describe Article do
  describe ‘#title’ do
    it ‘is unique’ do
      another_article = FactoryGirl.create(:article, title: article.title)
      article.valid?

      expect(another_article.errors[:title].size).to eq(1)
    end
  end
end




Helper

* API 에서의 Helper 는 View Helper 로 사용한다.
* View Helper 테스트의 경우, view를 만드는 public method 를 직접 호출하여 리턴받은 데이터가 스펙의 응답 양식과 동일한 지 테스트 한다.
 (컨트롤러의 (http 요청) 없이 테스트 한다)
describe TalkViewHelper do
  # … 

  def valid_talk_view(talk)
      {
          uid: talk.uid,
          room_id: talk.room_id,
          member_id: talk.member_id.to_s,
          channel: talk.channel,
          type: talk.type, 
          text: talk.text,
          created_at: talk.created_at
      }
  end

  describe ‘#talk_view’ do
    context ‘talk 이 존재하는 경우’ do
      it ‘올바른 응답 데이터를 리턴한다’ do
        actual = helper.send(:talk_view, talk)

        expect(actual).to eq(valid_talk_view(talk))
      end
    end

    context ‘talk 이 존재하지 않는 경우’ do
      it ‘nil 값을 리턴한다’ do
        talk = nil
        actual = helper.send(:talk_view, talk)

        expect(actual).to be_nil
    end
  end
end