infinum_json_api_setup 0.0.7 → 0.1.0

data/spec/infinum_json_api_setup/rspec/helpers/response_helper_spec.rb

@@ -0,0 +1,234 @@
+describe InfinumJsonApiSetup::Rspec::Helpers::ResponseHelper do
+  include described_class
+
+  let(:response) { instance_double('Response', body: JSON.dump(payload)) } # rubocop:disable RSpec/RSpec/VerifiedDoubleReference
+
+  describe '#json_response' do
+    let(:payload) do
+      {
+        data: {
+          id: '1',
+          type: 'locations',
+          attributes: { name: 'Downtown HQ' }
+        }
+      }
+    end
+
+    it 'parses the response body with symbolized keys' do
+      expect(json_response).to eq(payload)
+    end
+  end
+
+  describe '#response_item' do
+    context 'when the response contains a single resource' do
+      let(:payload) do
+        {
+          data: {
+            id: '1',
+            type: 'locations',
+            attributes: { name: 'Downtown HQ', city: 'Zagreb' }
+          }
+        }
+      end
+
+      it 'returns an OpenStruct built from the resource attributes' do
+        expect(response_item).to have_attributes(name: 'Downtown HQ', city: 'Zagreb')
+      end
+    end
+
+    context 'when the response contains a collection' do
+      let(:payload) do
+        {
+          data: [
+            { id: '1', type: 'locations', attributes: { name: 'Downtown HQ' } }
+          ]
+        }
+      end
+
+      it 'raises an informative error' do
+        expect { response_item }.to raise_error('json response is not an item')
+      end
+    end
+  end
+
+  describe '#response_collection' do
+    context 'when the response contains a collection' do
+      let(:payload) do
+        {
+          data: [
+            { id: '1', type: 'locations', attributes: { name: 'Downtown HQ' } },
+            { id: '2', type: 'locations', attributes: { name: 'Suburb Office' } }
+          ]
+        }
+      end
+
+      it 'wraps each resource in an OpenStruct including id and type' do
+        expect(response_collection).to contain_exactly(
+          have_attributes(id: '1', type: 'locations', name: 'Downtown HQ'),
+          have_attributes(id: '2', type: 'locations', name: 'Suburb Office')
+        )
+      end
+    end
+
+    context 'when the response contains a single resource' do
+      let(:payload) do
+        {
+          data: {
+            id: '1',
+            type: 'locations',
+            attributes: { name: 'Downtown HQ' }
+          }
+        }
+      end
+
+      it 'raises an informative error' do
+        expect { response_collection }.to raise_error('json response is not a collection')
+      end
+    end
+  end
+
+  describe '#response_relationships' do
+    context 'when the response contains a single resource' do
+      let(:payload) do
+        {
+          data: {
+            relationships: {
+              label: { data: { id: '2', type: 'location_labels' } }
+            }
+          }
+        }
+      end
+
+      it 'returns the relationships hash for the primary resource' do
+        expect(response_relationships).to eq(payload[:data][:relationships])
+      end
+    end
+
+    context 'when the response contains a collection' do
+      let(:payload) do
+        {
+          data: [
+            { relationships: { label: { data: { id: '2', type: 'location_labels' } } } },
+            { relationships: { label: { data: { id: '3', type: 'location_labels' } } } }
+          ]
+        }
+      end
+
+      it 'returns the relationships for each resource' do
+        expect(response_relationships(response_type: :collection)).to eq(
+          payload[:data].pluck(:relationships)
+        )
+      end
+    end
+
+    context 'when an unsupported response type is requested' do
+      let(:payload) do
+        {
+          data: {
+            relationships: {
+              label: { data: { id: '2', type: 'location_labels' } }
+            }
+          }
+        }
+      end
+
+      it 'raises an argument error' do
+        expect { response_relationships(response_type: :unknown) }
+          .to raise_error(ArgumentError, ':response_type must be one of [:item, :collection]')
+      end
+    end
+  end
+
+  describe '#response_meta' do
+    let(:payload) do
+      {
+        data: {},
+        meta: { current_page: 2, total_pages: 5 }
+      }
+    end
+
+    it 'returns the meta section of the response' do
+      expect(response_meta).to eq(payload[:meta])
+    end
+  end
+
+  describe '#response_included' do
+    let(:payload) do
+      {
+        data: {},
+        included: [
+          {
+            id: '2',
+            type: 'location_labels',
+            attributes: { name: 'HQ Label' }
+          }
+        ]
+      }
+    end
+
+    it 'returns included resources as OpenStruct instances' do
+      expect(response_included.first).to have_attributes(id: '2', type: 'location_labels', name: 'HQ Label')
+    end
+  end
+
+  describe '#response_included_relationship' do
+    context 'when the relationship exists in the included section' do
+      let(:payload) do
+        {
+          data: {
+            relationships: {
+              label: { data: { id: '2', type: 'location_labels' } }
+            }
+          },
+          included: [
+            {
+              id: '2',
+              type: 'location_labels',
+              attributes: { name: 'HQ Label' }
+            }
+          ]
+        }
+      end
+
+      it 'returns the matching included resource' do
+        result = response_included_relationship(:label)
+
+        expect(result).to have_attributes(id: '2', type: 'location_labels', name: 'HQ Label')
+      end
+    end
+
+    context 'when the relationship data is nil' do
+      let(:payload) do
+        {
+          data: {
+            relationships: {
+              label: { data: nil }
+            }
+          },
+          included: []
+        }
+      end
+
+      it 'returns nil' do
+        expect(response_included_relationship(:label)).to be_nil
+      end
+    end
+
+    context 'when no matching included resource is present' do
+      let(:payload) do
+        {
+          data: {
+            relationships: {
+              label: { data: { id: '99', type: 'location_labels' } }
+            }
+          },
+          included: []
+        }
+      end
+
+      it 'returns nil' do
+        expect(response_included_relationship(:label)).to be_nil
+      end
+    end
+  end
+end

