wor-simple_crud 0.5.0 → 0.7.0

data/lib/simple_crud/rspec/helpers/requests.rb

@@ -11,8 +11,11 @@ module SimpleCrud
           Rack::Utils::SYMBOL_TO_STATUS_CODE.invert[422]
         end
 
-        def request_format(action)
-          check_html(action) ? :html : :json
+        # Rails copies the controller-test `format:` kwarg into params, which
+        # collides with a model attribute named `format`. Only HTML requests
+        # need it, so leave params untouched for JSON.
+        def format_param(action)
+          check_html(action) ? :html : nil
         end
 
         # Extra params (e.g. a parent slug) added to every request, for nested

data/lib/simple_crud/rspec.rb

@@ -27,6 +27,8 @@ require_relative '../spec/shared_examples/simple_crud_for_destroy_with_finder'
 require_relative '../spec/shared_examples/simple_crud_not_found_with_finder'
 require_relative '../spec/shared_examples/simple_crud_for_new_with_build'
 require_relative '../spec/shared_examples/simple_crud_for_create_with_build'
+require_relative '../spec/shared_examples/simple_crud_for_owned_resource'
+require_relative '../spec/shared_examples/simple_crud_for_nested_resource'
 require_relative '../spec/shared_examples/authorization_adapter_authorize'
 require_relative '../spec/matchers/have_been_serialized_with'
 

data/lib/simple_crud/serializer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  # Precedence: Blueprinter, then a plain class .render, then ActiveModelSerializers.
+  module Serializer
+    def self.render(serializer, record, options = {})
+      return record.as_json if serializer.nil?
+      return serializer.render_as_hash(record, options) if serializer.respond_to?(:render_as_hash)
+      return serializer.render(record, **options) if serializer.is_a?(Class) && serializer.respond_to?(:render)
+
+      serializer.new(record, options).as_json
+    end
+  end
+end

data/lib/simple_crud/show_context.rb

@@ -21,7 +21,9 @@ module SimpleCrud
       record = find_record
       maybe_authorize(record)
       controller.instance_variable_set(:@record, record)
-      block ? controller.instance_exec(record, &block) : record.as_json
+      return controller.instance_exec(record, &block) if block
+
+      SimpleCrud::Serializer.render(parameters[:serializer], record, serializer_options(record))
     end
   end
 end

data/lib/simple_crud/simple_crud_controller.rb

@@ -2,7 +2,9 @@
 
 require 'active_support/all'
 require_relative 'config'
+require_relative 'serializer'
 require_relative 'cache_helpers'
+require_relative 'relation_source'
 require_relative 'action_context'
 require_relative 'persistence_context'
 require_relative 'show_context'
@@ -31,16 +33,26 @@ module SimpleCrudController
   ### serializer: use a particular serializer (both each_serializer and serializer)
   ### 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
+  ### scope: custom index scope for :index, overriding policy_scope. A Proc/lambda run with the
+  ###   controller as self (arity 0 no args, arity 1 the user, else user and params), or a Symbol
+  ###   naming a model class method taking (current_user, params)
   ### build: custom record builder (Proc/lambda) for :new/:create, invoked with the controller as self
+  ### owned_by: association on Config.user_method for the default finder/build/index-scope
+  ### parent: nested-route parent for the same defaults; exclusive with owned_by:
+  ### parent_association: parent association when it differs from the controller model's plural
+  ### notice:/alert: flash on the html: create/update/destroy success redirect / failure re-render
   ### 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/:edit, or the record and a saved flag for :create/:update/:destroy
+  ### An Array of actions declares several at once with the same options
   def simple_crud_for(method, parameters = {}, &block)
+    return method.each { |name| simple_crud_for(name, parameters.dup, &block) } if method.is_a?(Array)
+
     parameters[:block] = true if block
     parameters = parameters_with_defaults(parameters)
     klass = simple_crud_controller_model
     check_valid_method(method)
