refactor specs

Separate out into different spec files, etc

Author: Lee Richmond

gemfiles/rails_4.gemfile

@@ -3,7 +3,7 @@
 source "http://artprod.dev.bloomberg.com/artifactory/api/gems/rubygems/"
 
 gem "active_model_serializers", :git => "https://github.com/richmolj/active_model_serializers.git"
-gem "rails", "~> 4.0"
+gem "rails", "~> 4.1"
 
 group :test do
   gem "appraisal"

gemfiles/rails_4.gemfile.lock

@@ -11,7 +11,7 @@ GIT
 PATH
   remote: ../
   specs:
-    jsonapi_compliable (0.3.1)
+    jsonapi_compliable (0.3.2)
       active_model_serializers (~> 0.10)
       jsonapi (~> 0.1.1.beta2)
       jsonapi_ams_extensions (~> 0.1)
@@ -208,7 +208,7 @@ DEPENDENCIES
   kaminari
   pry
   pry-byebug
-  rails (~> 4.0)
+  rails (~> 4.1)
   rake (~> 10.0)
   rspec-rails
   sqlite3

gemfiles/rails_5.gemfile.lock

@@ -11,7 +11,7 @@ GIT
 PATH
   remote: ../
   specs:
-    jsonapi_compliable (0.3.1)
+    jsonapi_compliable (0.3.2)
       active_model_serializers (~> 0.10)
       jsonapi (~> 0.1.1.beta2)
       jsonapi_ams_extensions (~> 0.1)

lib/jsonapi_compliable/base.rb

@@ -8,6 +8,7 @@ module Base
     included do
       class_attribute :_jsonapi_compliable
       before_action :parse_fieldsets!
+      after_action :reset_scope_flag
     end
 
     def default_page_number