data/spec/infinum_json_api_setup/rspec/matchers/have_empty_data_spec.rb

@@ -12,11 +12,12 @@ describe InfinumJsonApiSetup::RSpec::Matchers::HaveEmptyData do
 
     context "when data isn't empty" do
       it 'fails and describes failure reason' do
-        response = response_with_body(JSON.dump(data: { a: 1 }))
+        data = { 'a' => 1 }
+        response = response_with_body(JSON.dump(data:))
 
         expect do
           expect(response).to have_empty_data
-        end.to fail_with("Expected response data({\"a\"=>1}) to be empty, but isn't")
+        end.to fail_with("Expected response data(#{data}) to be empty, but isn't")
       end
     end
 

data/spec/rails_helper.rb

@@ -27,20 +27,16 @@ require 'pundit'
 # directory. Alternatively, in the individual `*_spec.rb` files, manually
 # require only the support files necessary.
 #
-Dir[File.expand_path('support/**/*.rb', __dir__)].sort.each { |f| require f }
+Dir[File.expand_path('support/**/*.rb', __dir__)].each { |f| require f }
 
 # Checks for pending migrations and applies them before tests are run.
 # If you are not using ActiveRecord, you can remove these lines.
 begin
   ActiveRecord::Migration.maintain_test_schema!
 rescue ActiveRecord::PendingMigrationError => e
-  puts e.to_s.strip
-  exit 1
+  abort e.to_s.strip
 end
 RSpec.configure do |config|
-  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = "#{::Rails.root}/spec/fixtures"
-
   # If you're not using ActiveRecord, or you'd prefer not to run each of your
   # examples within a transaction, remove the following line or assign false
   # instead of true.

data/spec/requests/api/v1/content_negotiation_spec.rb

@@ -1,10 +1,18 @@
-describe 'Content negotiation', type: :request do
+describe 'Content negotiation' do
   it 'passes through requests demanding JSON:API compliant response' do
     get '/api/v1/locations', headers: { accept: 'application/vnd.api+json' }
 
     expect(response).to have_http_status(:ok)
   end
 
+  it 'passes through requests containing JSON:API compliant body' do
+    post '/api/v1/locations', params: { location: { latitude: 1, longitude: 1 } }.to_json,
+                              headers: { accept: 'application/vnd.api+json',
+                                         'content-type': 'application/vnd.api+json; charset=utf-8' }
+
+    expect(response).to have_http_status(:created)
+  end
+
   it 'responds with 406 NotAcceptable to requests demanding non JSON:API compliant reponse' do
     get '/api/v1/locations', headers: { accept: 'application/json' }
 
@@ -12,7 +20,7 @@ describe 'Content negotiation', type: :request do
   end
 
   it 'responds with 415 UnsupportedMediaType to requests containing non JSON:API compliant body' do