+    check_relation_source(parameters)
     check_policies(parameters)
     check_serializer(parameters)
     define_method(method, send("crud_lambda_for_#{method}", klass, parameters, &block))
@@ -61,17 +73,22 @@ module SimpleCrudController
   end
 
   def parameters_with_defaults(parameters)
-    defaults = {
-      authorize: true, paginate: true, authenticate: true, authenticate_headers: nil,
-      serializer: nil, html: false, finder: nil, scope: nil, build: nil, raise_on_invalid: false
-    }
     defaults.merge(simple_crud_inherited_defaults).each do |key, value|
       parameters[key] = value unless parameters.key?(key)
     end
-    parameters[:authenticate_headers] = parameters[:authenticate] if parameters[:authenticate_headers].nil?
+    parameters[:authenticate_headers] ||= parameters[:authenticate]
     parameters
   end
 
+  def defaults
+    {
+      authorize: true, paginate: true, authenticate: true, authenticate_headers: nil,
+      serializer: nil, serializer_options: nil, status: nil, after_persist: nil, html: false,
+      finder: nil, scope: nil, build: nil, owned_by: nil, parent: nil, parent_association: nil,
+      notice: nil, alert: nil, raise_on_invalid: false
+    }
+  end
+
   def write_metadata(method, parameters)
     @simple_crud_metadata ||= {}
     @simple_crud_metadata[method] = parameters
@@ -85,6 +102,12 @@ module SimpleCrudController
     raise ArgumentError, 'invalid method' unless %i[show index create update destroy new edit].include? method
   end
 
+  def check_relation_source(parameters)
+    return unless parameters[:owned_by] && parameters[:parent]
+
+    raise ArgumentError, 'owned_by: and parent: are mutually exclusive, they both scope the same action'
+  end
+
   def check_policies(parameters)
     return if !parameters.key?(:authorize) || !parameters[:authorize]
 

data/lib/simple_crud/update_context.rb

@@ -9,7 +9,8 @@ module SimpleCrud
       maybe_authorize(record)
       attrs   = permitted_params
       persist = ->(bang:) { bang ? record.update!(attrs) : record.update(attrs) }
-      options = { status: :ok, failure_template: :edit, redirect: parameters[:redirect] || record }
+      options = { status: parameters[:status] || :ok, failure_template: :edit,
+                  redirect: parameters[:redirect] || record }
       persist_and_render(record, options, persist)
     end
   end

data/lib/simple_crud/version.rb

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

data/lib/spec/matchers/have_been_serialized_with.rb

@@ -4,12 +4,29 @@ RSpec::Matchers.define :have_been_serialized_with do |serializer|
   # TODO: Add support for optional relations `has_many :zarasa, if: zarasa2`
   # TODO: Support multilevel serialization
   match do |json_response|
+    attributes  = serializer_attributes(serializer)
+    reflections = serializer_reflections(serializer)
+
     [json_response].flatten.all? do |json_response_item|
-      all_attributes_included?(serializer._attributes, json_response_item) &&
-        all_attributes_included?(serializer._reflections.keys, json_response_item)
+      all_attributes_included?(attributes, json_response_item) &&
+        all_attributes_included?(reflections, json_response_item)
     end
   end
 
+  # Blueprinter blueprints expose their fields through the view collection;
+  # ActiveModelSerializers expose `._attributes` / `._reflections`.
+  def serializer_attributes(serializer)
+    return serializer._attributes unless serializer.respond_to?(:view_collection)
+
+    serializer.view_collection.fields_for(:default).map(&:name)
+  end
+
+  def serializer_reflections(serializer)
+    return serializer._reflections.keys unless serializer.respond_to?(:view_collection)
+
+    []
+  end
+
   failure_message do |json_response|
     "expected attributes of #{serializer} serializer to be included in #{json_response}"
   end

data/lib/spec/shared_examples/simple_crud_for_create.rb

@@ -4,7 +4,7 @@ RSpec.shared_examples 'simple crud for create' do
   describe 'POST #create' do
     context 'without authenticated user' do
       subject!(:req) do
