wor-simple_crud 0.3.0 → 0.3.1

data/lib/simple_crud/rspec/helpers.rb

@@ -1,147 +1,25 @@
 # frozen_string_literal: true
 
+require_relative 'helpers/settings'
+require_relative 'helpers/controller_options'
+require_relative 'helpers/models'
+require_relative 'helpers/authentication'
+require_relative 'helpers/requests'
+require_relative 'helpers/policies'
+
 module SimpleCrud
   module RSpec
     # Helpers available to the shared examples (and to apps that include
-    # them). Everything app-specific is delegated to SimpleCrud::RSpec::Config
-    # so it can be overridden without editing the examples.
+    # them), composed from focused sub-modules: settings resolution,
+    # controller-option introspection, record building, authentication,
+    # request params and policy access.
     module Helpers
-      def config
-        SimpleCrud::RSpec::Config.instance
-      end
-
-      def get_option(method, option)
-        described_class.instance_variable_get(:@simple_crud_metadata)[method][option]
-      end
-
-      # :unprocessable_entity was renamed :unprocessable_content in Rack 3.1.
-      # Resolve the current Rack's canonical symbol for 422.
-      def unprocessable_status
-        Rack::Utils::SYMBOL_TO_STATUS_CODE.invert[422]
-      end
-
-      %i[paginate authorize authenticate serializer html finder scope build raise_on_invalid].each do |option|
-        define_method("check_#{option}") { |method| get_option(method, option) }
-      end
-
-      %i[owner_association required_attribute required_error finder_key params_key invalid_status
-         unauthenticated_status assert_html_template].each do |setting|
-        define_method(setting) { resolve(config.public_send(setting)) }
-      end
-
-      def model_class
-        described_class.to_s.split('::')
-                       .last.sub('Controller', '').singularize.underscore
-      end
-
-      def model_class_object
-        model_class.classify.constantize
-      end
-
-      def model
-        @model ||= create_record(model_class, model_attributes)
-      end
-
-      def model_attributes
-        association = resolve(config.owner_association)
-        association ? { association => current_user } : {}
-      end
-
-      def create_record(klass, attributes)
-        instance_exec(klass, attributes, &config.create_record)
-      end
-
-      def create_records(klass, count, attributes)
-        instance_exec(klass, count, attributes, &config.create_records)
-      end
-
-      def params_for(klass)
-        instance_exec(klass, &config.params_for)
-      end
-
-      def model_params
-        @model_params ||= params_for(model_class)
-      end
-
-      def current_user
-        @current_user ||= instance_exec(&config.current_user)
-      end
-
-      def authenticate_request
-        instance_exec(&config.authenticate)
-      end
-
-      def owner_foreign_key
-        :"#{owner_association}_id"
-      end
-
-      # The owner association attributed to current_user, if the model has one.
-      def owner_params
-        owner_association ? { owner_foreign_key => current_user.id } : {}
-      end
-
-      # Extra params (e.g. a parent slug) added to every request, for nested
-      # resources like /classrooms/:classroom_slug/assignments.
-      def route_params
-        resolve(config.route_params)
-      end
-
-      def with_route_params(attrs)
-        route_params.merge(attrs)
-      end
-
-      # The params that identify a record for the given action, using the
-      # configured finder_key when the action has a custom finder.
-      def record_param(action, record, not_found: false)
-        key = check_finder(action) ? finder_key : :id
-        value = not_found ? "nonexistent-#{key}" : record.public_send(key)
-        { key => value }
-      end
-
-      # Wraps a request body under the model's strong-params key when
-      # params_key is configured (nested strong params), else passes it flat.
-      def body_params(attrs)
-        key = params_key
-        key ? { key => attrs } : attrs
-      end
-
-      def policy_class_object
-        instance_exec(model_class_object, &config.policy_class)
-      end
-
-      def model_serializer
-        defined?(serializer) ? serializer : instance_exec(model, &config.serializer_class)
-      end
-
-      def make_policies_fail(method)
-        allow(policy_class_object).to receive(:new)
-          .and_return(instance_double(policy_class_object, "#{method}?" => false))
-      end
-
-      def make_policies_succeed(method)
-        allow(policy_class_object).to receive(:new)
-          .and_return(instance_double(policy_class_object, "#{method}?" => true))
-      end
-
-      def request_format(action)
-        check_html(action) ? :html : :json
-      end
-
-      def resolve(value)
-        value.is_a?(Proc) ? instance_exec(&value) : value
-      end
-
-      # Runs the block with a config setting temporarily overridden, restoring
-      # the original value afterwards (even if the block raises). Useful when
-      # a controller's spec needs a different setting than the app-wide default.
-      def with_config_override(setting, value)
-        config_instance = SimpleCrud::RSpec::Config.instance
-        original = config_instance.public_send(setting)
-        SimpleCrud::RSpec.configure { |c| c.public_send("#{setting}=", value) }
-        yield
-      ensure
-        SimpleCrud::RSpec.configure { |c| c.public_send("#{setting}=", original) }
-      end
+      include Settings
+      include ControllerOptions
+      include Models
+      include Authentication
+      include Requests
+      include Policies
     end
   end
 end