@@ -30,18 +31,22 @@ def jsonapi_scope(scope,
       scope = JSONAPICompliable::Scope::Sideload.new(self, scope).apply if includes
       scope = JSONAPICompliable::Scope::Sort.new(self, scope).apply if sort
       scope = JSONAPICompliable::Scope::Paginate.new(self, scope).apply if paginate
+      @_jsonapi_scoped = true
       scope
     end
 
+    def reset_scope_flag
+      @_jsonapi_scoped = false
+    end
+
     def parse_fieldsets!
       Util::FieldParams.parse!(params, :fields)
       Util::FieldParams.parse!(params, :extra_fields)
     end
 
-    # * Eager loads whitelisted includes
-    # * Merges opts and ams_default_options
     def render_ams(scope, opts = {})
-      scope = jsonapi_scope(scope) if scope.is_a?(ActiveRecord::Relation)
+      opts[:scope] = true unless opts[:scope] == false
+      scope = jsonapi_scope(scope) if !@_jsonapi_scoped && opts.delete(:scope)
       options = default_ams_options
       options[:include] = forced_includes || Util::IncludeParams.scrub(self)
       options[:json] = scope
@@ -60,6 +65,9 @@ def default_ams_options
       end
     end
 
+    # TODO: This nastiness likely goes away once jsonapi standardizes
+    # a spec for nested relationships.
+    # See: https://github.com/json-api/json-api/issues/1089
     def forced_includes(data = nil)
       return unless force_includes?
       data = raw_params[:data] unless data
@@ -85,9 +93,11 @@ def force_includes?
 
     module ClassMethods
       def jsonapi(&blk)
-        dsl = JsonapiCompliable::DSL.new
-        dsl.instance_eval(&blk)
-        self._jsonapi_compliable = dsl
+        if !self._jsonapi_compliable
+          dsl = JsonapiCompliable::DSL.new
+          self._jsonapi_compliable = dsl
+        end
+        self._jsonapi_compliable.instance_eval(&blk)
       end
     end
   end

lib/jsonapi_compliable/scope/default_filter.rb

@@ -4,11 +4,22 @@ class Scope::DefaultFilter < Scope::Base
 
     def apply
       dsl.default_filters.each_pair do |name, opts|
-        next if find_filter(name)
+        next if overridden?(name)
         @scope = opts[:filter].call(@scope)
       end
 
       @scope
     end
+
+    private
+
+    def overridden?(name)
+      if found = find_filter(name)
+        found_aliases = found[name][:aliases]
+        filter_param.keys.any? { |k| found_aliases.include?(k.to_sym) }
+      else
+        false
+      end
+    end
   end
 end

lib/jsonapi_compliable/scope/extra_fields.rb

@@ -1,6 +1,5 @@
 module JSONAPICompliable
   class Scope::ExtraFields < Scope::Base
-
     def apply
       each_extra_field do |extra_field|
         @scope = extra_field[:proc].call(@scope)

lib/jsonapi_compliable/scope/filter.rb

@@ -28,9 +28,5 @@ def each_filter
         yield filter, value
       end
     end
-
-    def filter_param
-      params[:filter] || {}
-    end
   end
 end

lib/jsonapi_compliable/scope/filterable.rb

@@ -15,5 +15,9 @@ def find_filter!(name)
       end
       { filter_name => filter_value }
     end
+
+    def filter_param
+      params[:filter] || {}
+    end
   end
 end

spec/create_update_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+RSpec.describe 'create/update', type: :controller do
+  controller(ApplicationController) do
+    jsonapi { }
+
+    before_action :deserialize_jsonapi!, only: [:create, :update]
+
+    def create
+      author = Author.new(author_params.except(:state_attributes))
+      author.state = State.find_or_initialize_by(author_params[:state_attributes])
+      author.save!(validate: false)
+      render_ams(author, scope: false)
+    end
+
+    def update
+      author = Author.find(author_params[:id])
+      author_params[:books_attributes].each do |attrs|
+        book = Book.find_or_initialize_by(attrs)
+        author.association(:books).add_to_target(book, :skip_callbacks)
+      end
+      author.association(:books).loaded!
+      author.save!
+      render_ams(author, scope: false)
+    end
+
+    private
+
+    def author_params
+      params.require(:author).permit!
+    end
+  end
+
+  let!(:virginia) { State.create!(name: 'virginia') }
+
+  context 'when creating' do
+    it 'includes whatever nested relations were sent in the request in the response' do
+      post :create, params: {
+        data: {
+          type: 'authors',
+          attributes: { first_name: 'Stephen', last_name: 'King' },
+          relationships: {
+            state: {
+              data: {
+                type: 'states',
+                id: virginia.id
+              }
+            },
+            books: {
+              data: [
+                { type: 'books', attributes: { title: 'The Shining' } }
+              ]
+            }
+          }
+        }
+      }
+
+      expect(json_included_types).to match_array(%w(states books))
+      expect(json_include('states')['id']).to eq(virginia.id.to_s)
+    end
+  end
+
+  context 'when updating' do
+    let!(:author) { Author.create!(first_name: 'Stephen', last_name: 'King', state: virginia) }
+    let!(:old_book) { author.books.create(title: "The Shining") }
+
+    before do
+      routes.draw { put "update" => "anonymous#update" }
+    end
+
+    it 'should include relations sent as part of payload' do
+      put :update, id: author.id, params: {
+        data: {
+          id: author.id,
+          type: 'authors',
+          relationships: {
+            books: {
+              data: [
+                {
+                  type: 'books',
+                  attributes: {
+                    title: "The Firm"
+                  }
+                }
+              ]
+            }
+          }
+        }
+      }
+
+      expect(json_included_types).to match_array(%w(books))
+      expect(json_includes('books').length).to eq(1)
+      expect(json_include('books')['id']).to eq(Book.last.id.to_s)
+      author.reload
+      expect(author.book_ids).to match_array(Book.pluck(:id))
+    end
+  end
+end

spec/deserialization_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe 'deserialization', type: :controller do
+  controller(ApplicationController) do
+    jsonapi { }
+  end
+
+  let(:payload) do
+    {
+      data: {
+        type: 'authors',
+        attributes: { first_name: 'Stephen', last_name: 'King' },
+        relationships: {
+          state: {
+            data: {
+              type: 'states',
+              attributes: { name: 'virginia' },
+            }
+          },
+          books: {
+            data: [
+              { type: 'books', attributes: { title: 'The Shining' } }
+            ]
+          }
+        }
+      }
+    }
+  end
+
+
+  describe '#deserialize_jsonapi!' do
+    before do
+      controller.params = payload
+    end
+
+    it 'preserves raw params as raw_params' do
+      controller.deserialize_jsonapi!
+
+      if Rails::VERSION::MAJOR == 4
+        expect(controller.raw_params).to eq(payload.deep_stringify_keys)
+      else
+        expect(controller.raw_params).to eq(payload)
+      end
+    end
+
+    it 'sets params to a rails-friendly payload' do
+      controller.deserialize_jsonapi!
+      expected = {
+        author: {
+          first_name: 'Stephen',
+          last_name: 'King',
+          state_attributes: {
+            name: 'virginia'
+          },
+          books_attributes: [
+            { title: 'The Shining' }
+          ]
+        }
+      }
+      expected.deep_stringify_keys! if Rails::VERSION::MAJOR == 4
+      expect(controller.params).to eq(expected)
+    end
+  end
+end