dry_crud 2.1.2 → 3.0.0

data/lib/generators/dry_crud/templates/spec/helpers/utility_helper_spec.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
-require 'spec_helper'
+require 'rails_helper'
 
 describe UtilityHelper do
 
@@ -17,17 +17,17 @@ describe UtilityHelper do
     let(:model) { crud_test_models(:AAAAA) }
 
     it 'recognizes types' do
-      column_type(model, :name).should == :string
-      column_type(model, :children).should == :integer
-      column_type(model, :companion_id).should == :integer
-      column_type(model, :rating).should == :float
-      column_type(model, :income).should == :decimal
-      column_type(model, :birthdate).should == :date
-      column_type(model, :gets_up_at).should == :time
-      column_type(model, :last_seen).should == :datetime
-      column_type(model, :human).should == :boolean
-      column_type(model, :remarks).should == :text
-      column_type(model, :companion).should be_nil
+      expect(column_type(model, :name)).to eq(:string)
+      expect(column_type(model, :children)).to eq(:integer)
+      expect(column_type(model, :companion_id)).to eq(:integer)
+      expect(column_type(model, :rating)).to eq(:float)
+      expect(column_type(model, :income)).to eq(:decimal)
+      expect(column_type(model, :birthdate)).to eq(:date)
+      expect(column_type(model, :gets_up_at)).to eq(:time)
+      expect(column_type(model, :last_seen)).to eq(:datetime)
+      expect(column_type(model, :human)).to eq(:boolean)
+      expect(column_type(model, :remarks)).to eq(:text)
+      expect(column_type(model, :companion)).to be_nil
     end
   end
 
@@ -35,39 +35,39 @@ describe UtilityHelper do
 
     it 'escapes safe content' do
       html = content_tag_nested(:div, %w(a b)) { |e| content_tag(:span, e) }
-      html.should be_html_safe
-      html.should == '<div><span>a</span><span>b</span></div>'
+      expect(html).to be_html_safe
+      expect(html).to eq('<div><span>a</span><span>b</span></div>')
     end
 
     it 'escapes unsafe content' do
       html = content_tag_nested(:div, %w(a b)) { |e| "<#{e}>" }
-      html.should == '<div>&lt;a&gt;&lt;b&gt;</div>'
+      expect(html).to eq('<div>&lt;a&gt;&lt;b&gt;</div>')
     end
 
     it 'simplys join without block' do
       html = content_tag_nested(:div, %w(a b))
-      html.should == '<div>ab</div>'
+      expect(html).to eq('<div>ab</div>')
     end
   end
 
   describe '#safe_join' do
     it 'works as super without block' do
       html = safe_join(['<a>', '<b>'.html_safe])
-      html.should == '&lt;a&gt;<b>'
+      expect(html).to eq('&lt;a&gt;<b>')
     end
 
     it 'collects contents for array' do
       html = safe_join(%w(a b)) { |e| content_tag(:span, e) }
-      html.should == '<span>a</span><span>b</span>'
+      expect(html).to eq('<span>a</span><span>b</span>')
     end
   end
 
   describe '#default_crud_attrs' do
     it 'do not contain id and password' do
-      default_crud_attrs.should ==
-        [:name, :email, :whatever, :children, :companion_id, :rating, :income,
-         :birthdate, :gets_up_at, :last_seen, :human, :remarks,
-         :created_at, :updated_at]
+      expect(default_crud_attrs).to eq([
+        :name, :email, :whatever, :children, :companion_id, :rating, :income,
+        :birthdate, :gets_up_at, :last_seen, :human, :remarks,
+        :created_at, :updated_at])
     end
   end
 

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

@@ -3,8 +3,8 @@ require 'support/crud_controller_test_helper'
 
 RSpec.configure do |c|
   c.before failing: true do
-    model_class.any_instance.stub(:save).and_return(false)
-    model_class.any_instance.stub(:destroy).and_return(false)
+    allow_any_instance_of(model_class).to receive(:save).and_return(false)
+    allow_any_instance_of(model_class).to receive(:destroy).and_return(false)
   end
 end
 
