dry_crud 1.7.0 → 2.0.0

data/lib/generators/dry_crud/templates/spec/support/crud_controller_test_helper.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 # Contains assertions for testing common crud controller use cases.
 # See crud_controller_examples for use cases.
 module CrudControllerTestHelper
@@ -7,30 +9,32 @@ module CrudControllerTestHelper
   def perform_request
     m = example.metadata
     example_params = respond_to?(:params) ? send(:params) : {}
-    params = scope_params.merge(:format => m[:format])
-    params.merge!(:id => test_entry.id) if m[:id]
+    params = scope_params.merge(format: m[:format])
+    params.merge!(id: test_entry.id) if m[:id]
     params.merge!(example_params)
     send(m[:method], m[:action], params)
   end
 
-  # If a combine key is given in metadata, only the first request for all examples
-  # with the same key will be performed.
+  # If a combine key is given in metadata, only the first request for all
+  # examples with the same key will be performed.
   def perform_combined_request
-    if stack = example.metadata[:combine]
+    stack = example.metadata[:combine]
+    if stack
       @@current_stack ||= nil
-      if stack == @@current_stack && described_class == @@current_controller.class
+      if stack == @@current_stack &&
+         described_class == @@current_controller.class
         @response = @@current_response
-        @templates = @@current_templates
+        @_templates = @templates = @@current_templates
         @controller = @@current_controller
         @request = @@current_request
       else
         perform_request
-        
+
         @@current_stack = stack
         @@current_response = @response
         @@current_request = @request
         @@current_controller = @controller
-        @@current_templates = @templates
+        @@current_templates = @_templates || @templates
       end
     else
       perform_request
@@ -41,7 +45,7 @@ module CrudControllerTestHelper
   def scope_params
     params = {}
     # for nested controllers, add parent ids to each request
-    Array(controller.nesting).reverse.inject(test_entry) do |parent, p|
+    Array(controller.nesting).reverse.reduce(test_entry) do |parent, p|
       if p.is_a?(Class) && p < ActiveRecord::Base
         assoc = p.name.underscore
         params["#{assoc}_id"] = parent.send(:"#{assoc}_id")
@@ -52,57 +56,61 @@ module CrudControllerTestHelper
     end
     params
   end
-  
+
+  # Helper methods to describe contexts.
   module ClassMethods
-    
+
     # Describe a certain action and provide some usefull metadata.
     # Tests whether this action is configured to be skipped.
     def describe_action(method, action, metadata = {}, &block)