-        post :create, params: with_route_params(body_params(params_for(model_class))), format: request_format(:create)
+        post :create, params: with_route_params(body_params(params_for(model_class))), format: format_param(:create)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:create)
@@ -16,7 +16,7 @@ RSpec.shared_examples 'simple crud for create' do
 
         before do
           make_policies_fail(:create)
-          post :create, params: with_route_params(body_params(model_params)), format: request_format(:create)
+          post :create, params: with_route_params(body_params(model_params)), format: format_param(:create)
         end
 
         it 'fails with forbidden' do
@@ -30,7 +30,7 @@ RSpec.shared_examples 'simple crud for create' do
       let(:create_params) { model_params.merge(owner_params) }
 
       before do
-        post :create, params: with_route_params(body_params(create_params)), format: request_format(:create)
+        post :create, params: with_route_params(body_params(create_params)), format: format_param(:create)
       end
 
       if check_html(:create)
@@ -38,8 +38,8 @@ RSpec.shared_examples 'simple crud for create' do
           expect(response).to have_http_status(:found)
         end
       else
-        it 'response with 201 status code' do
-          expect(response).to have_http_status(:created)
+        it 'response with the configured status code' do
+          expect(response).to have_http_status(check_status(:create) || :created)
         end
 
         it 'creates an article with valid attributes' do
@@ -58,7 +58,7 @@ RSpec.shared_examples 'simple crud for create' 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)
+          post :create, params: with_route_params(body_params(owner_params)), format: format_param(:create)
         end
 
         unless check_block(:create)

data/lib/spec/shared_examples/simple_crud_for_create_with_block.rb

@@ -7,7 +7,7 @@ RSpec.shared_examples 'simple crud for create with block' do
       let(:create_params) { model_params.merge(owner_params) }
 
       before do
-        post :create, params: with_route_params(body_params(create_params)), format: request_format(:create)
+        post :create, params: with_route_params(body_params(create_params)), format: format_param(:create)
       end
 
       it 'passes the saved record to the block' do
@@ -24,7 +24,7 @@ RSpec.shared_examples 'simple crud for create with block' 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)
+          post :create, params: with_route_params(body_params(owner_params)), format: format_param(:create)
         end
 
         it 'does not create a model' do

data/lib/spec/shared_examples/simple_crud_for_create_with_build.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for create with build' 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)
+      post :create, params: with_route_params(body_params(params_for(model_class))), format: format_param(:create)
     end
 
     it 'creates the record owned by the current user' do

data/lib/spec/shared_examples/simple_crud_for_destroy.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for destroy' do
     context 'without authenticated user' do
       subject!(:req) do
         delete :destroy, params: with_route_params(record_param(:destroy, nil, not_found: true)),
-                         format: request_format(:destroy)
+                         format: format_param(:destroy)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:destroy)
@@ -17,7 +17,7 @@ RSpec.shared_examples 'simple crud for destroy' do
 
         before do
           make_policies_fail(:destroy)
-          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
         end
 
         it 'fails with forbidden' do
@@ -31,7 +31,7 @@ RSpec.shared_examples 'simple crud for destroy' do
 
       before do
         model
-        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
       end
 
       if check_html(:destroy)
@@ -40,8 +40,8 @@ RSpec.shared_examples 'simple crud for destroy' do
           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)
+        it 'response with the configured status code' do
+          expect(response).to have_http_status(check_status(:destroy) || :ok)
         end
       end
     end
@@ -53,7 +53,7 @@ RSpec.shared_examples 'simple crud for destroy' do
         model
         allow(model).to receive(:destroy).and_return(false)
         allow_any_instance_of(SimpleCrud::DestroyContext).to receive(:find_record).and_return(model)
-        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
       end
 
       it 'keeps the record' do
@@ -77,7 +77,7 @@ RSpec.shared_examples 'simple crud for destroy' do
       before do
         model
         delete :destroy, params: with_route_params(record_param(:destroy, nil, not_found: true)),
