wor-simple_crud 0.2.1

data/lib/spec/matchers/have_been_serialized_with.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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|
+    [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)
+    end
+  end
+
+  failure_message do |json_response|
+    "expected attributes of #{serializer} serializer to be included in #{json_response}"
+  end
+
+  failure_message_when_negated do |json_response|
+    "expected attributes of #{serializer} serializer not to be included in #{json_response}"
+  end
+
+  description do
+    "checks to see if all the serializer's attributes are in the JSON response"
+  end
+
+  def all_attributes_included?(attributes, json_response)
+    attributes.all? do |attribute|
+      json_response.key?(attribute.to_s) || json_response.key?(attribute.to_sym)
+    end
+  end
+end

data/lib/spec/response_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Response
+  # Parses the last response body as JSON.
+  module JSONParser
+    def response_body
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/spec/shared_contexts/authenticate_user.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'with authenticated user' do
+  let(:current_user) { create(:user) }
+
+  before do
+    headers = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+    auth_headers = Devise::JWT::TestHelpers.auth_headers(headers, current_user)
+    request.headers.merge!(auth_headers)
+  end
+end

data/lib/spec/shared_examples/helpers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+def get_option(method, option)
+  described_class.instance_variable_get(:@simple_crud_metadata)[method][option]
+end
+
+%i[paginate authorize authenticate serializer].each do |option|
+  define_method("check_#{option}") do |method|
+    get_option(method, option)
+  end
+end
+
+def model_class
+  described_class.to_s.split('::')
+                 .last.sub('Controller', '').singularize.underscore
+end
+
+def model_serializer
+  defined?(serializer) ? serializer : "#{model.class}_serializer".classify.constantize
+end
+
+def model
+  @model ||= create(model_class, **model_attributes)
+end
+
+def model_attributes
+  respond_to?(:current_user) ? { user: current_user } : {}
+end
+
+def model_class_object
+  model_class.classify.constantize
+end
+
+def policy_class_object
+  "#{model_class_object}Policy".classify.constantize
+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 model_params
+  @model_params ||= attributes_for(model_class)
+end

data/lib/spec/shared_examples/simple_crud_for_create.rb