@@ -36,7 +36,7 @@ shared_examples 'crud controller' do |options|
   end
 
   before do
-    m = example.metadata
+    m = RSpec.current_example.metadata
     if m[:perform_request] != false && m[:action] && m[:method]
       perform_combined_request
     end
@@ -52,9 +52,9 @@ shared_examples 'crud controller' do |options|
       context 'plain',
               unless: skip?(options, %w(index html plain)),
               combine: 'ihp' do
-        it_should_respond
-        it_should_assign_entries
-        it_should_render
+        it_is_expected_to_respond
+        it_is_expected_to_assign_entries
+        it_is_expected_to_render
       end
 
       context 'search',
@@ -63,11 +63,11 @@ shared_examples 'crud controller' do |options|
               combine: 'ihse' do
         let(:params) { { q: search_value } }
 
-        it_should_respond
+        it_is_expected_to_respond
 
         context 'entries' do
           subject { entries }
-          it { should include(test_entry) }
+          it { is_expected.to include(test_entry) }
         end
       end
 
@@ -78,11 +78,11 @@ shared_examples 'crud controller' do |options|
                 combine: 'ihso' do
           let(:params) { { sort: sort_column, sort_dir: 'asc' } }
 
-          it_should_respond
+          it_is_expected_to_respond
 
-          it 'should have sorted entries' do
+          it 'has sorted entries' do
             sorted = entries.sort_by(&(sort_column.to_sym))
-            entries.should == sorted
+            expect(entries).to eq(sorted)
           end
         end
 
@@ -91,11 +91,11 @@ shared_examples 'crud controller' do |options|
                 combine: 'ihsd' do
           let(:params) { { sort: sort_column, sort_dir: 'desc' } }
 
-          it_should_respond
+          it_is_expected_to_respond
 
-          it 'should have sorted entries' do
+          it 'has sorted entries' do
             sorted = entries.sort_by(&(sort_column.to_sym))
-            entries.should == sorted.reverse
+            expect(entries).to eq(sorted.reverse)
           end
         end
       end
@@ -105,9 +105,9 @@ shared_examples 'crud controller' do |options|
             format: :json,
             unless: skip?(options, %w(index json)),
             combine: 'ij' do
-      it_should_respond
-      it_should_assign_entries
-      it { response.body.should start_with('[{') }
+      it_is_expected_to_respond
+      it_is_expected_to_assign_entries
+      it { expect(response.body).to start_with('[{') }
     end
   end
 
@@ -122,9 +122,9 @@ shared_examples 'crud controller' do |options|
       context 'plain',
               unless: skip?(options, %w(show html plain)),
               combine: 'sh' do
-        it_should_respond
-        it_should_assign_entry
-        it_should_render
+        it_is_expected_to_respond
+        it_is_expected_to_assign_entry
+        it_is_expected_to_render
       end
 
       context 'with non-existing id',
@@ -132,7 +132,7 @@ shared_examples 'crud controller' do |options|
                             %w(show html with_non_existing_id)) do
         let(:params) { { id: 9999 } }
 
-        it 'should raise RecordNotFound', perform_request: false do
+        it 'raises RecordNotFound', perform_request: false do
           expect { perform_request }
           .to raise_error(ActiveRecord::RecordNotFound)
         end
@@ -143,9 +143,9 @@ shared_examples 'crud controller' do |options|
             format: :json,
             unless: skip?(options, %w(show json)),
             combine: 'sj' do
-      it_should_respond
-      it_should_assign_entry
-      it_should_render_json
+      it_is_expected_to_respond
+      it_is_expected_to_assign_entry
+      it_is_expected_to_render_json
     end
   end
 
@@ -154,15 +154,15 @@ shared_examples 'crud controller' do |options|
     context 'plain',
             unless: skip?(options, %w(new plain)),
             combine: 'new' do
