wor-simple_crud 0.2.1 → 0.3.1

data/lib/spec/shared_examples/simple_crud_for_create.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'helpers'
-
 shared_examples 'simple crud for create' do
   describe 'POST #create' do
     context 'without authenticated user' do
-      subject!(:req) { post :create, params: attributes_for(model_class) }
+      subject!(:req) do
+        post :create, params: with_route_params(body_params(params_for(model_class))), format: request_format(:create)
+      end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:create)
     end
@@ -16,7 +16,7 @@ shared_examples 'simple crud for create' do
 
         before do
           make_policies_fail(:create)
-          post :create, params: model_params
+          post :create, params: with_route_params(body_params(model_params)), format: request_format(:create)
         end
 
         it 'fails with forbidden' do
@@ -27,22 +27,57 @@ shared_examples 'simple crud for create' do
 
     context 'when successfully creating an article' do
       include_context 'with authenticated user' if check_authenticate(:create)
-      let(:create_params) { model_params.merge(user_id: current_user.id) }
+      let(:create_params) { model_params.merge(owner_params) }
 
       before do
-        post :create, params: create_params
+        post :create, params: with_route_params(body_params(create_params)), format: request_format(:create)
       end
 
-      it 'response with 200 status code' do
-        expect(response).to have_http_status(:created)
+      if check_html(:create)
+        it 'redirects to the created record' do
+          expect(response).to have_http_status(:found)
+        end
+      else
+        it 'response with 201 status code' do
+          expect(response).to have_http_status(:created)
+        end
+
+        it 'creates an article with valid attributes' do
+          expect(model_class_object.last).to have_attributes(create_params)
+        end
       end
 
-      it 'creates an article' do
+      it 'creates the record', :aggregate_failures do
         expect(model_class_object.count).to be 1
+        instance_exec(model_class_object.last, &created_record_check) if created_record_check
       end
+    end
+
+    unless check_raise_on_invalid(:create)
+      context 'when creating with invalid attributes' do
+        include_context 'with authenticated user' if check_authenticate(:create)
+
+        before do
+          post :create, params: with_route_params(body_params(owner_params)), format: request_format(:create)
+        end
 
-      it 'creates an article with valid attributes' do
-        expect(model_class_object.last).to have_attributes(create_params)
+        unless check_block(:create)
+          if check_html(:create)
+            include_examples 'simple crud renders template', :new, -> { invalid_status }
+          else
+            it 'responds with unprocessable entity' do
+              expect(response).to have_http_status(unprocessable_status)
+            end
+
+            it 'returns the validation errors' do
+              expect(response_body['errors']).to include(required_error)
+            end
+          end
+        end
+
+        it 'does not create a model' do
+          expect(model_class_object.count).to be 0
+        end
       end
     end
   end

data/lib/spec/shared_examples/simple_crud_for_create_with_block.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for create with block' do
+  describe 'POST #create with a render block' do
+    context 'when successfully creating a record' do
+      include_context 'with authenticated user' if check_authenticate(:create)
+      let(:create_params) { model_params.merge(owner_params) }
+
+      before do
+        post :create, params: with_route_params(body_params(create_params)), format: request_format(:create)
+      end
+
+      it 'passes the saved record to the block' do
+        expect(response).to be_successful
+      end
+
+      it 'creates the record' do
+        expect(model_class_object.count).to be 1
+      end
+    end
+
+    unless check_raise_on_invalid(:create)
+      context 'when creating with invalid attributes' do
+        include_context 'with authenticated user' if check_authenticate(:create)
+
+        before do
+          post :create, params: with_route_params(body_params(owner_params)), format: request_format(:create)
+        end
+
+        it 'does not create a model' do
+          expect(model_class_object.count).to be 0
+        end
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_create_with_build.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for create with build' do
+  describe 'POST #create with a build hook' do
+    include_context 'with authenticated user' if check_authenticate(:create)
+
+    before do
+      post :create, params: with_route_params(body_params(params_for(model_class))), format: request_format(:create)
+    end
+
+    it 'creates the record owned by the current user' do
+      expect(model_class_object.last.public_send(owner_association)).to eq(current_user)
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_destroy.rb

@@ -3,7 +3,10 @@
 shared_examples 'simple crud for destroy' do
   describe 'DELETE #destroy' do
     context 'without authenticated user' do
-      subject!(:req) { delete :destroy, params: { id: 1 } }
+      subject!(:req) do
+        delete :destroy, params: with_route_params(record_param(:destroy, nil, not_found: true)),
+                         format: request_format(:destroy)
+      end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:destroy)
     end