@@ -0,0 +1,49 @@
+# 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) }
+
+      include_examples 'unauthorized when not logged in' if check_authenticate(:create)
+    end
+
+    if check_authorize(:create)
+      context 'when not authorized' do
+        include_context 'with authenticated user' if check_authenticate(:create)
+
+        before do
+          make_policies_fail(:create)
+          post :create, params: model_params
+        end
+
+        it 'fails with forbidden' do
+          expect(response).to have_http_status(:forbidden)
+        end
+      end
+    end
+
+    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) }
+
+      before do
+        post :create, params: create_params
+      end
+
+      it 'response with 200 status code' do
+        expect(response).to have_http_status(:created)
+      end
+
+      it 'creates an article' do
+        expect(model_class_object.count).to be 1
+      end
+
+      it 'creates an article with valid attributes' do
+        expect(model_class_object.last).to have_attributes(create_params)
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_destroy.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for destroy' do
+  describe 'DELETE #destroy' do
+    context 'without authenticated user' do
+      subject!(:req) { delete :destroy, params: { id: 1 } }
+
+      include_examples 'unauthorized when not logged in' if check_authenticate(:destroy)
+    end
+
+    if check_authorize(:destroy)
+      context 'when not authorized' do
+        include_context 'with authenticated user' if check_authenticate(:destroy)
+
+        before do
+          make_policies_fail(:destroy)
+          delete :destroy, params: { id: model.id }
+        end
+
+        it 'fails with forbidden' do
+          expect(response).to have_http_status(:forbidden)
+        end
+      end
+    end
+
+    context 'when ID is valid' do
+      include_context 'with authenticated user' if check_authenticate(:destroy)
+
+      before do
+        model
+        delete :destroy, params: { id: model.id }
+      end
+
+      it 'response with 200 status code' do
+        expect(response).to have_http_status(:ok)
+      end
+    end
+
+    context 'when ID is invalid' do
+      include_context 'with authenticated user' if check_authenticate(:destroy)
+
+      before do
+        model
+        delete :destroy, params: { id: model.id + 13 }
+      end
+
+      it 'responds with not found status' do
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+
+    if check_authorize(:destroy)
+      context 'when ID is valid but user isn\'t authorized' do
+        include_context 'with authenticated user' if check_authenticate(:destroy)
+
+        before do
+          model
+          make_policies_fail(:destroy)
+          delete :destroy, params: { id: model.id }
+        end
+
+        it 'response with 200 status code' do
+          expect(response).to have_http_status(:forbidden)
+        end
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_index.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for index' do
+  describe 'GET #index' do
+    let(:created_models) { create_list(model_class, 10) }
+
+    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
+
+    context 'with authenticated user' do
+      include_context 'with authenticated user' if check_authenticate(:index)
+      before do
+        make_policies_succeed(:index)
+        get :index
+      end
+
+      if check_paginate(:index)
+        it 'renders paginated models correctly serialized' do
+          expect(response_body['page']).to have_been_serialized_with(model_serializer)
+        end
+
+        it 'renders the correct paginated models' do
+          expect(response_body['page'].map { |a| a['id'] }).to eq(model_class_object.all.map(&:id))
+        end
+      else
+        it 'renders unpaginated models correctly serialized' do
+          expect(response_body).to have_been_serialized_with(model_serializer)
+        end
+
+        it 'renders the correct unpaginated models' do
+          expect(response_body.map { |a| a['id'] }).to eq(model_class_object.all.map(&:id))
+        end
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/simple_crud_for_show.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+shared_examples 'simple crud for show' do
+  describe 'GET #show' do
+    subject(:show_request) { get :show, params: show_params }
+
+    before do
+      model
+    end
+
+    context 'without authenticated user' do
+      subject!(:req) { get :show, params: { id: model.id } }
+
+      include_examples 'unauthorized when not logged in'
+    end
+
+    describe 'when the model exists' do
+      include_context 'with authenticated user'
+      let(:show_params) { { id: model.id } }
+
+      before do
+        show_request
+      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
+
+      it 'have been serializer with model Serializer' do
+        expect(response_body).to have_been_serialized_with(model_serializer)
+      end
+    end
+
+    describe 'when the model does not exist' do
+      include_context 'with authenticated user'
+      let(:show_params) { { id: -1 } }
+
+      before do
+        show_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_update.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+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) }
+
+      include_examples 'unauthorized when not logged in'
+    end
+
+    if check_authorize(:update)
+      context 'when not authorized' do
+        include_context 'with authenticated user' if check_authenticate(:update)
+
+        before do
+          make_policies_fail(:update)
+          put :update, params: model_params.merge(id: model.id)
+        end
+
+        it 'fails with forbidden' do
+          expect(response).to have_http_status(:forbidden)
+        end
+      end
+    end
+
+    context 'when successfully updating an model' do
+      include_context 'with authenticated user'
+
+      before do
+        model
+        put :update, params: model_params.merge(id: model.id)
+      end
+
+      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 with valid attributes' do
+        expect(model_class.classify.constantize.last).to have_attributes(model_params)
+      end
+    end
+
+    context 'when updating a model that doesn\'t exist' do
+      include_context 'with authenticated user'
+
+      before { put :update, params: { id: 1 } }
+
+      it 'response with 422 status code' do
+        expect(response).to have_http_status(:not_found)
+      end
+
+      it 'doesn\'t create an model' do
+        expect(model_class_object.count).to be 0
+      end
+    end
+  end
+end

data/lib/spec/shared_examples/unauthorized_when_not_logged_in.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+shared_examples 'unauthorized when not logged in' do
+  context 'when the user is not logged in' do
+    it 'returns status code unauthorized' do
+      req
+      expect(response).to have_http_status(:unauthorized)
+    end
+  end
+end

data/pull_request_template.md

@@ -0,0 +1,3 @@
+## Summary
+
+[Change!] Describe your feature, problems you had, notes, improvements and others.