-      it_should_respond
-      it_should_render
-      it_should_persist_entry(false)
+      it_is_expected_to_respond
+      it_is_expected_to_render
+      it_is_expected_to_persist_entry(false)
     end
 
     context 'with params',
             unless: skip?(options, %w(new with_params)) do
       let(:params) { { model_identifier => new_entry_attrs } }
-      it_should_set_attrs(:new)
+      it_is_expected_to_set_attrs(:new)
     end
   end
 
@@ -170,55 +170,55 @@ shared_examples 'crud controller' do |options|
                   unless: skip?(options, %w(create)) do
     let(:params) { { model_identifier => new_entry_attrs } }
 
-    it 'should add entry to database', perform_request: false do
+    it 'adds entry to database', perform_request: false do
       expect { perform_request }.to change { model_class.count }.by(1)
     end
 
     context 'html',
             format: :html,
             unless: skip?(options, %w(create html)) do
-      it_should_persist_entry # cannot combine this
+      it_is_expected_to_persist_entry # cannot combine this
 
       context 'with valid params',
               unless: skip?(options, %w(create html valid)),
               combine: 'chv' do
-        it_should_redirect_to_show
-        it_should_set_attrs(:new)
-        it_should_have_flash(:notice)
+        it_is_expected_to_redirect_to_show
+        it_is_expected_to_set_attrs(:new)
+        it_is_expected_to_have_flash(:notice)
       end
 
       context 'with invalid params',
               failing: true,
               unless: skip?(options, %w(create html invalid)),
               combine: 'chi' do
-        it_should_render('new')
-        it_should_persist_entry(false)
-        it_should_set_attrs(:new)
-        it_should_not_have_flash(:notice)
+        it_is_expected_to_render('new')
+        it_is_expected_to_persist_entry(false)
+        it_is_expected_to_set_attrs(:new)
+        it_is_expected_to_not_have_flash(:notice)
       end
     end
 
     context 'json',
             format: :json,
             unless: skip?(options, %w(create json)) do
-      it_should_persist_entry # cannot combine this
+      it_is_expected_to_persist_entry # cannot combine this
 
       context 'with valid params',
               unless: skip?(options, %w(create json valid)),
               combine: 'cjv' do
-        it_should_respond(201)
-        it_should_set_attrs(:new)
-        it_should_render_json
+        it_is_expected_to_respond(201)
+        it_is_expected_to_set_attrs(:new)
+        it_is_expected_to_render_json
       end
 
       context 'with invalid params',
               failing: true,
               unless: skip?(options, %w(create json invalid)),
               combine: 'cji' do
-        it_should_respond(422)
-        it_should_set_attrs(:new)
-        it_should_render_error_json
-        it_should_persist_entry(false)
+        it_is_expected_to_respond(422)
+        it_is_expected_to_set_attrs(:new)
+        it_is_expected_to_render_json
+        it_is_expected_to_persist_entry(false)
       end
     end
   end
@@ -227,9 +227,9 @@ shared_examples 'crud controller' do |options|
                   id: true,
                   unless: skip?(options, %w(edit)),
                   combine: 'edit' do
-    it_should_respond
-    it_should_render
-    it_should_assign_entry
+    it_is_expected_to_respond
+    it_is_expected_to_render
+    it_is_expected_to_assign_entry
   end
 
   describe_action :put, :update,
@@ -237,7 +237,7 @@ shared_examples 'crud controller' do |options|
                   unless: skip?(options, %w(update)) do
     let(:params) { { model_identifier => edit_entry_attrs } }
 
-    it 'should update entry in database', perform_request: false do
+    it 'updates entry in database', perform_request: false do
       expect { perform_request }.to change { model_class.count }.by(0)
     end
 
@@ -247,19 +247,19 @@ shared_examples 'crud controller' do |options|
       context 'with valid params',
               unless: skip?(options, %w(update html valid)),
               combine: 'uhv' do