-      describe("#{method.to_s.upcase} #{action}", 
-               {:if => described_class.instance_methods.collect(&:to_s).include?(action.to_s), 
-                :method => method, 
-                :action => action}.
-               merge(metadata), 
+      action_defined = described_class.instance_methods
+                         .map(&:to_s).include?(action.to_s)
+      describe("#{method.to_s.upcase} #{action}",
+               { if: action_defined,
+                 method: method,
+                 action: action }.merge(metadata),
                &block)
     end
-    
+
+    # Is the current context part of the skip list.
     def skip?(options, *contexts)
       options ||= {}
       contexts = Array(contexts).flatten
       skips = Array(options[:skip])
       skips = [skips] if skips.blank? || !skips.first.is_a?(Array)
-      
-      skips.flatten.present? && 
+
+      skips.flatten.present? &&
       skips.any? { |skip| skip == contexts.take(skip.size) }
     end
-    
+
     # Test the response status, default 200.
     def it_should_respond(status = 200)
       its(:status) { should == status }
     end
-    
+
     # Test that entries are assigned.
     def it_should_assign_entries
-      it "should assign entries" do
+      it 'should assign entries' do
         entries.should be_present
       end
     end
-    
+
     # Test that entry is assigned.
     def it_should_assign_entry
-      it "should assign entry" do
+      it 'should assign entry' do
         entry.should == test_entry
       end
     end
-    
-    # Test that the given template or the main template of the action under test is rendered. 
+
+    # Test that the given template or the main template of the action under
+    # test is rendered.
     def it_should_render(template = nil)
       it { should render_template(template || example.metadata[:action]) }
     end
-    
+
     # Test that test_entry_attrs are set on entry.
     def it_should_set_attrs(action = nil)
-      it "should set params as entry attributes" do
+      it 'should set params as entry attributes' do
         attrs = send("#{action}_entry_attrs")
         actual = {}
         attrs.keys.each do |key|
@@ -111,50 +119,51 @@ module CrudControllerTestHelper
         actual.should == attrs
       end
     end
-    
+
     # Test that the response redirects to the index action.
     def it_should_redirect_to_index
-      it { should redirect_to scope_params.merge(:action => 'index', :returning => true) } 
+      it do
+        should redirect_to scope_params.merge(action: 'index',
+                                              returning: true)
+      end
     end
-    
+
     # Test that the response redirects to the show action of the current entry.
     def it_should_redirect_to_show
-      it { should redirect_to scope_params.merge(:action => 'show', :id => entry.id) } 
+      it do
+        should redirect_to scope_params.merge(action: 'show',
+                                              id: entry.id)
+      end
     end
-    
+
     # Test that the given flash type is present.
     def it_should_have_flash(type, message = nil)
-      context "flash" do
-        subject { flash }
-        
-        its([type]) do
-          should(message ? match(message) : be_present)
-        end
+      it "flash(#{type}) is set" do
+        flash[type].should(message ? match(message) : be_present)
       end
     end
 
     # Test that not flash of the given type is present.
     def it_should_not_have_flash(type)
-      context "flash" do
-        subject { flash }
-        its([type]) { should be_blank }
+      it "flash(#{type}) is nil" do
+        flash[type].should be_blank
       end
     end
-    
+
     # Test that the current entry is persistend and valid, or not.
     def it_should_persist_entry(bool = true)
-      context "entry" do
+      context 'entry' do
         subject { entry }
-    
+
         if bool
-          it { should be_persisted }
+          it { should_not be_new_record }
           it { should be_valid }
         else
-          it { should_not be_persisted }
+          it { should be_new_record }
         end
       end
     end
   end
-  
+
 end
 

data/lib/generators/dry_crud/templates/test/{functional → controllers}/crud_test_models_controller_test.rb

@@ -1,6 +1,7 @@
+# encoding: UTF-8
 require 'test_helper'
-require 'crud_test_model'
-require File.join('functional', 'crud_controller_test_helper')
+require 'support/crud_test_model'
+require 'support/crud_controller_test_helper'
 
 # Tests all actions of the CrudController based on a dummy model
 # (CrudTestModel). This is useful to test the general behavior
@@ -16,79 +17,81 @@ class CrudTestModelsControllerTest < ActionController::TestCase
 
   teardown :reset_db
 
-
   def test_setup
     assert_equal 6, CrudTestModel.count
     assert_equal CrudTestModelsController, @controller.class
-    assert_recognizes({:controller => 'crud_test_models', :action => 'index'}, '/crud_test_models')
-    assert_recognizes({:controller => 'crud_test_models', :action => 'show', :id => '1'}, '/crud_test_models/1')
-    # no need to hide actions for pure restful controllers
-    #assert_equal %w(index show new create edit update destroy).to_set, CrudTestModelsController.send(:action_methods)
+    assert_recognizes({ controller: 'crud_test_models',
+                        action: 'index' },
+                      '/crud_test_models')
+    assert_recognizes({ controller: 'crud_test_models',
+                        action: 'show',
+                        id: '1' },
+                      '/crud_test_models/1')
   end
 
   def test_index
     super
     assert_equal 6, entries.size
     assert_equal entries.sort_by(&:name), entries
-    assert_equal Hash.new, session[:list_params]
+    assert_equal({}, session[:list_params])
     assert_equal entries, assigns(:crud_test_models)
     assert_respond_to assigns(:crud_test_models), :klass
   end
 
   def test_index_js
-    get :index, test_params(:format => 'js')
+    get :index, test_params(format: 'js')
     assert_response :success
     assert_equal 'index js', @response.body
-    assert_present entries
+    assert entries.present?
   end
 
   def test_index_search
     super
     assert_equal 1, entries.size
-    assert_equal({:q => 'AAAA'}, session[:list_params]['/crud_test_models'])
+    assert_equal({ q: 'AAAA' }, session[:list_params]['/crud_test_models'])
   end
 
   def test_index_with_custom_options
-    get :index, :filter => true
+    get :index, filter: true
     assert_response :success
     assert_template 'index'
-    assert_present entries
+    assert entries.present?
     assert_equal 2, entries.size
     assert_equal entries.sort_by(&:children).reverse, entries
   end
 
   def test_index_search_with_custom_options
-    get :index, :q => 'DDD', :filter => true
+    get :index, q: 'DDD', filter: true
     assert_response :success
     assert_template 'index'
-    assert_present entries
+    assert entries.present?
     assert_equal 1, entries.size
     assert_equal [CrudTestModel.find_by_name('BBBBB')], entries
-    assert_equal({:q => 'DDD'}, session[:list_params]['/crud_test_models'])
+    assert_equal({ q: 'DDD' }, session[:list_params]['/crud_test_models'])
   end
 
   def test_sort_given_column
-    get :index, :sort => 'children', :sort_dir => 'asc'
+    get :index, sort: 'children', sort_dir: 'asc'
     assert_response :success
     assert_template 'index'
-    assert_present entries
+    assert entries.present?
     assert_equal 6, entries.size
     assert_equal CrudTestModel.all.sort_by(&:children), entries
-    assert_equal({:sort => 'children', :sort_dir => 'asc'}, session[:list_params]['/crud_test_models'])
+    assert_equal({ sort: 'children', sort_dir: 'asc' },
+                 session[:list_params]['/crud_test_models'])
   end
 
   def test_sort_virtual_column
-    get :index, :sort => 'chatty', :sort_dir => 'desc'
+    get :index, sort: 'chatty', sort_dir: 'desc'
     assert_response :success
     assert_template 'index'
-    assert_present entries
+    assert entries.present?
     assert_equal 6, entries.size
-    assert_equal({:sort => 'chatty', :sort_dir => 'desc'}, session[:list_params]['/crud_test_models'])
-
-    sorted = CrudTestModel.all.sort_by(&:chatty)
+    assert_equal({ sort: 'chatty', sort_dir: 'desc' },
+                 session[:list_params]['/crud_test_models'])
 
     # sort order is ambiguous, use index
-    names = entries.collect(&:name)
+    names = entries.map(&:name)
     assert names.index('BBBBB') < names.index('AAAAA')
     assert names.index('BBBBB') < names.index('DDDDD')
     assert names.index('EEEEE') < names.index('AAAAA')
@@ -98,24 +101,27 @@ class CrudTestModelsControllerTest < ActionController::TestCase
   end
 
   def test_sort_with_search
-    get :index, :q => 'DDD', :sort => 'chatty', :sort_dir => 'asc'
+    get :index, q: 'DDD', sort: 'chatty', sort_dir: 'asc'
     assert_response :success
     assert_template 'index'
-    assert_present entries
+    assert entries.present?
     assert_equal 3, entries.size
-    assert_equal ['CCCCC', 'DDDDD', 'BBBBB'], entries.collect(&:name)
-    assert_equal({:sort => 'chatty', :sort_dir => 'asc', :q => 'DDD'}, session[:list_params]['/crud_test_models'])
+    assert_equal %w(CCCCC DDDDD BBBBB), entries.map(&:name)
+    assert_equal({ sort: 'chatty', sort_dir: 'asc', q: 'DDD' },
+                 session[:list_params]['/crud_test_models'])
   end
 
   def test_index_returning
     session[:list_params] = {}
-    session[:list_params]['/crud_test_models'] = {:q => 'DDD', :sort => 'chatty', :sort_dir => 'desc'}
-    get :index, :returning => true
+    session[:list_params]['/crud_test_models'] = { q: 'DDD',
+                                                   sort: 'chatty',
+                                                   sort_dir: 'desc' }
+    get :index, returning: true
     assert_response :success
     assert_template 'index'
-    assert_present entries
+    assert entries.present?
     assert_equal 3, entries.size
-    assert_equal ['BBBBB', 'DDDDD', 'CCCCC'], entries.collect(&:name)
+    assert_equal %w(BBBBB DDDDD CCCCC), entries.map(&:name)
     assert_equal 'DDD', @controller.params[:q]
     assert_equal 'chatty', @controller.params[:sort]
     assert_equal 'desc', @controller.params[:sort_dir]
@@ -125,7 +131,8 @@ class CrudTestModelsControllerTest < ActionController::TestCase
     super
     assert assigns(:companions)
     assert_equal @controller.send(:entry), assigns(:crud_test_model)
-    assert_equal [:before_render_new, :before_render_form], @controller.called_callbacks
+    assert_equal [:before_render_new, :before_render_form],
+                 @controller.called_callbacks
   end
 
   def test_show
@@ -134,7 +141,7 @@ class CrudTestModelsControllerTest < ActionController::TestCase
   end
 
   def test_show_with_custom
-    get :show, test_params(:id => crud_test_models(:BBBBB).id)
+    get :show, test_params(id: crud_test_models(:BBBBB).id)
     assert_response :success
     assert_equal 'custom html', @response.body
   end
@@ -142,78 +149,87 @@ class CrudTestModelsControllerTest < ActionController::TestCase
   def test_create
     super
     assert_match /model got created/, flash[:notice]
-    assert_blank flash[:alert]
-    assert_equal [:before_create, :before_save, :after_save, :after_create], @controller.called_callbacks
+    assert flash[:alert].blank?
+    assert_equal [:before_create, :before_save, :after_save, :after_create],
+                 @controller.called_callbacks
   end
 
   def test_edit
     super
     assert_equal @controller.send(:entry), assigns(:crud_test_model)
-    assert_equal [:before_render_edit, :before_render_form], @controller.called_callbacks
+    assert_equal [:before_render_edit, :before_render_form],
+                 @controller.called_callbacks
   end
 
   def test_update
     super
-    assert_match /successfully updated/, flash[:notice]
-    assert flash[:notice].html_safe?
-    assert_blank flash[:alert]
+    assert_equal I18n.t('crud.update.flash.success',
+                        model: 'Crud Test Model <i>foo</i>'),
+                 flash[:notice]
+    assert flash[:alert].blank?
     assert_equal @controller.send(:entry), assigns(:crud_test_model)
-    assert_equal [:before_update, :before_save, :after_save, :after_update], @controller.called_callbacks
+    assert_equal [:before_update, :before_save, :after_save, :after_update],
+                 @controller.called_callbacks
   end
 
   def test_destroy
     super
-    assert_equal [:before_destroy, :after_destroy], @controller.called_callbacks
-    assert_match 'successfully deleted', flash[:notice]
-    assert flash[:notice].html_safe?
+    assert_equal [:before_destroy, :after_destroy],
+                 @controller.called_callbacks
+    assert_equal I18n.t('crud.destroy.flash.success',
+                         model: 'Crud Test Model <i>AAAAA</i>'),
+                 flash[:notice]
   end
 
   def test_create_with_before_callback
-    assert_no_difference("CrudTestModel.count") do
-      post :create, :crud_test_model => {:name => 'illegal', :children => 2}
+    assert_no_difference('CrudTestModel.count') do
+      post :create, crud_test_model: { name: 'illegal', children: 2 }
     end
     assert_response :success
     assert_template 'new'
     assert entry.new_record?
-    assert assigns(:companions)
-    assert_present flash[:alert]
+    assert assigns(:companions).present?
+    assert flash[:alert].present?
     assert_equal 'illegal', entry.name
-    assert_equal [:before_render_new, :before_render_form], @controller.called_callbacks
+    assert_equal [:before_render_new, :before_render_form],
+                 @controller.called_callbacks
   end
 
   def test_create_with_before_callback_redirect
     @controller.should_redirect = true
-    assert_no_difference("CrudTestModel.count") do
-      post :create, :crud_test_model => {:name => 'illegal', :children => 2}
+    assert_no_difference('CrudTestModel.count') do
+      post :create, crud_test_model: { name: 'illegal', children: 2 }
     end
-    assert_redirected_to :action => 'index'
+    assert_redirected_to action: 'index'
     assert_nil @controller.called_callbacks
   end
 
   def test_new_with_before_render_callback_redirect_does_not_set_companions
     @controller.should_redirect = true
     get :new
-    assert_redirected_to :action => 'index'
+    assert_redirected_to action: 'index'
     assert_nil assigns(:companions)
   end
 
   def test_create_with_failure
-    assert_no_difference("CrudTestModel.count") do
-      post :create, :crud_test_model => {:children => 2}
+    assert_no_difference('CrudTestModel.count') do
+      post :create, crud_test_model: { children: 2 }
     end
     assert_response :success
     assert_template 'new'
     assert entry.new_record?
     assert assigns(:companions)
-    assert_blank flash[:notice]
-    assert_blank flash[:alert]
-    assert_blank entry.name
-    assert_equal [:before_create, :before_save, :before_render_new, :before_render_form], @controller.called_callbacks
+    assert flash[:notice].blank?, flash[:notice].to_s
+    assert flash[:alert].blank?, flash[:alert].to_s
+    assert entry.name.blank?
+    assert_equal [:before_create, :before_save,
+                  :before_render_new, :before_render_form],
+                 @controller.called_callbacks
   end
 
   def test_create_with_failure_json
-    assert_no_difference("CrudTestModel.count") do
-      post :create, :crud_test_model => {:children => 2}, :format => 'json'
+    assert_no_difference('CrudTestModel.count') do
+      post :create, crud_test_model: { children: 2 }, format: 'json'
     end
     assert_response :unprocessable_entity
     assert entry.new_record?
@@ -222,57 +238,62 @@ class CrudTestModelsControllerTest < ActionController::TestCase
   end
 
   def test_update_with_failure
-    put :update, :id => test_entry.id, :crud_test_model => {:rating => 20}
+    put :update, id: test_entry.id, crud_test_model: { rating: 20 }
     assert_response :success
     assert_template 'edit'
     assert entry.changed?
-    assert_blank flash[:notice]
-    assert_blank flash[:alert]
+    assert flash[:notice].blank?
+    assert flash[:alert].blank?
     assert_equal 20, entry.rating
-    assert_equal [:before_update, :before_save, :before_render_edit, :before_render_form], @controller.called_callbacks
+    assert_equal [:before_update, :before_save,
+                  :before_render_edit, :before_render_form],
+                 @controller.called_callbacks
   end
 
   def test_update_with_failure_json
-    put :update, :id => test_entry.id, :crud_test_model => {:rating => 20}, :format => 'json'
+    put :update, id: test_entry.id,
+                 crud_test_model: { rating: 20 },
+                 format: 'json'
     assert_response :unprocessable_entity
     assert entry.changed?
     assert_match /errors/, @response.body
-    assert_blank flash[:notice]
+    assert flash[:notice].blank?
     assert_equal 20, entry.rating
     assert_equal [:before_update, :before_save], @controller.called_callbacks
   end
 
   def test_destroy_failure
     assert_no_difference("#{model_class.name}.count") do
-      @request.env['HTTP_REFERER'] = crud_test_model_url(crud_test_models(:BBBBB))
-      delete :destroy, test_params(:id => crud_test_models(:BBBBB).id)
+      @request.env['HTTP_REFERER'] =
+        crud_test_model_url(crud_test_models(:BBBBB))
+      delete :destroy, test_params(id: crud_test_models(:BBBBB).id)
     end
     assert_redirected_to_show(entry)
     assert_match /companion/, flash[:alert]
-    assert_blank flash[:notice]
+    assert flash[:notice].blank?
   end
 
   def test_destroy_failure_callback
     e = crud_test_models(:AAAAA)
     e.update_attribute :name, 'illegal'
     assert_no_difference("#{model_class.name}.count") do
-      delete :destroy, test_params(:id => e.id)
+      delete :destroy, test_params(id: e.id)
     end
     assert_redirected_to_index
     assert_match /illegal name/, flash[:alert]
-    assert_blank flash[:notice]
+    assert flash[:notice].blank?
   end
 
   def test_destroy_failure_json
     assert_no_difference("#{model_class.name}.count") do
-      delete :destroy, test_params(:id => crud_test_models(:BBBBB).id, :format => 'json')
+      delete :destroy, test_params(id: crud_test_models(:BBBBB).id,
+                                   format: 'json')
     end
     assert_response :unprocessable_entity
     assert_match /errors/, @response.body
-    assert_blank flash[:notice]
+    assert flash[:notice].blank?
   end
 
-
   def test_models_label
     assert_equal 'Crud Test Models', @controller.models_label
     assert_equal 'Crud Test Model', @controller.models_label(false)
@@ -285,23 +306,23 @@ class CrudTestModelsControllerTest < ActionController::TestCase
   end
 
   def new_entry_attrs
-    {:name => 'foo',
-     :children => 42,
-     :companion_id => 3,
-     :rating => 8.5,
-     :income => 2.42,
-     :birthdate => '31-12-1999'.to_date,
-     :human => true,
-     :remarks => "some custom\n\tremarks"}
+    { name: 'foo',
+      children: 42,
+      companion_id: 3,
+      rating: 8.5,
+      income: 2.42,
+      birthdate: '31-12-1999'.to_date,
+      human: true,
+      remarks: "some custom\n\tremarks" }
   end
 
   def edit_entry_attrs
-    {:name => 'foo',
-     :children => 42,
-     :rating => 8.5,
-     :income => 2.42,
-     :birthdate => '31-12-1999'.to_date,
-     :human => true,
-     :remarks => "some custom\n\tremarks"}
+    { name: 'foo',
+      children: 42,
+      rating: 8.5,
+      income: 2.42,
+      birthdate: '31-12-1999'.to_date,
+      human: true,
+      remarks: "some custom\n\tremarks" }
   end
 end