Тестирование модулей в rspec

Question

Каковы лучшие практики по тестированию модулей в rspec? У меня есть несколько модулей, которые включены в несколько моделей, и сейчас у меня просто есть дублирующие тесты для каждой модели (с небольшими отличиями). Есть ли способ высушить это?

Answer 1

Рад пути =>

let(:dummy_class) { Class.new { include ModuleToBeTested } }

В качестве альтернативы вы можете расширить тестовый класс с помощью вашего модуля:

let(:dummy_class) { Class.new { extend ModuleToBeTested } }

Использование 'let' лучше, чем использование переменной экземпляра для определения фиктивного класса в before (: each)

Когда использовать RSpec let ()?

Answer 2

Что сказал Майк. Вот тривиальный пример:

код модуля ...

module Say
  def hello
    "hello"
  end
end

фрагмент спецификации ...

class DummyClass
end

before(:each) do
  @dummy_class = DummyClass.new
  @dummy_class.extend(Say)
end

it "get hello string" do
  expect(@dummy_class.hello).to eq "hello"
end

Answer 3

Для модулей, которые можно тестировать отдельно или издеваться над классом, мне нравится что-то вроде:

Модуль:

module MyModule
  def hallo
    "hallo"
  end
end

спецификация:

describe MyModule do
  include MyModule

  it { hallo.should == "hallo" }
end

Может показаться неправильным захватывать вложенные группы примеров, но мне нравится краткость. Есть мысли?

Answer 4

Я нашел лучшее решение на домашней странице rspec. По-видимому, он поддерживает общие группы примеров. От https://www.relishapp.com/rspec/rspec-core/v/2-13/docs/example-groups/shared-examples!

Группы общих примеров

Вы можете создавать общие группы примеров. и включить эти группы в другие группы.

Предположим, у вас есть поведение, которое относится ко всем изданиям вашего продукт, большой и маленький.

Во-первых, выделите «общий» поведение:

shared_examples_for "all editions" do   
  it "should behave like all editions" do   
  end 
end

тогда, когда вам нужно определить поведение для больших и малых изданий, ссылаться на общее поведение, используя метод it_should_behave_like ().

describe "SmallEdition" do  
  it_should_behave_like "all editions"
  it "should also behave like a small edition" do   
  end 
end

Answer 5

Сверху моей головы, не могли бы вы создать фиктивный класс в своем тестовом скрипте и включить в него модуль? Затем проверьте, что фиктивный класс ведет себя так, как вы ожидаете.

РЕДАКТИРОВАТЬ: Если, как указано в комментариях, модуль ожидает, что некоторые поведения будут присутствовать в классе, в который он смешан, то я бы попытался реализовать фиктивные значения этих поведений. Достаточно, чтобы модуль с радостью выполнял свои обязанности.

Тем не менее, я буду немного нервничать по поводу своего дизайна, когда модуль ожидает многого от своего хоста (мы говорим "хост"?) - если я еще не наследую от базового класса или могу не добавляю новые функциональные возможности в дерево наследования, тогда, я думаю, я бы попытался минимизировать любые такие ожидания, которые может иметь модуль. Меня беспокоит то, что мой дизайн может начать развиваться в некоторых областях с неприятной негибкостью.

Answer 6

Я считаю, что принятый ответ является правильным, но я хотел бы добавить пример использования методов rpsecs shared_examples_for и it_behaves_like. Я упоминаю несколько трюков в фрагменте кода, но для получения дополнительной информации см. relishapp-rspec-guide

С этим вы можете протестировать ваш модуль в любом из классов, которые его включают. То есть вы действительно тестируете то, что используете в своем приложении.

Давайте рассмотрим пример:

# Lets assume a Movable module
module Movable
  def self.movable_class?
    true
  end

  def has_feets?
    true
  end
end

# Include Movable into Person and Animal
class Person < ActiveRecord::Base
  include Movable
end

class Animal < ActiveRecord::Base
  include Movable
end

Теперь давайте создадим спецификацию для нашего модуля: movable_spec.rb

shared_examples_for Movable do
  context 'with an instance' do
    before(:each) do
      # described_class points on the class, if you need an instance of it: 
      @obj = described_class.new

      # or you can use a parameter see below Animal test
      @obj = obj if obj.present?
    end

    it 'should have feets' do
      @obj.has_feets?.should be_true
    end
  end

  context 'class methods' do
    it 'should be a movable class' do
      described_class.movable_class?.should be_true
    end
  end
end

# Now list every model in your app to test them properly

describe Person do
  it_behaves_like Movable
end

