rails_api_kit 1.0.0

data/spec/errors_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+RSpec.describe NotesController, type: :request do
+  describe "PUT /notes/:id" do
+    let(:note) { create_note }
+    let(:note_id) { note.id }
+    let(:user) { note.user }
+    let(:user_id) { user.id }
+    let(:note_params) do
+      {
+        note: {
+          title: FFaker::Company.name,
+          user_id: user_id
+        }
+      }
+    end
+    let(:params) { note_params }
+
+    before do
+      put(note_path(note_id), params: params.to_json, headers: api_headers)
+    end
+
+    it 'renders single' do
+      expect(response).to have_http_status(:ok)
+      expect(response_json["data"]["id"]).to eql(note.id)
+      expect(response_json["meta"]).to eq("single" => true)
+    end
+
+    context "with a missing parameter in the payload" do
+      let(:params) { {} }
+
+      it do
+        expect(response).to have_http_status(:unprocessable_content)
+        expect(response_json["errors"].size).to eq(1)
+        expect(response_json["errors"][0]["status"]).to eq("422")
+        expect(response_json["errors"][0]["title"]).to eq('Unprocessable Content')
+        expect(response_json["errors"][0]["detail"]).to eq("Required parameter missing or invalid")
+      end
+    end
+
+    context "with an invalid payload" do
+      let(:params) do
+        payload = note_params.dup
+        payload[:note][:user_id] = nil
+        payload
+      end
+
+      it 'with invalid user id' do
+        expect(response).to have_http_status(:unprocessable_content)
+        expect(response_json["errors"].size).to eq(1)
+        expect(response_json["errors"][0]["status"]).to eq("422")
+        expect(response_json["errors"][0]["code"]).to include("blank")
+        expect(response_json["errors"][0]["title"]).to eq('Error')
+        expect(response_json["errors"][0]["detail"]).to eq("User must exist")
+        expect(response_json["errors"][0]["attribute"]).to eq("user")
+      end
+
+      context "required by validations" do
+        let(:params) do
+          payload = note_params.dup
+          payload[:note][:title] = "BAD_TITLE"
+          payload[:note][:quantity] = 100 + rand(10)
+          payload
+        end
+
+        it 'multiple errors' do
+          expect(response).to have_http_status(:unprocessable_content)
+          expect(response_json["errors"].size).to eq(3)
+
+          expect(response_json["errors"][0]["status"]).to eq("422")
+          expect(response_json["errors"][0]["code"]).to include("invalid")
+          expect(response_json["errors"][0]["title"]).to eq('Error')
+          expect(response_json["errors"][0]["detail"]).to eq("Title is invalid")
+
+          expect(response_json["errors"][1]["status"]).to eq("422")
+          expect(response_json["errors"][1]["code"]).to eq("less_than")
+          expect(response_json["errors"][1]["title"]).to eq('Error')
+          expect(response_json["errors"][1]["detail"]).to eq("Quantity must be less than 100")
+
+          expect(response_json["errors"][2]["status"]).to eq("422")
+          expect(response_json["errors"][2]["code"]).to eq("invalid")
+          expect(response_json["errors"][2]["title"]).to eq('Error')
+          expect(response_json["errors"][2]["detail"]).to eq("Title has typos")
+        end
+      end
+
+      context "as a param attribute" do
+        let(:params) do
+          payload = note_params.dup
+          payload[:note].delete(:title)
+          payload
+        end
+
+        it do
+          expect(response).to have_http_status(:success)
+        end
+      end
+    end
+
+    context "with a bad note ID" do
+      let(:user_id) { nil }
+      let(:note_id) { rand(10) }
+
+      it do
+        expect(response).to have_http_status(:not_found)
+        expect(response_json["errors"].size).to eq(1)
+        expect(response_json["errors"][0]["status"]).to eq("404")
+        expect(response_json["errors"][0]["title"]).to eq(Rack::Utils::HTTP_STATUS_CODES[404])
+        expect(response_json["errors"][0]["detail"]).to eq("Resource not found")
+      end
+    end
+
+    context "with an exception" do
+      let(:user_id) { nil }
+      let(:note_id) { "tada" }
+
+      it do
+        expect(response).to have_http_status(:internal_server_error)
+        expect(response_json["errors"].size).to eq(1)
+        expect(response_json["errors"][0]["status"]).to eq("500")
+        expect(response_json["errors"][0]["title"]).to eq(Rack::Utils::HTTP_STATUS_CODES[500])
+        expect(response_json["errors"][0]["detail"]).to eql("tada")
+      end
+    end
+  end
+end