-    post '/api/v1/locations', params: { user: { name: 'Harry' } },
+    post '/api/v1/locations', params: { location: { latitude: 1, longitude: 1 } },
                               headers: { accept: 'application/vnd.api+json',
                                          'content-type': 'application/x-www-form-urlencoded' }
 

data/spec/requests/api/v1/error_handling_spec.rb

@@ -1,12 +1,11 @@
-describe 'Error handling', type: :request do
+describe 'Error handling' do
   context "when request doesn't contain required parameters" do
     it 'responds with 400 BadRequest' do
       post '/api/v1/locations', params: {}, headers: default_headers
 
       expect(response).to have_http_status(:bad_request)
       error = json_response['errors'].first
-      expect(error['title']).to eq('Bad Request')
-      expect(error['detail']).to match('param is missing or the value is empty: location')
+      expect(error).to include('title' => 'Bad Request', 'detail' => match(/param is missing or the value is empty/))
     end
   end
 
@@ -17,7 +16,7 @@ describe 'Error handling', type: :request do
       post '/api/v1/locations', params: { location: params }.to_json, headers: default_headers
 
       expect(response).to have_http_status(:unprocessable_entity)
-      expect(json_response['errors'].map { |details| details['source'] }).to contain_exactly(
+      expect(json_response['errors'].pluck('source')).to contain_exactly(
         { 'parameter' => 'latitude', 'pointer' => 'data/attributes/latitude' },
         { 'parameter' => 'longitude', 'pointer' => 'data/attributes/longitude' }
       )
@@ -29,25 +28,44 @@ describe 'Error handling', type: :request do
       get '/api/v1/locations/0', headers: default_headers
 
       expect(response).to have_http_status(:not_found)
-      expect(json_response['errors'].first['title']).to eq('Not found')
-      expect(json_response['errors'].first['detail']).to eq('Resource not found')
+      expect(json_response['errors'].first).to include('title' => 'Not found', 'detail' => 'Resource not found')
+    end
+
+    context 'with another locale' do
+      it 'responds with localized error message' do
+        get '/api/v1/locations/0', headers: default_headers.merge('Accept-Language' => 'de')
+
+        expect(response).to have_http_status(:not_found)
+        expect(json_response['errors'].first).to include('title' => 'Nicht gefunden',
+                                                         'detail' => 'Ressource nicht gefunden')
+      end
     end
   end
 
   context 'when client is not authorized to perform requested action' do
+    let(:loc) { create(:location, :fourth_quadrant) }
+
     it 'responds with 403 Forbidden' do
-      loc = create(:location, :fourth_quadrant)
       get "/api/v1/locations/#{loc.id}", headers: default_headers
 
       expect(response).to have_http_status(:forbidden)
-      expect(json_response['errors'].first['title']).to eq('Forbidden')
-      expect(json_response['errors'].first['detail'])
-        .to eq('You are not allowed to perform this action')
+      expect(json_response['errors'].first).to include('title' => 'Forbidden',
+                                                       'detail' => 'You are not allowed to perform this action')
+    end
+
+    context 'with another locale' do
+      it 'responds with localized error message' do
+        get "/api/v1/locations/#{loc.id}", headers: default_headers.merge('Accept-Language' => 'de')
+
+        expect(response).to have_http_status(:forbidden)
+        expect(json_response['errors'].first).to include('title' => 'Verboten',
+                                                         'detail' => 'Sie dürfen diese Aktion nicht ausführen')
+      end
     end
   end
 
   context 'when request contains unpermitted sort params' do
-    let(:bugsnag) { class_double('Bugsnag', notify: nil) }
+    let(:bugsnag) { class_double('Bugsnag', notify: nil) } # rubocop:disable RSpec/VerifiedDoubleReference
 
     before do
       stub_const('Bugsnag', bugsnag)
@@ -64,14 +82,14 @@ describe 'Error handling', type: :request do
 
       expect(response).to have_http_status(:bad_request)
       error = json_response['errors'].first
-      expect(error['title']).to eq('Bad Request')
-      expect(error['detail']).to eq('title is not a permitted sort attribute')
+      expect(error).to include('title' => 'Bad Request',
+                               'detail' => 'title is not a permitted sort attribute')
     end
   end
 
   context 'when action processing causes PG::Error' do
-    let(:location_model) { class_double('Location') }
-    let(:bugsnag) { class_double('Bugsnag', notify: nil) }
+    let(:location_model) { class_double(Location) }
+    let(:bugsnag) { class_double('Bugsnag', notify: nil) } # rubocop:disable RSpec/VerifiedDoubleReference
 
     before do
       stub_const('Bugsnag', bugsnag)
@@ -89,14 +107,14 @@ describe 'Error handling', type: :request do
       get '/api/v1/locations/0', headers: default_headers
 
       expect(response).to have_http_status(:internal_server_error)
-      expect(json_response['errors'].first['title']).to eq('Internal Server Error')
-      expect(json_response['errors'].first['detail']).to eq('Something went wrong')
+      expect(json_response['errors'].first).to include('title' => 'Internal Server Error',
+                                                       'detail' => 'Something went wrong')
     end
   end
 
   context 'when client requests invalid locale' do
-    it 'responds with 500 InternalServerError' do
-      get '/api/v1/locations?locale=--', headers: default_headers
+    it 'responds with 400 BadRequest' do
+      get '/api/v1/locations', headers: default_headers.merge('Accept-Language' => 'fr')
 
       expect(response).to have_http_status(:bad_request)
       expect(json_response['errors'].first['title']).to eq('Bad Request')

data/spec/requests/api/v1/locale_negotiation_spec.rb

@@ -0,0 +1,66 @@
+describe 'Locale negotiation' do
+  describe 'with localized content' do
+    it 'returns English hello message when Accept-Language is en' do
+      get '/api/v1/hello', headers: default_headers.merge('Accept-Language': 'en')
+
+      expect(response).to have_http_status(:ok)
+
+      expect(json_response['data']['attributes']['message']).to eq('Hello world')
+    end
+
+    it 'returns German hello message when Accept-Language is de' do
+      get '/api/v1/hello', headers: default_headers.merge('Accept-Language': 'de')
+
+      expect(response).to have_http_status(:ok)
+
+      expect(json_response['data']['attributes']['message']).to eq('Hallo Welt')
+    end
+
+    it 'returns default English message when no Accept-Language header provided' do
+      get '/api/v1/hello', headers: default_headers
+
+      expect(response).to have_http_status(:ok)
+
+      expect(json_response['data']['attributes']['message']).to eq('Hello world')
+    end
+
+    it 'prioritizes first valid locale from complex Accept-Language header' do
+      get '/api/v1/hello', headers: default_headers.merge('Accept-Language': 'de-DE,de;q=0.9,en;q=0.8')
+
+      expect(response).to have_http_status(:ok)
+
+      expect(json_response['data']['attributes']['message']).to eq('Hallo Welt')
+    end
+  end
+
+  describe 'error handling' do
+    it 'responds with 400 Bad Request when Accept-Language header is malformed' do
+      get '/api/v1/hello', headers: default_headers.merge('Accept-Language': '123-invalid')
+
+      expect(response).to have_http_status(:bad_request)
+      expect(response).to include_error_detail('Invalid locale')
+    end
+
+    it 'responds with 400 Bad Request and error message for invalid locale' do
+      get '/api/v1/hello', headers: default_headers.merge('Accept-Language': 'fr')
+
+      expect(response).to have_http_status(:bad_request)
+      expect(response).to include_error_detail('Invalid locale')
+    end
+
+    context 'when fallback to default is enabled' do
+      around do |example|
+        Api::V1::HelloController.fallback_to_default_locale_if_invalid = true
+        example.run
+        Api::V1::HelloController.fallback_to_default_locale_if_invalid = false
+      end
+
+      it 'responds with 200 OK and default locale body' do
+        get '/api/v1/hello', headers: default_headers.merge('Accept-Language': 'fr')
+
+        expect(response).to have_http_status(:ok)
+        expect(json_response['data']['attributes']['message']).to eq('Hello world')
+      end
+    end
+  end
+end

data/spec/requests/api/v1/responder_spec.rb

@@ -1,4 +1,4 @@
-describe 'Responder', type: :request do
+describe 'Responder' do
   context 'when GET request' do
     it 'responds with 200 OK' do
       get '/api/v1/locations', headers: default_headers

data/spec/requests/api/v1/serializer_options_spec.rb

@@ -1,7 +1,7 @@
 require 'cgi'
 require 'uri'
 
-describe 'Serializer options', type: :request do
+describe 'Serializer options' do
   it 'adds meta with pagination information' do
     get '/api/v1/locations', params: {}, headers: default_headers