@@ -14,7 +17,7 @@ shared_examples 'simple crud for destroy' do
 
         before do
           make_policies_fail(:destroy)
-          delete :destroy, params: { id: model.id }
+          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
         end
 
         it 'fails with forbidden' do
@@ -28,11 +31,43 @@ shared_examples 'simple crud for destroy' do
 
       before do
         model
-        delete :destroy, params: { id: model.id }
+        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
       end
 
-      it 'response with 200 status code' do
-        expect(response).to have_http_status(:ok)
+      if check_html(:destroy)
+        it 'redirects to the collection and destroys the record', :aggregate_failures do
+          expect(response).to have_http_status(:found)
+          expect(model_class_object.exists?(model.id)).to be false
+        end
+      else
+        it 'response with 200 status code' do
+          expect(response).to have_http_status(:ok)
+        end
+      end
+    end
+
+    context 'when destroying fails' do
+      include_context 'with authenticated user' if check_authenticate(:destroy)
+
+      before do
+        model
+        allow(model).to receive(:destroy).and_return(false)
+        allow(SimpleCrudController).to receive(:find_record).and_return(model)
+        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+      end
+
+      it 'keeps the record' do
+        expect(model_class_object.exists?(model.id)).to be true
+      end
+
+      unless check_block(:destroy) || check_raise_on_invalid(:destroy)
+        if check_html(:destroy)
+          include_examples 'simple crud renders template', :show
+        else
+          it 'responds with unprocessable entity' do
+            expect(response).to have_http_status(unprocessable_status)
+          end
+        end
       end
     end
 
@@ -41,7 +76,8 @@ shared_examples 'simple crud for destroy' do
 
       before do
         model
-        delete :destroy, params: { id: model.id + 13 }
+        delete :destroy, params: with_route_params(record_param(:destroy, nil, not_found: true)),
+                         format: request_format(:destroy)
       end
 
       it 'responds with not found status' do
@@ -56,10 +92,10 @@ shared_examples 'simple crud for destroy' do
         before do
           model
           make_policies_fail(:destroy)
-          delete :destroy, params: { id: model.id }
+          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
         end
 
-        it 'response with 200 status code' do
+        it 'responds with forbidden status' do
           expect(response).to have_http_status(:forbidden)
         end
       end

data/lib/spec/shared_examples/simple_crud_for_destroy_with_block.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for destroy with block' do
+  describe 'DELETE #destroy with a render block' do
+    include_context 'with authenticated user' if check_authenticate(:destroy)
+
+    let!(:record) { model }
+
+    before do
+      delete :destroy, params: with_route_params(record_param(:destroy, record)), format: request_format(:destroy)
+    end
+
+    it 'passes the destroyed record to the block' do
+      expect(response).to be_successful
+    end
+
+    it 'destroys the record' do
+      expect(model_class_object.exists?(record.id)).to be false
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_destroy_with_finder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for destroy with finder' do
+  describe 'DELETE #destroy with a custom finder' do
+    include_context 'with authenticated user' if check_authenticate(:destroy)
+
+    context 'when the model exists' do
+      before do
+        model
+        delete :destroy, params: with_route_params(finder_key => model.public_send(finder_key)),
+                         format: request_format(:destroy)
+      end
+
+      it 'destroys the model' do
+        expect(model_class_object.exists?(model.id)).to be false
+      end
+
+      if check_block(:destroy)
+        it 'passes the destroyed record to the block' do
+          expect(rendered_record.id).to eq(model.id)
+        end
+      elsif check_html(:destroy)
+        it 'redirects to the collection' do
+          expect(response).to have_http_status(:found)
+        end
+      else
+        it 'responds with ok status' do
+          expect(response).to have_http_status(:ok)
+        end
+      end
+    end
+
+    include_examples 'simple crud not found with finder', :delete, :destroy
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_edit.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for edit' do
+  describe 'GET #edit' do
+    subject(:edit_request) { get :edit, params: with_route_params(edit_params), format: request_format(:edit) }
+
+    before do
+      model
+    end
+
+    context 'without authenticated user' do
+      subject!(:req) do
+        get :edit, params: with_route_params(record_param(:edit, model)), format: request_format(:edit)
+      end
+
+      include_examples 'unauthorized when not logged in' if check_authenticate(:edit)
+    end
+
+    if check_authorize(:edit)
+      context 'when the user is not authorized' do
+        include_context 'with authenticated user' if check_authenticate(:edit)
+
+        let(:edit_params) { record_param(:edit, model) }
+
+        before do
+          model
+          make_policies_fail(:edit)
+          edit_request
+        end
+
+        it 'responds with forbidden status' do
+          expect(response).to have_http_status(:forbidden)
+        end
+      end
+    end
+
+    context 'when the model exists' do
+      include_context 'with authenticated user' if check_authenticate(:edit)
+
+      let(:edit_params) { record_param(:edit, model) }
+
+      before do
+        model
+        make_policies_succeed(:edit) if check_authorize(:edit)
+        edit_request
+      end
+
+      it 'responds with ok status' do
+        expect(response).to have_http_status(:ok)
+      end
+
+      if check_block(:edit)
+        it 'renders the asked model through the block' do
+          expect(response).to be_successful
+        end
+      elsif check_html(:edit)
+        include_examples 'simple crud renders template', :edit
+      else
+        it 'returns the asked model' do
+          expect(response_body['id']).to eq(model.id)
+        end
+      end
+    end
+
+    context 'when the model does not exist' do
+      include_context 'with authenticated user'
+
+      let(:edit_params) { record_param(:edit, nil, not_found: true) }
+
+      before do
+        edit_request
+      end
+
+      it 'responds with not found status' do
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_index.rb