data/spec/fetching_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+RSpec.describe UsersController, type: :request do
+  describe 'GET /users' do
+    let!(:user) { }
+    let(:params) { }
+
+    before do
+      get(users_path, params: params, headers: api_headers)
+    end
+
+    context 'with users' do
+      let(:first_user) { create_user }
+      let(:second_user) { create_user }
+      let(:third_user) { create_note.user }
+      let(:users) { [ first_user, second_user, third_user ] }
+      let(:user) { users.last }
+      let(:note) { third_user.notes.first }
+
+      context 'returns customers and dasherized first name' do
+        let(:params) do
+          { upcase: :yes, fields: [ :first_name ] }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(users.size)
+
+          response_json['data'].each do |item|
+            user = users.detect { |u| u.id == item['id'].to_i }
+            expect(item['first_name']).to eql(user.first_name.upcase)
+          end
+        end
+      end
+
+      context 'returns customers and full name' do
+        let(:params) do
+          { fields:  { user: 'id,full_name' } }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(users.size)
+
+          response_json['data'].each do |item|
+            user = users.detect { |u| u.id == item['id'].to_i }
+            full_name = "#{user.first_name} #{user.last_name}"
+            expect(item['full_name']).to eql(full_name)
+          end
+        end
+      end
+
+      context 'returns customers included and sparse fields' do
+        let(:params) do
+          {
+            include: 'notes',
+            fields:  { note: 'title,updated_at' }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].last.keys).not_to include('custom_note')
+          expect(response_json['data'].last['notes'].size).to eql(1)
+          expect(response_json['data'].last['notes'][0]).to eql({
+            'title' => note.title,
+            'updated_at' => note.updated_at.as_json
+          })
+        end
+      end
+
+      context 'returns customers included runtime structs' do
+        let(:params) do
+          {
+            include: 'custom_note',
+            fields:  { custom_note: 'title,updated_at' }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data']).to all(include('custom_note'))
+          expect(response_json['data'].first['custom_note']).to include('title' => "My", 'quantity' => 1)
+        end
+      end
+    end
+  end
+
+  describe 'GET /users/:id' do
+    let(:note) { create_note }
+    let(:user) { note.user }
+    let(:params) { }
+
+    before do
+      get(user_path(user), params: params, headers: api_headers)
+    end
+
+    context 'with users' do
+      context 'returns user' do
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data']['id']).to eq(user.id)
+          expect(response_json['data']['first_name']).to eq(user.first_name)
+          expect(response_json['data']['last_name']).to eq(user.last_name)
+          expect(response_json['data'].keys).not_to include('notes')
+        end
+      end
+
+      context 'returns customers first name and notes id' do
+        let(:params) do
+          {
+            include: 'notes',
+            fields: { user: 'first_name', note: 'id' }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data']).to eq({ "first_name" => user.first_name, "notes" => [ { "id" => note.id } ] })
+        end
+      end
+
+      context 'returns user attributes with and notes id' do
+        let(:params) do
+          {
+            include: 'notes',
+            fields: { note: 'id' }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json.dig('data', 'id')).to eq(user.id)
+          expect(response_json.dig('data', 'first_name')).to eq(user.first_name)
+          expect(response_json.dig('data', 'last_name')).to eq(user.last_name)
+          expect(response_json.dig('data', 'notes', 0, 'id')).to eq(note.id)
+        end
+      end
+
+      context 'returns customers first name and notes id' do
+        let(:params) do
+          { fields: { user: 'first_name' } }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data']).to eq({ "first_name" => user.first_name })
+        end
+      end
+
+      context 'returns customers included and sparse fields' do
+        let(:params) do
+          {
+            include: 'notes',
+            fields:  { note: 'title,updated_at' }
+          }
+        end
+
+        it 'should render notes with user' do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].keys.size).to eql(7)
+          expect(response_json['data']['notes'].size).to eql(1)
+          expect(response_json['data']['notes'][0]).to eql({
+            'title' => note.title,
+            'updated_at' => note.updated_at.as_json
+          })
+        end
+      end
+    end
+  end
+end

data/spec/filtering_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+RSpec.describe UsersController, type: :request do
+  describe '#extract_attributes_and_predicate' do
+    context 'mixed attributes (and/or)' do
+      it 'extracts ANDs' do
+        attributes, predicates = ApiKit::Filtering
+          .extract_attributes_and_predicates('attr1_and_attr2_eq')
+        expect(attributes).to eq([ 'attr1', 'attr2' ])
+        expect(predicates.size).to eq(1)
+        expect(predicates[0].name).to eq('eq')
+      end
+    end
+
+    context 'mixed predicates' do
+      it 'extracts in order' do
+        attributes, predicates = ApiKit::Filtering
+          .extract_attributes_and_predicates('attr1_sum_eq')
+        expect(attributes).to eq([ 'attr1' ])
+        expect(predicates.size).to eq(2)
+        expect(predicates[0].name).to eq('sum')
+        expect(predicates[1].name).to eq('eq')
+      end
+    end
+  end
+
+  describe 'GET /users' do
+    let!(:user) { }
+    let(:params) { }
+
+    before do
+      get(users_path, params: params, headers: api_headers)
+    end
+
+    context 'with users' do
+      let(:first_user) { create_user }
+      let(:second_user) { create_note.user }
+      let(:third_user) { create_user }
+      let(:users) { [ first_user, second_user, third_user ] }
+      let(:user) { users.last }
+
+      context 'returns filtered users' do
+        let(:params) do
+          {
+            filter: {
+              last_name_or_first_name_cont_any: (
+                "#{third_user.first_name[0..5]}%,#{self.class.name}"
+              )
+            }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(1)
+          expect(response_json['data'][0]['id']).to eql(third_user.id)
+        end
+
+        context 'with a comma' do
+          let(:params) do
+            third_user.update(first_name: third_user.first_name + ',')
+
+            {
+              filter: { first_name_eq: third_user.first_name }
+            }
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(1)
+            expect(response_json['data'][0]['id']).to eql(third_user.id)
+          end
+        end
+      end
+
+      context 'returns sorted users by notes quantity sum' do
+        let(:params) do
+          { sort: '-notes_quantity_sum' }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(3)
+          expect(response_json['data'][0]['id']).to eql(second_user.id)
+        end
+      end
+
+      context 'returns sorted users by notes' do
+        let(:params) do
+          { sort: '-notes_created_at' }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(3)
+          expect(response_json['data'][0]['id']).to eql(second_user.id)
+        end
+      end
+    end
+  end
+end