data/lib/simple_crud/rspec.rb

@@ -10,6 +10,7 @@ require_relative '../spec/shared_examples/simple_crud_for_index'
 require_relative '../spec/shared_examples/simple_crud_for_destroy'
 require_relative '../spec/shared_examples/simple_crud_for_create'
 require_relative '../spec/shared_examples/simple_crud_for_new'
+require_relative '../spec/shared_examples/simple_crud_for_edit'
 require_relative '../spec/shared_examples/unauthorized_when_not_logged_in'
 require_relative '../spec/shared_examples/simple_crud_renders_template'
 require_relative '../spec/shared_examples/simple_crud_without_authenticated_user'

data/lib/simple_crud/simple_crud_controller.rb

@@ -3,10 +3,13 @@
 require 'active_support/all'
 require_relative 'config'
 require_relative 'controller_helpers'
+require_relative 'action_lambdas'
 
 # Extended onto a controller for CRUD actions.
 module SimpleCrudController
   extend SimpleCrud::ControllerHelpers
+  # Include, not extend: controllers gain these by extending SimpleCrudController.
+  include SimpleCrud::ActionLambdas
 
   cattr_accessor :params, :permitted
 
@@ -15,15 +18,16 @@ module SimpleCrudController
   ### paginate: paginate the list via Config.pagination_adapter (wor-paginate by default)
   ### authenticate: use devise to authenticate
   ### serializer: use a particular serializer (both each_serializer and serializer)
-  ### html: render the action's ERB template instead of JSON (index/show/new/create/update/destroy)
-  ### finder: custom record lookup (Proc/lambda or Symbol) for :show/:update/:destroy
+  ### html: render the action's ERB template instead of JSON (index/show/new/edit/create/update/destroy)
+  ### finder: custom record lookup (Proc/lambda or Symbol) for :show/:update/:destroy/:edit
   ### scope: custom index scope (Proc/lambda taking current_user and optional params), overrides policy_scope
   ### build: custom record builder (Proc/lambda) for :new/:create, invoked with the controller as self
   ### raise_on_invalid: use strict create!/update! semantics instead of returning 422
   ### A block given to simple_crud_for renders explicitly: it receives the records for :index,
-  ### the record for :show/:new, or the record and a saved flag for :create/:update/:destroy
+  ### the record for :show/:new/:edit, or the record and a saved flag for :create/:update/:destroy
   def simple_crud_for(method, parameters = {}, &block)
     parameters[:html] = true if block && !parameters.key?(:html)
+    parameters[:block] = true if block
     parameters = parameters_with_defaults(parameters)
     klass = simple_crud_controller_model
     check_valid_method(method)
@@ -47,77 +51,12 @@ module SimpleCrudController
     @simple_crud_metadata[method] = parameters
   end
 
-  def crud_lambda_for_show(klass, parameters = {}, &block)
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      requested = SimpleCrudController.find_record(klass, self, parameters)
-
-      options = {}.merge(serializer: parameters[:serializer]).compact
-      SimpleCrudController.maybe_authorize(self, requested, parameters)
-      SimpleCrudController.render_show(self, requested, options, parameters, &block)
-    end
-  end
-
-  def crud_lambda_for_new(klass, parameters = {}, &block)
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      record = SimpleCrudController.build_record(self, klass, parameters)
-      SimpleCrudController.maybe_authorize(self, record, parameters)
-      SimpleCrudController.render_new(self, record, parameters, &block)
-    end
-  end
-
-  def crud_lambda_for_index(klass, parameters = {}, &block)
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      SimpleCrudController.maybe_authorize(self, klass.new, parameters)
-      options = {}.merge(each_serializer: parameters[:serializer]).compact
-      SimpleCrudController.render_index(self, klass, options, parameters, &block)
-    end
-  end
-
-  def crud_lambda_for_create(klass, parameters = {}, &block)
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-      record = SimpleCrudController.build_record(self, klass, parameters)
-      record.assign_attributes(permitted_params)
-      SimpleCrudController.maybe_authorize(self, record, parameters)
-      persist = ->(bang:) { bang ? record.save! : record.save }
-      options = { status: :created, failure_template: :new }
-      SimpleCrudController.save_and_render(self, record, parameters, options, persist, &block)
-    end
-  end
-
-  def crud_lambda_for_update(klass, parameters = {}, &block)
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      requested = SimpleCrudController.find_record(klass, self, parameters)
-      SimpleCrudController.maybe_authorize(self, requested, parameters)
-      permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-      persist = ->(bang:) { bang ? requested.update!(permitted_params) : requested.update(permitted_params) }
-      options = { status: :ok, failure_template: :edit }
-      SimpleCrudController.save_and_render(self, requested, parameters, options, persist, &block)
-    end
-  end
-
-  def crud_lambda_for_destroy(klass, parameters = {}, &block)
-    lambda do
-      authenticate_user! if parameters[:authenticate]
-      requested = SimpleCrudController.find_record(klass, self, parameters)
-      SimpleCrudController.maybe_authorize(self, requested, parameters)
-      options = { status: :ok, failure_template: :show, redirect: parameters[:redirect] || klass }
-      persist = ->(bang:) { bang ? requested.destroy! : requested.destroy }
-      SimpleCrudController.persist_and_render(self, requested, parameters, options, persist, &block)
-    end
-  end
-
   def simple_crud_controller_model
     to_s.split('::').last.sub('Controller', '').singularize.classify.constantize
   end
 
   def check_valid_method(method)