@@ -2,39 +2,24 @@
 
 shared_examples 'simple crud for index' do
   describe 'GET #index' do
-    let(:created_models) { create_list(model_class, 10) }
+    let(:created_models) { create_records(model_class, 10, model_attributes) }
 
     before { created_models }
 
-    context 'without authenticated user' do
-      subject!(:req) { get :index }
-
-      include_examples 'unauthorized when not logged in' if check_authenticate(:index)
-    end
-
-    if check_authorize(:index)
-      context 'when not authorized' do
-        include_context 'with authenticated user' if check_authenticate(:index)
-
-        before do
-          make_policies_fail(:index)
-          get :index
-        end
-
-        it 'fails with forbidden' do
-          expect(response).to have_http_status(:forbidden)
-        end
-      end
-    end
+    include_examples 'simple crud without authenticated user', :index
+    include_examples 'simple crud when not authorized', :index, :get
 
     context 'with authenticated user' do
       include_context 'with authenticated user' if check_authenticate(:index)
+
       before do
-        make_policies_succeed(:index)
-        get :index
+        make_policies_succeed(:index) if check_authorize(:index)
+        get :index, params: with_route_params({}), format: request_format(:index)
       end
 
-      if check_paginate(:index)
+      if check_html(:index)
+        include_examples 'simple crud renders template', :index
+      elsif check_paginate(:index)
         it 'renders paginated models correctly serialized' do
           expect(response_body['page']).to have_been_serialized_with(model_serializer)
         end

data/lib/spec/shared_examples/simple_crud_for_index_with_block.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for index with block' do
+  describe 'GET #index with a render block' do
+    let(:created_models) { create_records(model_class, 2, model_attributes) }
+
+    include_context 'with authenticated user' if check_authenticate(:index)
+
+    before do
+      created_models
+      get :index, params: with_route_params({}), format: request_format(:index)
+    end
+
+    if check_html(:index)
+      include_examples 'simple crud renders template', :index
+    else
+      it 'renders the records through the block' do
+        expect(response).to be_successful
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_index_with_scope.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for index with scope' do
+  let(:request_params) { {} }
+  let(:my_models) { create_records(model_class, 2, scoped_attributes) }
+  let(:other_models) { create_records(model_class, 3, other_scoped_attributes) }
+
+  # Hooks stay inside this context so co-including the example never
+  # authenticates or stubs policies for sibling examples.
+  context 'when listing the scoped records' do
+    before do
+      authenticate_request if check_authenticate(:index)
+      make_policies_succeed(:index) if check_authorize(:index)
+      my_models
+      other_models
+      get :index, params: with_route_params(request_params), format: request_format(:index)
+    end
+
+    if check_html(:index)
+      it 'returns only the assigned scoped records' do
+        expect(rendered_records.map(&:id)).to match_array(my_models.map(&:id))
+      end
+    elsif check_paginate(:index)
+      it 'returns only the paginated scoped records' do
+        expect(response_body['page'].map { |m| m['id'] }).to match_array(my_models.map(&:id))
+      end
+    else
+      it 'returns only the unpaginated scoped records' do
+        expect(response_body.map { |m| m['id'] }).to match_array(my_models.map(&:id))
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_new.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for new' do
+  describe 'GET #new' do
+    include_examples 'simple crud without authenticated user', :new
+    include_examples 'simple crud when not authorized', :new, :get
+
+    context 'when building a new record' do
+      include_context 'with authenticated user' if check_authenticate(:new)
+
+      before do
+        make_policies_succeed(:new) if check_authorize(:new)
+        get :new, params: with_route_params({}), format: request_format(:new)
+      end
+
+      it 'responds with ok status' do
+        expect(response).to have_http_status(:ok)
+      end
+
+      if check_html(:new)
+        include_examples 'simple crud renders template', :new
+      else
+        it 'returns a blank record as json' do
+          expect(response_body['id']).to be_nil
+        end
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_new_with_block.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for new with block' do
+  describe 'GET #new with a render block' do
+    include_context 'with authenticated user' if check_authenticate(:new)
+
+    before do
+      make_policies_succeed(:new) if check_authorize(:new)
+      get :new, params: with_route_params({}), format: request_format(:new)
+    end
+
+    if check_html(:new)
+      include_examples 'simple crud renders template', :new
+    else
+      it 'renders the built record through the block' do
+        expect(response).to be_successful
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_new_with_build.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for new with build' do
+  describe 'GET #new with a build hook' do
+    include_context 'with authenticated user' if check_authenticate(:new)
+
+    before do
+      get :new, params: with_route_params({}), format: request_format(:new)
+    end
+
+    it 'builds the record owned by the current user', :aggregate_failures do
+      if check_html(:new) || check_block(:new)
+        expect(rendered_record.public_send(owner_foreign_key)).to eq(current_user.id)
+      else
+        expect(response_body[owner_foreign_key.to_s]).to eq(current_user.id)
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_show.rb