-                         format: request_format(:destroy)
+                         format: format_param(:destroy)
       end
 
       it 'responds with not found status' do
@@ -92,7 +92,7 @@ RSpec.shared_examples 'simple crud for destroy' do
         before do
           model
           make_policies_fail(:destroy)
-          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
         end
 
         it 'responds with forbidden status' do

data/lib/spec/shared_examples/simple_crud_for_destroy_with_block.rb

@@ -7,7 +7,7 @@ RSpec.shared_examples 'simple crud for destroy with block' do
     let!(:record) { model }
 
     before do
-      delete :destroy, params: with_route_params(record_param(:destroy, record)), format: request_format(:destroy)
+      delete :destroy, params: with_route_params(record_param(:destroy, record)), format: format_param(:destroy)
     end
 
     it 'passes the destroyed record to the block' do

data/lib/spec/shared_examples/simple_crud_for_destroy_with_finder.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for destroy with finder' do
       before do
         model
         delete :destroy, params: with_route_params(finder_key => model.public_send(finder_key)),
-                         format: request_format(:destroy)
+                         format: format_param(:destroy)
       end
 
       it 'destroys the model' do
@@ -24,8 +24,8 @@ RSpec.shared_examples 'simple crud for destroy with finder' do
           expect(response).to have_http_status(:found)
         end
       else
-        it 'responds with ok status' do
-          expect(response).to have_http_status(:ok)
+        it 'responds with the configured status code' do
+          expect(response).to have_http_status(check_status(:destroy) || :ok)
         end
       end
     end

data/lib/spec/shared_examples/simple_crud_for_edit.rb

@@ -2,7 +2,7 @@
 
 RSpec.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) }
+    subject(:edit_request) { get :edit, params: with_route_params(edit_params), format: format_param(:edit) }
 
     before do
       model
@@ -10,7 +10,7 @@ RSpec.shared_examples 'simple crud for edit' do
 
     context 'without authenticated user' do
       subject!(:req) do
-        get :edit, params: with_route_params(record_param(:edit, model)), format: request_format(:edit)
+        get :edit, params: with_route_params(record_param(:edit, model)), format: format_param(:edit)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:edit)

data/lib/spec/shared_examples/simple_crud_for_index.rb

@@ -14,7 +14,7 @@ RSpec.shared_examples 'simple crud for index' do
 
       before do
         make_policies_succeed(:index) if check_authorize(:index)
-        get :index, params: with_route_params({}), format: request_format(:index)
+        get :index, params: with_route_params({}), format: format_param(:index)
       end
 
       if check_html(:index)
@@ -25,7 +25,7 @@ RSpec.shared_examples 'simple crud for index' do
         end
 
         it 'renders the correct paginated models' do
-          expect(response_body['page'].map { |a| a['id'] }).to eq(model_class_object.all.map(&:id))
+          expect(response_body['page'].map { |a| a['id'] }).to match_array(model_class_object.all.map(&:id))
         end
       else
         it 'renders unpaginated models correctly serialized' do
@@ -33,7 +33,7 @@ RSpec.shared_examples 'simple crud for index' do
         end
 
         it 'renders the correct unpaginated models' do
-          expect(response_body.map { |a| a['id'] }).to eq(model_class_object.all.map(&:id))
+          expect(response_body.map { |a| a['id'] }).to match_array(model_class_object.all.map(&:id))
         end
       end
     end

data/lib/spec/shared_examples/simple_crud_for_index_with_block.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for index with block' do
 
     before do
       created_models
-      get :index, params: with_route_params({}), format: request_format(:index)
+      get :index, params: with_route_params({}), format: format_param(:index)
     end
 
     if check_html(:index)

data/lib/spec/shared_examples/simple_crud_for_index_with_scope.rb

@@ -13,7 +13,7 @@ RSpec.shared_examples 'simple crud for index with scope' do
       make_policies_succeed(:index) if check_authorize(:index)
       my_models
       other_models