data/spec/dummy/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,6 @@
+// app/assets/config/manifest.js
+//
+//= link application.css
+//= link marketing.css
+//
+//= link application.js

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'pagy'
+
+class ApplicationController < ActionController::Base
+  # :unprocessable_entity was renamed :unprocessable_content in Rack 3.1.
+  # Older Rack (bundled with Rails 6.1/7.0) doesn't recognize the new name.
+  UNPROCESSABLE_STATUS = if Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(:unprocessable_content)
+                           :unprocessable_content
+                         else
+                           :unprocessable_entity
+                         end
+
+  protect_from_forgery with: :exception
+  include Wor::Paginate
+  include Pagy::Method
+  include ActionController::MimeResponds
+  respond_to :json
+  # i18n configuration. See: http://guides.rubyonrails.org/i18n.html
+  rescue_from ActiveRecord::RecordNotFound, with: :not_found
+  rescue_from ActiveRecord::StatementInvalid, with: :unprocessable
+  rescue_from ActiveRecord::RecordInvalid, with: :unprocessable
+  rescue_from ActionController::ParameterMissing, with: :unprocessable
+  rescue_from Pundit::NotAuthorizedError, with: :forbidden
+  # TODO: find a less general way to catch wrong enum values
+  rescue_from ArgumentError, with: :unprocessable
+  def not_found(_exception)
+    head :not_found
+  end
+
+  def unprocessable(exception)
+    render json: { errors: exception }, status: UNPROCESSABLE_STATUS
+  end
+
+  def forbidden(exception)
+    render json: { errors: exception }, status: :forbidden
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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 :create
+  simple_crud_for :destroy
+  simple_crud_for :update
+  simple_crud_for :show
+  simple_crud_for :index
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module WithoutPagination
+  class DummyModelsController < ApplicationController
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    before_action :set_params
+    def set_params
+      SimpleCrudController.params = params
+    end
+
+    simple_crud_for :index, paginate: false
+  end
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/spec/dummy/app/models/dummy_model.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'dummy_model_policy'
+class DummyModel < ApplicationRecord
+  belongs_to :user
+  validates :name, presence: true
+end

data/spec/dummy/app/models/dummy_model_policy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class DummyModelPolicy
+  attr_reader :user, :dummy_model
+
+  def initialize(user, dummy_model)
+    @user = user
+    @dummy_model = dummy_model
+  end
+
+  def check_user
+    user == dummy_model.user
+  end
+
+  def show?
+    check_user
+  end
+
+  def update?
+    check_user
+  end
+
+  def create?
+    check_user
+  end
+
+  def destroy?
+    check_user
+  end
+
+  def index?
+    check_user
+  end
+end

data/spec/dummy/app/models/user.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class User < ApplicationRecord
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :validatable, :jwt_authenticatable,
+         jwt_revocation_strategy: Devise::JWT::RevocationStrategies::Null
+
+  has_many :dummy_models
+end

data/spec/dummy/app/serializers/dummy_model_serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DummyModelSerializer < ActiveModel::Serializer
+  attributes :something, :id, :user_id
+end

data/spec/dummy/bin/bundle

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+APP_PATH = File.expand_path('../config/application', __dir__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/spec/dummy/bin/setup

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+require 'fileutils'
+
+# path to your application root.
+APP_ROOT = Pathname.new File.expand_path('..', __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a starting point to setup your application.
+  # Add necessary setup steps to this file.
+
+  puts '== Installing dependencies =='
+  system! 'gem install bundler --conservative'
+  system('bundle check') || system!('bundle install')
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?('config/database.yml')
+  #   cp 'config/database.yml.sample', 'config/database.yml'
+  # end
+
+  puts "\n== Preparing database =="
+  system! 'bin/rails db:setup'
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! 'bin/rails log:clear tmp:clear'
+
+  puts "\n== Restarting application server =="
+  system! 'bin/rails restart'
+end

data/spec/dummy/bin/update

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+require 'fileutils'
+
+# path to your application root.
+APP_ROOT = Pathname.new File.expand_path('..', __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to update your development environment automatically.
+  # Add necessary update steps to this file.
+
+  puts '== Installing dependencies =='
+  system! 'gem install bundler --conservative'
+  system('bundle check') || system!('bundle install')
+
+  puts "\n== Updating database =="
+  system! 'bin/rails db:migrate'
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! 'bin/rails log:clear tmp:clear'
+
+  puts "\n== Restarting application server =="
+  system! 'bin/rails restart'
+end