-        it_should_set_attrs(:edit)
-        it_should_redirect_to_show
-        it_should_persist_entry
-        it_should_have_flash(:notice)
+        it_is_expected_to_set_attrs(:edit)
+        it_is_expected_to_redirect_to_show
+        it_is_expected_to_persist_entry
+        it_is_expected_to_have_flash(:notice)
       end
 
       context 'with invalid params',
               failing: true,
               unless: skip?(options, %w(update html invalid)),
               combine: 'uhi' do
-        it_should_render('edit')
-        it_should_set_attrs(:edit)
-        it_should_not_have_flash(:notice)
+        it_is_expected_to_render('edit')
+        it_is_expected_to_set_attrs(:edit)
+        it_is_expected_to_not_have_flash(:notice)
       end
     end
 
@@ -270,19 +270,19 @@ shared_examples 'crud controller' do |options|
       context 'with valid params',
               unless: skip?(options, %w(update json valid)),
               combine: 'ujv' do
-        it_should_respond(204)
-        it_should_set_attrs(:edit)
-        it { response.body.should be_blank }
-        it_should_persist_entry
+        it_is_expected_to_respond(200)
+        it_is_expected_to_set_attrs(:edit)
+        it_is_expected_to_render_json
+        it_is_expected_to_persist_entry
       end
 
       context 'with invalid params',
               failing: true,
               unless: skip?(options, %w(update json invalid)),
               combine: 'uji' do
-        it_should_respond(422)
-        it_should_set_attrs(:edit)
-        it_should_render_error_json
+        it_is_expected_to_respond(422)
+        it_is_expected_to_set_attrs(:edit)
+        it_is_expected_to_render_json
       end
     end
   end
@@ -291,7 +291,7 @@ shared_examples 'crud controller' do |options|
                   id: true,
                   unless: skip?(options, %w(destroy)) do
 
-    it 'should remove entry from database', perform_request: false  do
+    it 'removes entry from database', perform_request: false  do
       expect { perform_request }.to change { model_class.count }.by(-1)
     end
 
@@ -300,13 +300,13 @@ shared_examples 'crud controller' do |options|
             unless: skip?(options, %w(destroy html)) do
 
       context 'successfull', combine: 'dhs' do
-        it_should_redirect_to_index
-        it_should_have_flash(:notice)
+        it_is_expected_to_redirect_to_index
+        it_is_expected_to_have_flash(:notice)
       end
 
       context 'with failure', failing: true, combine: 'dhf' do
-        it_should_redirect_to_index
-        it_should_have_flash(:alert)
+        it_is_expected_to_redirect_to_index
+        it_is_expected_to_have_flash(:alert)
       end
     end
 
@@ -315,13 +315,13 @@ shared_examples 'crud controller' do |options|
             unless: skip?(options, %w(destroy json)) do
 
       context 'successfull', combine: 'djs' do
-        it_should_respond(204)
-        it { response.body.should be_blank }
+        it_is_expected_to_respond(204)
+        it { expect(response.body).to be_blank }
       end
 
       context 'with failure', failing: true, combine: 'djf' do
-        it_should_respond(422)
-        it_should_render_error_json
+        it_is_expected_to_respond(422)
+        it_is_expected_to_render_json
       end
     end
   end

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

@@ -7,7 +7,7 @@ module CrudControllerTestHelper
 
   # Performs a request based on the metadata of the action example under test.
   def perform_request
-    m = example.metadata
+    m = RSpec.current_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]
@@ -22,29 +22,40 @@ module CrudControllerTestHelper
   # 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
-    stack = example.metadata[:combine]
+    stack = RSpec.current_example.metadata[:combine]
     if stack
       @@current_stack ||= nil
       if stack == @@current_stack &&
          described_class == @@current_controller.class
-        @response = @@current_response
-        @_templates = @templates = @@current_templates
-        @controller = @@current_controller
-        @request = @@current_request
+        restore_request
       else
         perform_request