-      get :index, params: with_route_params(request_params), format: request_format(:index)
+      get :index, params: with_route_params(request_params), format: format_param(:index)
     end
 
     if check_html(:index)

data/lib/spec/shared_examples/simple_crud_for_nested_resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# For a parent: controller. The parent in route_params must match the record's owner_association.
+RSpec.shared_examples 'simple crud for nested resource' do
+  describe 'parent: scoping' do
+    include_context 'with authenticated user' if check_authenticate(:show)
+
+    it 'finds a record inside the parent' do
+      get :show, params: with_route_params(record_param(:show, model)), format: format_param(:show)
+
+      expect(response).to have_http_status(:ok)
+    end
+
+    it 'returns not found for a record outside the parent' do
+      outside = create_record(model_class, model_attributes.merge(owner_association => other_user))
+      get :show, params: with_route_params(record_param(:show, outside)), format: format_param(:show)
+
+      expect(response).to have_http_status(:not_found)
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_new.rb

@@ -10,7 +10,7 @@ RSpec.shared_examples 'simple crud for new' do
 
       before do
         make_policies_succeed(:new) if check_authorize(:new)
-        get :new, params: with_route_params({}), format: request_format(:new)
+        get :new, params: with_route_params({}), format: format_param(:new)
       end
 
       it 'responds with ok status' do

data/lib/spec/shared_examples/simple_crud_for_new_with_block.rb

@@ -6,7 +6,7 @@ RSpec.shared_examples 'simple crud for new with block' do
 
     before do
       make_policies_succeed(:new) if check_authorize(:new)
-      get :new, params: with_route_params({}), format: request_format(:new)
+      get :new, params: with_route_params({}), format: format_param(:new)
     end
 
     if check_html(:new)

data/lib/spec/shared_examples/simple_crud_for_new_with_build.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for new with build' do
     include_context 'with authenticated user' if check_authenticate(:new)
 
     before do
-      get :new, params: with_route_params({}), format: request_format(:new)
+      get :new, params: with_route_params({}), format: format_param(:new)
     end
 
     it 'builds the record owned by the current user', :aggregate_failures do

data/lib/spec/shared_examples/simple_crud_for_owned_resource.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Include alongside the per-action examples for a controller using owned_by:.
+RSpec.shared_examples 'simple crud for owned resource' do
+  describe 'owned_by: scoping' do
+    include_context 'with authenticated user'
+
+    let!(:someone_elses_model) do
+      create_record(model_class, model_attributes.merge(owner_association => other_user))
+    end
+
+    it 'returns not found for a record owned by another user' do
+      get :show, params: with_route_params(record_param(:show, someone_elses_model)), format: format_param(:show)
+
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it 'ignores an attempt to update a record owned by another user', :aggregate_failures do
+      params = with_route_params(record_param(:update, someone_elses_model)).merge(body_params(model_params))
+      patch :update, params: params, format: format_param(:update)
+
+      expect(response).to have_http_status(:not_found)
+      expect(someone_elses_model.reload.public_send(required_attribute))
+        .not_to eq(model_params[required_attribute])
+    end
+
+    it 'attributes a created record to the current user regardless of the request', :aggregate_failures do
+      body = body_params(model_params.merge(owner_association => other_user.id))
+      post :create, params: with_route_params(body), format: format_param(:create)
+
+      expect(response).to have_http_status(check_status(:create) || :created)
+      expect(model_class_object.last.public_send(owner_association)).to eq(current_user)
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_show.rb

@@ -2,14 +2,14 @@
 
 RSpec.shared_examples 'simple crud for show' do
   describe 'GET #show' do
-    subject(:show_request) { get :show, params: with_route_params(show_params), format: request_format(:show) }
+    subject(:show_request) { get :show, params: with_route_params(show_params), format: format_param(:show) }
 
     before do
       model
     end
 
     context 'without authenticated user' do
-      subject!(:req) { get :show, params: with_route_params(record_param(:show, model)), format: request_format(:show) }
+      subject!(:req) { get :show, params: with_route_params(record_param(:show, model)), format: format_param(:show) }
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:show)
     end

