wor-simple_crud 0.2.1 → 0.3.0

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
+        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,14 @@
+# 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, {}) }
+
+    before do
+      created_models
+      get :index, params: with_route_params({}), format: :html
+    end
+
+    include_examples 'simple crud renders template', :index
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_index_with_scope.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for index with scope' do
+  let(:user) { current_user }
+  let(:other_user) { resolve(config.other_user) }
+  let(:my_models) { create_records(model_class, 2, owner_association => user) }
+  let(:other_models) { create_records(model_class, 3, owner_association => other_user) }
+  let(:request_params) { {} }
+
+  before do
+    authenticate_request
+    make_policies_succeed(:index)
+    my_models
+    other_models
+    get :index, params: with_route_params(request_params)
+  end
+
+  it 'returns only the scoped records' do
+    expect(response_body['page'].map { |m| m['id'] }).to match_array(my_models.map(&:id))
+  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)
+        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,9 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for new with block' do
+  describe 'GET #new with a render block' do
+    before { get :new, params: with_route_params({}), format: :html }
+
+    include_examples 'simple crud renders template', :new
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_new_with_build.rb

@@ -0,0 +1,13 @@
+# 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'
+
+    before { get :new, params: with_route_params({}) }
+
+    it 'builds the record owned by the current user' do
+      expect(response_body[owner_foreign_key.to_s]).to eq(current_user.id)
+    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,11 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for show with block' do
+  describe 'GET #show with a render block' do
+    let!(:record) { model }
+
+    before { get :show, params: with_route_params({ id: record.id }), format: :html }
+
+    include_examples 'simple crud renders template', :show
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_show_with_finder.rb

@@ -0,0 +1,24 @@
+# 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'
+
+    context 'when the model exists' do
+      before do
+        model
+        get :show, params: with_route_params(finder_key => model.public_send(finder_key))
+      end
+
+      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
+
+    include_examples 'simple crud not found with finder', :get, :show
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_update.rb

@@ -3,9 +3,12 @@
 shared_examples 'simple crud for update' do
   describe 'PUT #update' do
     context 'without authenticated user' do
-      subject!(:req) { put :update, params: attributes_for(model_class).merge(id: model.id) }
+      subject!(:req) do
+        update_params = body_params(params_for(model_class)).merge(record_param(:update, model))
+        put :update, params: with_route_params(update_params), format: request_format(:update)
+      end
 
-      include_examples 'unauthorized when not logged in'
+      include_examples 'unauthorized when not logged in' if check_authenticate(:update)
     end
 
     if check_authorize(:update)
@@ -14,7 +17,8 @@ shared_examples 'simple crud for update' do
 
         before do
           make_policies_fail(:update)
-          put :update, params: model_params.merge(id: model.id)
+          put :update, params: with_route_params(body_params(model_params).merge(record_param(:update, model))),
+                       format: request_format(:update)
         end
 
         it 'fails with forbidden' do
@@ -24,32 +28,43 @@ shared_examples 'simple crud for update' do
     end
 
     context 'when successfully updating an model' do
-      include_context 'with authenticated user'
+      include_context 'with authenticated user' if check_authenticate(:update)
+      let(:update_params) { body_params(model_params).merge(record_param(:update, model)) }
+      let(:update_attributes) { model_params.merge(record_param(:update, model).except(:id)) }
 
       before do
         model
-        put :update, params: model_params.merge(id: model.id)
+        put :update, params: with_route_params(update_params), format: request_format(:update)
       end
 
-      it 'response with 200 status code' do
-        expect(response).to have_http_status(:ok)
-      end
+      if check_html(:update)
+        it 'redirects to the updated record' do
+          expect(response).to have_http_status(:found)
+        end
+      else
+        it 'response with 200 status code' do
+          expect(response).to have_http_status(:ok)
+        end
 
-      it 'updates an model' do
-        expect(model_class_object.count).to be 1
-      end
+        it 'updates an model' do
+          expect(model_class_object.count).to be 1
+        end
 
-      it 'updates an model with valid attributes' do
-        expect(model_class.classify.constantize.last).to have_attributes(model_params)
+        it 'updates an model with valid attributes' do
+          expect(model_class_object.last).to have_attributes(update_attributes)
+        end
       end
     end
 
     context 'when updating a model that doesn\'t exist' do
       include_context 'with authenticated user'
 
