require 'rails_helper'

class TestUser

  def speak
    :speak
  end
end

class TestException < StandardError
end

RSpec.describe 'Configure Response' do
  let(:user) { TestUser.new }

  it 'returns nil by default' do
    allow(user).to receive(:speak)

    expect(user.speak).to be_nil
  end

  it 'returns specific value' do
    expected_message = 'speak'
    allow(user).to receive(:speak).and_return(expected_message)

    expect(user.speak).to eq(expected_message)
  end

  it 'returns different values for multiple calls' do
    expected_messages = ["message 1", "message 2", "message 3"]
    allow(user).to receive(:speak).and_return(*expected_messages)

    expect(user.speak).to eq(expected_messages[0])
    expect(user.speak).to eq(expected_messages[1])
    expect(user.speak).to eq(expected_messages[2])
  end

  context 'when raising errors' do
    it 'raises an Exception class' do
      expected_exception_klass = TestException
      allow(user).to receive(:speak).and_raise(TestException)

      begin
        user.speak
      rescue => error
        expect(error).to be_a(expected_exception_klass)
      end
    end

    it 'raises an error with message' do
      expected_error_message = 'test error message'
      allow(user).to receive(:speak).and_raise(expected_error_message)

      begin
        user.speak
      rescue => error
        expect(error.message).to eq(expected_error_message)
      end
    end

    it 'raises an Exception class with message' do
      expected_exception_klass = TestException
      expected_error_message   = 'test error message'
      allow(user).to receive(:speak).and_raise(expected_exception_klass, expected_error_message)

      begin
        user.speak
      rescue => error
        expect(error).to be_a(expected_exception_klass)
        expect(error.message).to eq(expected_error_message)
      end
    end

    it 'raises an instance of an Exception class' do
      expected_exception_instance = TestException.new
      allow(user).to receive(:speak).and_raise(expected_exception_instance)

      begin
        user.speak
      rescue => error
        expect(error).to eq(expected_exception_instance)
      end
    end
  end

  it 'throws a symbol with an argument' do
    expected_message = "yell"
    allow(user).to receive(:speak).and_throw(:yell, expected_message)

     message = catch :yell do
      user.speak
     end

     expect(message).to eq(expected_message)
  end

  it 'yields an argument' do
    message1 = "hello"
    message2 = "world"

    expected_message = [message1, message2].join(' ')

    allow(user).to receive(:speak).and_yield(message1, message2)

    message = user.speak do |msg1, msg2|
      [msg1, msg2].join(' ')
    end

    expect(message).to eq(expected_message)
  end

  context 'when partial doubles' do
    it 'calls original implementation' do
      expected_message = :speak
      allow(user).to receive(:speak).and_call_original

      expect(user.speak).to eq(expected_message)
    end

    it 'wraps original implementation' do
      expected_message = 'speak'
      allow(user).to receive(:speak).and_wrap_original do |mthd,  args|
        result = mthd.call(*args)

        result.to_s
      end

      expect(user.speak).to eq(expected_message)
    end
  end
end