data/lib/spec/shared_examples/simple_crud_for_show_with_block.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for show with block' do
 
     before do
       make_policies_succeed(:show) if check_authorize(:show)
-      get :show, params: with_route_params(record_param(:show, record)), format: request_format(:show)
+      get :show, params: with_route_params(record_param(:show, record)), format: format_param(:show)
     end
 
     if check_html(:show)

data/lib/spec/shared_examples/simple_crud_for_show_with_finder.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for show with finder' do
       before do
         model
         get :show, params: with_route_params(finder_key => model.public_send(finder_key)),
-                   format: request_format(:show)
+                   format: format_param(:show)
       end
 
       if check_block(:show)

data/lib/spec/shared_examples/simple_crud_for_update.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for update' do
     context 'without authenticated user' do
       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)
+        put :update, params: with_route_params(update_params), format: format_param(:update)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:update)
@@ -18,7 +18,7 @@ RSpec.shared_examples 'simple crud for update' do
         before do
           make_policies_fail(:update)
           put :update, params: with_route_params(body_params(model_params).merge(record_param(:update, model))),
-                       format: request_format(:update)
+                       format: format_param(:update)
         end
 
         it 'fails with forbidden' do
@@ -34,7 +34,7 @@ RSpec.shared_examples 'simple crud for update' do
 
       before do
         model
-        put :update, params: with_route_params(update_params), format: request_format(:update)
+        put :update, params: with_route_params(update_params), format: format_param(:update)
       end
 
       if check_html(:update)
@@ -42,8 +42,8 @@ RSpec.shared_examples 'simple crud for update' do
           expect(response).to have_http_status(:found)
         end
       else
-        it 'response with 200 status code' do
-          expect(response).to have_http_status(:ok)
+        it 'response with the configured status code' do
+          expect(response).to have_http_status(check_status(:update) || :ok)
         end
 
         it 'updates an model' do
@@ -66,7 +66,7 @@ RSpec.shared_examples 'simple crud for update' do
 
       before do
         put :update, params: with_route_params(record_param(:update, nil, not_found: true)),
-                     format: request_format(:update)
+                     format: format_param(:update)
       end
 
       it 'response with 404 status code' do
@@ -86,7 +86,7 @@ RSpec.shared_examples 'simple crud for update' 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)
+                       format: format_param(:update)
         end
 
         unless check_block(:update)

data/lib/spec/shared_examples/simple_crud_for_update_with_finder.rb

@@ -12,7 +12,7 @@ RSpec.shared_examples 'simple crud for update with finder' do
 
       before do
         model
-        put :update, params: update_params, format: request_format(:update)
+        put :update, params: update_params, format: format_param(:update)
       end
 
       it 'updates the model' do

data/lib/spec/shared_examples/simple_crud_not_found_with_finder.rb

@@ -4,7 +4,7 @@ RSpec.shared_examples 'simple crud not found with finder' do |http_method, actio
   context 'when the model does not exist' do
     before do
       send(http_method, action, params: with_route_params(finder_key => "nonexistent-#{finder_key}"),
-                                format: request_format(action))
+                                format: format_param(action))
     end
 
     it 'responds with not found status' do

data/spec/blueprint/dummy_models_controller_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Blueprint::DummyModelsController, type: :controller do
+  let(:serializer) { DummyModelBlueprint }
+
+  include_examples 'simple crud for index'
+  include_examples 'simple crud for show'
+  include_examples 'simple crud for create'
+  include_examples 'simple crud for update'
+  include_examples 'simple crud for destroy'
+
+  describe 'GET #show' do
+    include_context 'with authenticated user'
+
+    let!(:record) { create(:dummy_model, user: current_user) }
+
+    it 'passes serializer_options to the blueprint' do
+      get :show, params: { id: record.id }
+
+      expect(response.parsed_body['url']).to eq(dummy_model_url(record))
+    end
+  end
+end