-      before { put :update, params: { id: 1 } }
+      before do
+        put :update, params: with_route_params(record_param(:update, nil, not_found: true)),
+                     format: request_format(:update)
+      end
 
-      it 'response with 422 status code' do
+      it 'response with 404 status code' do
         expect(response).to have_http_status(:not_found)
       end
 
@@ -57,5 +72,30 @@ shared_examples 'simple crud for update' do
         expect(model_class_object.count).to be 0
       end
     end
+
+    unless check_raise_on_invalid(:update)
+      context 'when updating with invalid attributes' do
+        include_context 'with authenticated user' if check_authenticate(:update)
+
+        before do
+          model
+          put :update, params: with_route_params(body_params({ required_attribute => nil }.merge(owner_params))
+                                                         .merge(record_param(:update, model))),
+                       format: request_format(:update)
+        end
+
+        if check_html(:update)
+          include_examples 'simple crud renders template', :edit, -> { 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
+    end
   end
 end

data/lib/spec/shared_examples/simple_crud_for_update_with_finder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for update with finder' do
+  describe 'PUT #update with a custom finder' do
+    include_context 'with authenticated user'
+
+    context 'when successfully updating a model' do
+      let(:update_params) do
+        with_route_params(body_params(required_attribute => 'Updated').merge(owner_params))
+          .merge(finder_key => model.public_send(finder_key))
+      end
+
+      before do
+        model
+        put :update, params: update_params
+      end
+
+      it 'responds with ok status' do
+        expect(response).to have_http_status(:ok)
+      end
+
+      it 'updates the model' do
+        expect(model.reload.public_send(required_attribute)).to eq('Updated')
+      end
+    end
+
+    include_examples 'simple crud not found with finder', :put, :update
+  end
+end

data/lib/spec/shared_examples/simple_crud_not_found_with_finder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud not found with finder' do |http_method, action|
+  context 'when the model does not exist' do
+    before do
+      send(http_method, action, params: with_route_params(finder_key => "nonexistent-#{finder_key}"))
+    end
+
+    it 'responds with not found status' do
+      expect(response).to have_http_status(:not_found)
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_renders_template.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud renders template' do |template, status = :ok|
+  it "renders the #{template} template", :aggregate_failures do
+    expect(response).to have_http_status(resolve(status))
+    expect(response).to render_template(template) if assert_html_template
+  end
+end

data/lib/spec/shared_examples/simple_crud_when_not_authorized.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud when not authorized' do |action, verb, request_params = {}|
+  if check_authorize(action)
+    context 'when not authorized' do
+      include_context 'with authenticated user' if check_authenticate(action)
+
+      before do
+        make_policies_fail(action)
+        send(verb, action, params: with_route_params(request_params))
+      end
+
+      it 'fails with forbidden' do
+        expect(response).to have_http_status(:forbidden)
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_without_authenticated_user.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud without authenticated user' do |action|
+  context 'without authenticated user' do
+    subject!(:req) { get action, params: with_route_params({}) }
+
+    include_examples 'unauthorized when not logged in' if check_authenticate(action)
+  end
+end

data/lib/spec/shared_examples/unauthorized_when_not_logged_in.rb

@@ -2,9 +2,9 @@
 
 shared_examples 'unauthorized when not logged in' do
   context 'when the user is not logged in' do
-    it 'returns status code unauthorized' do
+    it 'returns the unauthenticated status' do
       req
-      expect(response).to have_http_status(:unauthorized)
+      expect(response).to have_http_status(unauthenticated_status)
     end
   end
 end

data/spec/block/dummy_models_controller_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Block::DummyModelsController, type: :controller do
+  include_examples 'simple crud for index with block'
+  include_examples 'simple crud for index'
+end

data/spec/block_create/dummy_models_controller_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BlockCreate::DummyModelsController, type: :controller do
+  include_examples 'simple crud for create with block'
+end

data/spec/block_destroy/dummy_models_controller_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BlockDestroy::DummyModelsController, type: :controller do
+  include_examples 'simple crud for destroy with block'
+end

data/spec/block_new/dummy_models_controller_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BlockNew::DummyModelsController, type: :controller do
+  include_examples 'simple crud for new with block'
+end

data/spec/block_show/dummy_models_controller_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BlockShow::DummyModelsController, type: :controller do
+  include_examples 'simple crud for show with block'
+end

data/spec/built/dummy_models_controller_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Built::DummyModelsController, type: :controller do
+  include_examples 'simple crud for new with build'
+  include_examples 'simple crud for create with build'
+end

data/spec/dummy/app/controllers/block/dummy_models_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Block
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    extend SimpleCrudController
+
+    before_action :set_params
+    def set_params
+      SimpleCrudController.params = params
+    end
+
+    simple_crud_for :index, paginate: false, authenticate: false, authorize: false do |records|
+      render :index, locals: { models: records }
+    end
+  end
+end

data/spec/dummy/app/controllers/block_create/dummy_models_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BlockCreate
+  class DummyModelsController < HtmlModes::BaseController
+    simple_crud_for :create, html: false, authenticate: false, authorize: false do |record, saved|
+      if saved
+        render json: { saved: true, id: record.id }
+      else
+        render json: { saved: false, errors: record.errors.full_messages }, status: 422
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/block_destroy/dummy_models_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BlockDestroy
+  class DummyModelsController < HtmlModes::BaseController
+    simple_crud_for :destroy, html: false, authenticate: false, authorize: false do |_record, destroyed|
+      render json: { destroyed: destroyed ? true : false }
+    end
+  end
+end

data/spec/dummy/app/controllers/block_modes/base_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module BlockModes
+  class BaseController < HtmlModes::BaseController
+    private
+
+    def render_model(record, template)
+      render template, locals: { model: record }
+    end
+  end
+end

data/spec/dummy/app/controllers/block_new/dummy_models_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BlockNew
+  class DummyModelsController < BlockModes::BaseController
+    simple_crud_for :new, authenticate: false, authorize: false do |record|
+      render_model(record, :new)
+    end
+  end
+end

data/spec/dummy/app/controllers/block_show/dummy_models_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BlockShow
+  class DummyModelsController < BlockModes::BaseController
+    simple_crud_for :show, authenticate: false, authorize: false do |record|
+      render_model(record, :show)
+    end
+  end
+end

data/spec/dummy/app/controllers/built/dummy_models_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Built
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    before_action :set_params
+    def set_params
+      SimpleCrudController.params = params
+    end
+
+    def dummy_model_params
+      params.permit(:name, :something, :user_id, :slug)
+    end
+
+    simple_crud_for :new, build: -> { current_user.dummy_models.build }
+    simple_crud_for :create, build: -> { current_user.dummy_models.build }
+  end
+end

data/spec/dummy/app/controllers/dummy_models_controller.rb

@@ -12,12 +12,13 @@ class DummyModelsController < ApplicationController
   end
 
   def dummy_model_params
-    params.permit(:name, :something, :user_id)
+    params.permit(:name, :something, :user_id, :slug)
   end
 
   simple_crud_for :create
   simple_crud_for :destroy
   simple_crud_for :update
   simple_crud_for :show
+  simple_crud_for :new
   simple_crud_for :index
 end

data/spec/dummy/app/controllers/finder/dummy_models_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Finder
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    before_action :set_params
+    def set_params
+      SimpleCrudController.params = params
+    end
+
+    def dummy_model_params
+      params.permit(:name, :something, :user_id)
+    end
+
+    simple_crud_for :show, finder: ->(params) { DummyModel.find_by!(slug: params[:slug]) }
+    simple_crud_for :update, finder: :find_by_slug
+    simple_crud_for :destroy, finder: ->(params) { DummyModel.find_by!(slug: params[:slug]) }
+  end
+end

data/spec/dummy/app/controllers/html/dummy_models_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Html
+  class DummyModelsController < HtmlModes::BaseController
+    simple_crud_for :index, html: true, authenticate: false, authorize: false
+  end
+end

data/spec/dummy/app/controllers/html_create/dummy_models_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HtmlCreate
+  class DummyModelsController < HtmlModes::BaseController
+    simple_crud_for :create, html: true, authenticate: false, authorize: false
+  end
+end