Você decidiu usar Rails Engines na sua aplicação ou herdou um projeto que faz uso delas e você gostaria de entender como o fluxo funciona. O Rails guides possui uma introdução bem completa sobre o que são as tais das Engines (http://guides.rubyonrails.org/engines.html)

Dentre seus usos, a capacidade de isolar uma parte do sistema, encapsulando seu funcionamento, é uma característica que, quando bem utilizada, poderá ser um grande trunfo na evolução de seu sistema.

É importante ressaltar que servem como módulos e deverão ser “plugados” na aplicação principal. Portanto, tome cuidado com a dependência de código. Tente levar sempre em consideração os princípios SOLID para abstração do código.

Dito isto, vamos ao que interessa.

Criando a uma Rails Engine do zero:

$ rails plugin new core -T --mountable --full --dummy-path=spec/dummy_app

Ao utilizarmos o comando rails plugin —help podemos verificar as opções utilizadas na instrução:

-T                 # Skip Test::Unit files
--mountable        # Generate mountable isolated application
--full             # Generate a rails engine with bundled Rails
                     application for testing
--dummy-path       # Create dummy application at given path

Se por algum motivo, a engine for gerada sem o dummy spec, não tem problema, ele foi feito para não ser ligado a aplicação principal, então você pode criá-lo em outro lugar e depois movê-lo para seu lugar final.

Nesse post, vamos usar o RSpec como framework de testes. Para configurarmos ele com nossa engine, iremos adicionar a dependência ao nosso arquivo .gemspec na raiz da engine.

Isso se dá porque, de acordo com a documentação do Rails, a engine pode ser adicionada como uma Gem futuramente e se as dependências estivessem no GemFile, elas poderiam não ser reconhecidas na hora da instalação, o que causaria bugs.

Gem::Specification.new do |s|
  ...
  s.add_dependency "rspec-rails", "~> 3.0"
end

Feito isso, iremos executar o comando bundle install no terminal, dentro da pasta core.

Na raiz da nossa aplicação, deve existir um arquivo no caminho lib/core/engine.rb. Iremos configurá-lo para incluir o RSpec.

module Core
  class Engine < ::Rails::Engine
    isolate_namespace Core

    config.generators do |g|
      g.test_framework :rspec
    end
  end
end

E logo depois rails generate rspec:install, conforme a documentação do rspec, para criar o diretório spec (onde os testes irão ficar).

No arquivo spec/rails_helper.rb iremos adicionar uma configuração para que nossos testes olhem para o arquivo de configuração da engine.

require "dummy_app/config/environment"

Para testarmos nosso fluxo, podemos gerar um simples model:

$ rails generate model article title:string text:text

$ bundle exec rake db:migrate RAILS_ENV=test

Dentro da nossa dummy_app de testes, vamos configurar as rotas em spec/dummy_app/config/ para apontar para a raíz de nossa aplicacação.

Rails.application.routes.draw do
  mount Core::Engine => "/"
end

Apenas para validarmos o fluxo, vamos inserir duas regras de validação no nosso modelo:

module Core
  class Article < ActiveRecord::Base
    validates :title, :text, presence: true
  end
end

require 'rails_helper'

module Core
  RSpec.describe Article, type: :model do
    it 'requires title' do
      article = Article.create(title: nil)
      expect(article.errors[:title].any?).to eq(true)
    end
    it 'requires text' do
      article = Article.create(text: nil)
      expect(article.errors[:text].any?).to eq(true)
    end
  end
end

E então rodar nossos testes com bundle exec rspec

Pronto, nossa engine está configurada com RSpec como suíte de testes, agora é só codificar.

O código final pode ser encontrado aqui (https://github.com/amandasposito/rails-engines-rspec).

Até mais!

Referências

• http://rspec.info/
• http://guides.rubyonrails.org
• http://guides.rubyonrails.org/engines.html