describe Animal do
  it_behaves_like Movable do
    let(:obj) { Animal.new({ :name => 'capybara' }) }
  end
end

Answer 7

моя недавняя работа, используя как можно меньше жесткой проводки

require 'spec_helper'

describe Module::UnderTest do
  subject {Object.new.extend(described_class)}

  context '.module_method' do
    it {is_expected.to respond_to(:module_method)}
    # etc etc
  end
end

желаю

subject {Class.new{include described_class}.new}

работает, но не работает (как в Ruby MRI 2.2.3 и RSpec :: Core 3.3.0)

Failure/Error: subject {Class.new{include described_class}.new}
  NameError:
    undefined local variable or method `described_class' for #<Class:0x000000063a6708>

Очевидно, что описанный_класс не виден в этой области.

Answer 8

Я бы предложил, чтобы для более крупных и часто используемых модулей был выбран «Группы общих примеров», как предложено @Andrius здесь . Для простых вещей, для которых вы не хотите испытывать трудности с наличием нескольких файлов и т. Д., Вот как обеспечить максимальный контроль над видимостью ваших пустышек (протестировано с помощью rspec 2.14.6, просто скопируйте и вставьте код в spec-файл и запустите его):

module YourCoolModule
  def your_cool_module_method
  end
end

describe YourCoolModule do
  context "cntxt1" do
    let(:dummy_class) do
      Class.new do
        include YourCoolModule

        #Say, how your module works might depend on the return value of to_s for
        #the extending instances and you want to test this. You could of course
        #just mock/stub, but since you so conveniently have the class def here
        #you might be tempted to use it?
        def to_s
          "dummy"
        end

        #In case your module would happen to depend on the class having a name
        #you can simulate that behaviour easily.
        def self.name
          "DummyClass"
        end
      end
    end

    context "instances" do
      subject { dummy_class.new }

      it { subject.should be_an_instance_of(dummy_class) }
      it { should respond_to(:your_cool_module_method)}
      it { should be_a(YourCoolModule) }
      its (:to_s) { should eq("dummy") }
    end

    context "classes" do
      subject { dummy_class }
      it { should be_an_instance_of(Class) }
      it { defined?(DummyClass).should be_nil }
      its (:name) { should eq("DummyClass") }
    end
  end

  context "cntxt2" do
    it "should not be possible to access let methods from anohter context" do
      defined?(dummy_class).should be_nil
    end
  end

  it "should not be possible to access let methods from a child context" do
    defined?(dummy_class).should be_nil
  end
end

#You could also try to benefit from implicit subject using the descbie
#method in conjunction with local variables. You may want to scope your local
#variables. You can't use context here, because that can only be done inside
#a describe block, however you can use Porc.new and call it immediately or a
#describe blocks inside a describe block.

#Proc.new do
describe "YourCoolModule" do #But you mustn't refer to the module by the
  #constant itself, because if you do, it seems you can't reset what your
  #describing in inner scopes, so don't forget the quotes.
  dummy_class = Class.new { include YourCoolModule }
  #Now we can benefit from the implicit subject (being an instance of the
  #class whenever we are describing a class) and just..
  describe dummy_class do
    it { should respond_to(:your_cool_module_method) }
    it { should_not be_an_instance_of(Class) }
    it { should be_an_instance_of(dummy_class) }
    it { should be_a(YourCoolModule) }
  end
  describe Object do
    it { should_not respond_to(:your_cool_module_method) }
    it { should_not be_an_instance_of(Class) }
    it { should_not be_an_instance_of(dummy_class) }
    it { should be_an_instance_of(Object) }
    it { should_not be_a(YourCoolModule) }
  end
#end.call
end

#In this simple case there's necessarily no need for a variable at all..
describe Class.new { include YourCoolModule } do
  it { should respond_to(:your_cool_module_method) }
  it { should_not be_a(Class) }
  it { should be_a(YourCoolModule) }
end

describe "dummy_class not defined" do
  it { defined?(dummy_class).should be_nil }
end

Answer 9

А как же:

describe MyModule do
  subject { Object.new.extend(MyModule) }
  it "does stuff" do
    expect(subject.does_stuff?).to be_true
  end
end

Answer 10

Вы также можете использовать вспомогательный тип

# api_helper.rb
module Api
  def my_meth
    10
  end
end

# spec/api_spec.rb
require "api_helper"

RSpec.describe Api, :type => :helper do
  describe "#my_meth" do
    it { expect( helper.my_meth ).to eq 10 }
  end
end

Вот документация: https://www.relishapp.com/rspec/rspec-rails/v/3-3/docs/helper-specs/helper-spec