@@ -2,21 +2,21 @@
 
 shared_examples 'simple crud for show' do
   describe 'GET #show' do
-    subject(:show_request) { get :show, params: show_params }
+    subject(:show_request) { get :show, params: with_route_params(show_params), format: request_format(:show) }
 
     before do
       model
     end
 
     context 'without authenticated user' do
-      subject!(:req) { get :show, params: { id: model.id } }
+      subject!(:req) { get :show, params: with_route_params(record_param(:show, model)), format: request_format(:show) }
 
-      include_examples 'unauthorized when not logged in'
+      include_examples 'unauthorized when not logged in' if check_authenticate(:show)
     end
 
     describe 'when the model exists' do
       include_context 'with authenticated user'
-      let(:show_params) { { id: model.id } }
+      let(:show_params) { record_param(:show, model) }
 
       before do
         show_request
@@ -26,18 +26,22 @@ shared_examples 'simple crud for show' do
         expect(response).to have_http_status(:ok)
       end
 
-      it 'returns the asked model' do
-        expect(response_body['id']).to eq(model.id)
-      end
+      if check_html(:show)
+        include_examples 'simple crud renders template', :show
+      else
+        it 'returns the asked model' do
+          expect(response_body['id']).to eq(model.id)
+        end
 
-      it 'have been serializer with model Serializer' do
-        expect(response_body).to have_been_serialized_with(model_serializer)
+        it 'have been serializer with model Serializer' do
+          expect(response_body).to have_been_serialized_with(model_serializer)
+        end
       end
     end
 
     describe 'when the model does not exist' do
       include_context 'with authenticated user'
-      let(:show_params) { { id: -1 } }
+      let(:show_params) { record_param(:show, nil, not_found: true) }
 
       before do
         show_request

data/lib/spec/shared_examples/simple_crud_for_show_with_block.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for show with block' do
+  describe 'GET #show with a render block' do
+    include_context 'with authenticated user' if check_authenticate(:show)
+
+    let!(:record) { model }
+
+    before do
+      make_policies_succeed(:show) if check_authorize(:show)
+      get :show, params: with_route_params(record_param(:show, record)), format: request_format(:show)
+    end
+
+    if check_html(:show)
+      include_examples 'simple crud renders template', :show
+    else
+      it 'renders the record through the block' do
+        expect(response).to be_successful
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_show_with_finder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for show with finder' do
+  describe 'GET #show with a custom finder' do
+    include_context 'with authenticated user' if check_authenticate(:show)
+
+    context 'when the model exists' do
+      before do
+        model
+        get :show, params: with_route_params(finder_key => model.public_send(finder_key)),
+                   format: request_format(:show)
+      end
+
+      if check_block(:show)
+        it 'finds the asked model' do
+          expect(rendered_record.id).to eq(model.id)
+        end
+      elsif check_html(:show)
+        include_examples 'simple crud renders template', :show
+      else
+        it 'responds with ok status' do
+          expect(response).to have_http_status(:ok)
+        end
+
+        it 'returns the asked model' do
+          expect(response_body['id']).to eq(model.id)
+        end
+      end
+    end
+
+    include_examples 'simple crud not found with finder', :get, :show
+  end
+end