-
         @@current_stack = stack
-        @@current_response = @response
-        @@current_request = @request
-        @@current_controller = @controller
-        @@current_templates = @_templates || @templates
+        remember_request
       end
     else
       perform_request
     end
   end
 
+  def remember_request
+    @@current_response = @response
+    @@current_request = @request
+    @@current_controller = @controller
+    @@current_templates = @_templates || @templates
+
+    # treat in-memory entry as committed in order to
+    # avoid rollback of internal state.
+    entry.committed! if entry
+  end
+
+  def restore_request
+    @response = @@current_response
+    @_templates = @templates = @@current_templates
+    @controller = @@current_controller
+    @request = @@current_request
+  end
+
   # The params defining the nesting of the test entry.
   def scope_params
     params = {}
@@ -88,92 +99,90 @@ module CrudControllerTestHelper
     end
 
     # Test the response status, default 200.
-    def it_should_respond(status = 200)
-      it { response.status.should == status }
+    def it_is_expected_to_respond(status = 200)
+      it { expect(response.status).to eq(status) }
     end
 
     # Test that entries are assigned.
-    def it_should_assign_entries
-      it 'should assign entries' do
-        entries.should be_present
+    def it_is_expected_to_assign_entries
+      it 'assigns entries' do
+        expect(entries).to be_present
       end
     end
 
     # Test that entry is assigned.
-    def it_should_assign_entry
-      it 'should assign entry' do
-        entry.should == test_entry
+    def it_is_expected_to_assign_entry
+      it 'assigns entry' do
+        expect(entry).to eq(test_entry)
       end
     end
 
     # 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]) }
+    def it_is_expected_to_render(template = nil)
+      it do
+        template ||= RSpec.current_example.metadata[:action]
+        is_expected.to render_template(template)
+      end
     end
 
     # Test that a json response is rendered.
-    def it_should_render_json
-      it { response.body.should start_with('{') }
-    end
-
-    # Test that a json response containing the error is rendered.
-    def it_should_render_error_json
-      it { response.body.should match(/"errors":\{/) }
+    def it_is_expected_to_render_json
+      it { expect(response.body).to start_with('{') }
     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
+    def it_is_expected_to_set_attrs(action = nil)
+      it 'sets params as entry attributes' do
         attrs = send("#{action}_entry_attrs")
         actual = {}
         attrs.keys.each do |key|
           actual[key] = entry.attributes[key.to_s]
         end
-        actual.should == attrs
+        expect(actual).to eq(attrs)
       end
     end
 
     # Test that the response redirects to the index action.
-    def it_should_redirect_to_index
+    def it_is_expected_to_redirect_to_index
       it do
-        should redirect_to scope_params.merge(action: 'index',
-                                              returning: true)
+        is_expected.to 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
+    def it_is_expected_to_redirect_to_show
       it do
-        should redirect_to scope_params.merge(action: 'show',
-                                              id: entry.id)
+        is_expected.to 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)
+    def it_is_expected_to_have_flash(type, message = nil)
       it "flash(#{type}) is set" do
-        flash[type].should(message ? match(message) : be_present)
+        expect(flash[type]).to(message ? match(message) : be_present)
       end
     end
 
     # Test that not flash of the given type is present.
-    def it_should_not_have_flash(type)
+    def it_is_expected_to_not_have_flash(type)
       it "flash(#{type}) is nil" do
-        flash[type].should be_blank
+        expect(flash[type]).to be_blank
       end
     end
 
     # Test that the current entry is persistend and valid, or not.
-    def it_should_persist_entry(bool = true)
+    def it_is_expected_to_persist_entry(bool = true)
       context 'entry' do
         subject { entry }
 
         if bool
-          it { should_not be_new_record }
-          it { should be_valid }
+          it { is_expected.not_to be_new_record }
+          it { is_expected.to be_valid }
         else
-          it { should be_new_record }
+          it { is_expected.to be_new_record }
         end
       end
     end