-    raise ArgumentError, 'invalid method' unless %i[show index create update destroy new].include? method
+    raise ArgumentError, 'invalid method' unless %i[show index create update destroy new edit].include? method
   end
 
   def check_policies(parameters)
@@ -130,11 +69,9 @@ module SimpleCrudController
   end
 
   def check_serializer(parameters)
-    return if parameters[:serializer].blank?
-
-    serializer_name = parameters[:serializer].to_s
-    return if Kernel.const_defined?(serializer_name)
+    name = parameters[:serializer].to_s
+    return if name.blank? || Kernel.const_defined?(name)
 
-    raise ArgumentError, "create a valid serializer with name #{serializer_name}"
+    raise ArgumentError, "create a valid serializer with name #{name}"
   end
 end

data/lib/simple_crud/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCrud
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/lib/spec/shared_examples/simple_crud_for_create.rb

@@ -47,8 +47,9 @@ shared_examples 'simple crud for create' do
         end
       end
 
-      it 'creates the record' 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
 
@@ -60,20 +61,22 @@ shared_examples 'simple crud for create' do
           post :create, params: with_route_params(body_params(owner_params)), format: request_format(:create)
         end
 
-        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
+        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)
+            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
+        it 'does not create a model' do
+          expect(model_class_object.count).to be 0
         end
       end
     end

data/lib/spec/shared_examples/simple_crud_for_create_with_block.rb

@@ -2,17 +2,35 @@
 
 shared_examples 'simple crud for create with block' do
   describe 'POST #create with a render block' do
-    it 'passes the saved record to the block' do
-      post :create, params: with_route_params(body_params({ name: 'Blocked' }.merge(owner_params)))
+    context 'when successfully creating a record' do
+      include_context 'with authenticated user' if check_authenticate(:create)
+      let(:create_params) { model_params.merge(owner_params) }
 
-      expect(response.parsed_body).to include('saved' => true)
+      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
 
-    it 'passes the failed record to the block', :aggregate_failures do
-      post :create, params: with_route_params(body_params(owner_params))
+    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
 
-      expect(response).to have_http_status(422)
-      expect(response.parsed_body).to include('saved' => false)
+        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

@@ -2,10 +2,10 @@
 
 shared_examples 'simple crud for create with build' do
   describe 'POST #create with a build hook' do
-    include_context 'with authenticated user'
+    include_context 'with authenticated user' if check_authenticate(:create)
 
     before do
-      post :create, params: with_route_params(body_params({ name: 'Built' }))
+      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

data/lib/spec/shared_examples/simple_crud_for_destroy.rb

@@ -46,6 +46,31 @@ shared_examples 'simple crud for destroy' do
       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
+
     context 'when ID is invalid' do
       include_context 'with authenticated user' if check_authenticate(:destroy)
 

data/lib/spec/shared_examples/simple_crud_for_destroy_with_block.rb

@@ -2,12 +2,20 @@
 
 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 { delete :destroy, params: with_route_params({ id: record.id }) }
+    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.parsed_body).to eq('destroyed' => true)
+      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

@@ -2,21 +2,32 @@
 
 shared_examples 'simple crud for destroy with finder' do
   describe 'DELETE #destroy with a custom finder' do
-    include_context 'with authenticated user'
+    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))
-      end
-
-      it 'responds with ok status' do
-        expect(response).to have_http_status(:ok)
+        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

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

@@ -13,7 +13,7 @@ shared_examples 'simple crud for index' do
       include_context 'with authenticated user' if check_authenticate(:index)
 
       before do
-        make_policies_succeed(:index)
+        make_policies_succeed(:index) if check_authorize(:index)
         get :index, params: with_route_params({}), format: request_format(:index)
       end
 

data/lib/spec/shared_examples/simple_crud_for_index_with_block.rb

@@ -2,13 +2,21 @@
 
 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, {}) }
+    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: :html
+      get :index, params: with_route_params({}), format: request_format(:index)
     end
 
-    include_examples 'simple crud renders template', :index
+    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

@@ -1,21 +1,33 @@
 # 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) { {} }
+  let(:my_models) { create_records(model_class, 2, scoped_attributes) }
+  let(:other_models) { create_records(model_class, 3, other_scoped_attributes) }
 
-  before do
-    authenticate_request
-    make_policies_succeed(:index)
-    my_models
-    other_models
-    get :index, params: with_route_params(request_params)
-  end
+  # 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
 
-  it 'returns only the scoped records' do
-    expect(response_body['page'].map { |m| m['id'] }).to match_array(my_models.map(&:id))
+    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