fast_jsonapi 1.0.16

data/spec/lib/object_serializer_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+
+  context 'when testing instance methods of object serializer' do
+    it 'returns correct hash when serializable_hash is called' do
+      options = {}
+      options[:meta] = { total: 2 }
+      options[:include] = [:actors]
+      serializable_hash = MovieSerializer.new([movie, movie], options).serializable_hash
+
+      expect(serializable_hash[:data].length).to eq 2
+      expect(serializable_hash[:data][0][:relationships].length).to eq 3
+      expect(serializable_hash[:data][0][:attributes].length).to eq 2
+
+      expect(serializable_hash[:meta]).to be_instance_of(Hash)
+
+      expect(serializable_hash[:included]).to be_instance_of(Array)
+      expect(serializable_hash[:included][0]).to be_instance_of(Hash)
+      expect(serializable_hash[:included].length).to eq 3
+
+      serializable_hash = MovieSerializer.new(movie).serializable_hash
+
+      expect(serializable_hash[:data]).to be_instance_of(Hash)
+      expect(serializable_hash[:meta]).to be nil
+      expect(serializable_hash[:included]).to be nil
+    end
+
+    it 'returns correct number of records when serialized_json is called for an array' do
+      options = {}
+      options[:meta] = { total: 2 }
+      json = MovieSerializer.new([movie, movie], options).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data'].length).to eq 2
+      expect(serializable_hash['meta']).to be_instance_of(Hash)
+    end
+
+    it 'returns correct id when serialized_json is called for a single object' do
+      json = MovieSerializer.new(movie).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data']['id']).to eq movie.id.to_s
+    end
+
+    it 'returns correct json when serializing nil' do
+      json = MovieSerializer.new(nil).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data']).to eq nil
+    end
+
+    it 'returns correct json when record id is nil' do
+      movie.id = nil
+      json = MovieSerializer.new(movie).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data']['id']).to be nil
+    end
+
+    it 'returns correct json when has_many returns []' do
+      movie.actor_ids = []
+      json = MovieSerializer.new(movie).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data']['relationships']['actors']['data'].length).to eq 0
+    end
+
+    it 'returns correct json when belongs_to returns nil' do
+      movie.owner_id = nil
+      json = MovieSerializer.new(movie).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data']['relationships']['owner']['data']).to be nil
+    end
+
+    it 'returns correct json when serializing []' do
+      json = MovieSerializer.new([]).serialized_json
+      serializable_hash = JSON.parse(json)
+      expect(serializable_hash['data']).to eq []
+    end
+
+    it 'returns errors when serializing with non-existent includes key' do
+      options = {}
+      options[:meta] = { total: 2 }
+      options[:include] = [:blah_blah]
+      expect { MovieSerializer.new([movie, movie], options).serializable_hash }.to raise_error(ArgumentError)
+    end
+
+    it 'returns keys when serializing with empty string/nil array includes key' do
+      options = {}
+      options[:meta] = { total: 2 }
+      options[:include] = ['']
+      expect(MovieSerializer.new([movie, movie], options).serializable_hash.keys).to eq [:data, :meta]
+      options[:include] = [nil]
+      expect(MovieSerializer.new([movie, movie], options).serializable_hash.keys).to eq [:data, :meta]
+    end
+  end
+
+  context 'when testing included do block of object serializer' do
+    it 'should set default_type based on serializer class name' do
+      class BlahSerializer
+        include FastJsonapi::ObjectSerializer
+      end
+      expect(BlahSerializer.record_type).to be :blah
+    end
+
+    it 'should set default_type for a multi word class name' do
+      class BlahBlahSerializer
+        include FastJsonapi::ObjectSerializer
+      end
+      expect(BlahBlahSerializer.record_type).to be :blah_blah
+    end
+
+    it 'shouldnt set default_type for a serializer that doesnt follow convention' do
+      class BlahBlahSerializerBuilder
+        include FastJsonapi::ObjectSerializer
+      end
+      expect(BlahBlahSerializerBuilder.record_type).to be_nil
+    end
+
+    it 'shouldnt set default_type for a serializer that doesnt follow convention' do
+      module V1
+        class BlahSerializer
+          include FastJsonapi::ObjectSerializer
+        end
+      end
+      expect(V1::BlahSerializer.record_type).to be :blah
+    end
+  end
+end

data/spec/lib/object_serializer_struct_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+
+  context 'when testing object serializer with ruby struct' do
+    it 'returns correct hash when serializable_hash is called' do
+      options = {}
+      options[:meta] = { total: 2 }
+      options[:include] = [:actors]
+      serializable_hash = MovieSerializer.new([movie_struct, movie_struct], options).serializable_hash
+
+      expect(serializable_hash[:data].length).to eq 2
+      expect(serializable_hash[:data][0][:relationships].length).to eq 3
+      expect(serializable_hash[:data][0][:attributes].length).to eq 2
+
+      expect(serializable_hash[:meta]).to be_instance_of(Hash)
+
+      expect(serializable_hash[:included]).to be_instance_of(Array)
+      expect(serializable_hash[:included][0]).to be_instance_of(Hash)
+      expect(serializable_hash[:included].length).to eq 3
+
+      serializable_hash = MovieSerializer.new(movie_struct).serializable_hash
+
+      expect(serializable_hash[:data]).to be_instance_of(Hash)
+      expect(serializable_hash[:meta]).to be nil
+      expect(serializable_hash[:included]).to be nil
+      expect(serializable_hash[:data][:id]).to eq movie_struct.id.to_s
+    end
+  end
+end

data/spec/lib/serialization_core_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context "movie class"
+
+  context 'when testing class methods of serialization core' do
+    it 'returns correct hash when id_hash is called' do
+      inputs = [{id: 23, record_type: :movie}, {id: 'x', record_type: 'person'}]
+      inputs.each do |hash|
+        result_hash = MovieSerializer.send(:id_hash, hash[:id], hash[:record_type])
+        expect(result_hash[:id]).to eq hash[:id].to_s
+        expect(result_hash[:type]).to eq hash[:record_type]
+      end
+
+      result_hash = MovieSerializer.send(:id_hash, nil, 'movie')
+      expect(result_hash).to be nil
+    end
+
+    it 'returns correct hash when ids_hash is called' do
+      inputs = [{ids: %w(1 2 3), record_type: :movie}, {ids: %w(x y z), record_type: 'person'}]
+      inputs.each do |hash|
+        results = MovieSerializer.send(:ids_hash, hash[:ids], hash[:record_type])
+        expect(results.map{|h| h[:id]}).to eq hash[:ids]
+        expect(results[0][:type]).to eq hash[:record_type]
+      end
+
+      result = MovieSerializer.send(:ids_hash, [], 'movie')
+      expect(result).to be_empty
+    end
+
+    it 'returns correct hash when attributes_hash is called' do
+      attributes_hash = MovieSerializer.send(:attributes_hash, movie)
+      attribute_names = attributes_hash.keys.sort
+      expect(attribute_names).to eq MovieSerializer.attributes_to_serialize.keys.sort
+      MovieSerializer.attributes_to_serialize.each do |key, method_name|
+        value = attributes_hash[key]
+        expect(value).to eq movie.send(method_name)
+      end
+    end
+
+    it 'returns the correct empty result when relationships_hash is called' do
+      movie.actor_ids = []
+      movie.owner_id = nil
+      relationships_hash = MovieSerializer.send(:relationships_hash, movie)
+      expect(relationships_hash[:actors][:data]).to eq([])
+      expect(relationships_hash[:owner][:data]).to eq(nil)
+    end
+
+    it 'returns correct keys when relationships_hash is called' do
+      relationships_hash = MovieSerializer.send(:relationships_hash, movie)
+      relationship_names = relationships_hash.keys.sort
+      relationships_hashes = MovieSerializer.relationships_to_serialize.values
+      expected_names = relationships_hashes.map{|relationship| relationship[:key]}.sort
+      expect(relationship_names).to eq expected_names
+    end
+
+    it 'returns correct values when relationships_hash is called' do
+      relationships_hash = MovieSerializer.relationships_hash(movie)
+      actors_hash = movie.actor_ids.map { |id|  {id: id.to_s, type: :actor} }
+      owner_hash = {id: movie.owner_id.to_s, type: :user}
+      expect(relationships_hash[:actors][:data]).to match_array actors_hash
+      expect(relationships_hash[:owner][:data]).to eq owner_hash
+    end
+
+    it 'returns correct hash when record_hash is called' do
+      record_hash = MovieSerializer.send(:record_hash, movie)
+      expect(record_hash[:id]).to eq movie.id.to_s
+      expect(record_hash[:type]).to eq MovieSerializer.record_type
+      expect(record_hash).to have_key(:attributes) if MovieSerializer.attributes_to_serialize.present?
+      expect(record_hash).to have_key(:relationships) if MovieSerializer.relationships_to_serialize.present?
+    end
+
+    it 'serializes known included records only once' do
+      includes_list = [:actors]
+      known_included_objects = {}
+      included_records = []
+      [movie, movie].each do |record|
+        included_records.concat MovieSerializer.send(:get_included_records, record, includes_list, known_included_objects)
+      end
+      expect(included_records.size).to eq 3
+    end
+  end
+
+end

data/spec/shared/contexts/ams_context.rb

@@ -0,0 +1,83 @@
+RSpec.shared_context 'ams movie class' do
+  before(:context) do
+    # models
+    class AMSMovie < ActiveModelSerializers::Model
+      attr_accessor :id, :name, :release_year, :actors, :owner, :movie_type
+    end
+
+    class AMSActor < ActiveModelSerializers::Model
+      attr_accessor :id, :name, :email
+    end
+
+    class AMSUser < ActiveModelSerializers::Model
+      attr_accessor :id, :name
+    end
+    class AMSMovieType < ActiveModelSerializers::Model
+      attr_accessor :id, :name
+    end
+    # serializers
+    class AMSMovieSerializer < ActiveModel::Serializer
+      type 'movie'
+      attributes :name, :release_year
+      has_many :actors
+      has_one :owner
+      belongs_to :movie_type
+    end
+
+    class AMSActorSerializer < ActiveModel::Serializer
+      type 'actor'
+      attributes :name, :email
+    end
+
+    class AMSUserSerializer < ActiveModel::Serializer
+      type 'user'
+      attributes :name
+    end
+    class AMSMovieTypeSerializer < ActiveModel::Serializer
+      type 'movie_type'
+      attributes :name
+    end
+  end
+
+  after(:context) do
+    classes_to_remove = %i[AMSMovie AMSMovieSerializer]
+    classes_to_remove.each do |klass_name|
+      Object.send(:remove_const, klass_name) if Object.constants.include?(klass_name)
+    end
+  end
+
+  let(:ams_actors) do
+    3.times.map do |i|
+      a = AMSActor.new
+      a.id = i + 1
+      a.name = "Test #{a.id}"
+      a.email = "test#{a.id}@test.com"
+      a
+    end
+  end
+
+  let(:ams_user) do
+    ams_user = AMSUser.new
+    ams_user.id = 3
+    ams_user
+  end
+
+  let(:ams_movie_type) do
+    ams_movie_type = AMSMovieType.new
+    ams_movie_type.id = 1
+    ams_movie_type.name = 'episode'
+    ams_movie_type
+  end
+
+  def build_ams_movies(count)
+    count.times.map do |i|
+      m = AMSMovie.new
+      m.id = i + 1
+      m.name = 'test movie'
+      m.actors = ams_actors
+      m.owner = ams_user
+      m.movie_type = ams_movie_type
+      m
+    end
+  end
+end

data/spec/shared/contexts/movie_context.rb

@@ -0,0 +1,192 @@
+RSpec.shared_context 'movie class' do
+
+  # Movie, Actor Classes and serializers
+  before(:context) do
+    # models
+    class Movie
+      attr_accessor :id, :name, :release_year, :actor_ids, :owner_id, :movie_type_id
+
+      def actors
+        actor_ids.map do |id|
+          a = Actor.new
+          a.id = id
+          a.name = "Test #{a.id}"
+          a.email = "test#{a.id}@test.com"
+          a
+        end
+      end
+
+      def movie_type
+        mt = MovieType.new
+        mt.id = movie_type_id
+        mt.name = 'Episode'
+        mt
+      end
+
+      def cache_key
+        "#{id}"
+      end
+    end
+
+    class Actor
+      attr_accessor :id, :name, :email
+    end
+
+    class MovieType
+      attr_accessor :id, :name
+    end
+
+    # serializers
+    class MovieSerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :movie
+      attributes :name, :release_year
+      has_many :actors
+      belongs_to :owner, record_type: :user
+      belongs_to :movie_type
+    end
+
+    class CachingMovieSerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :movie
+      attributes :name, :release_year
+      has_many :actors
+      belongs_to :owner, record_type: :user
+      belongs_to :movie_type
+
+      cache_options enabled: true
+    end
+
+    class CachingMovieWithHasManySerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :movie
+      attributes :name, :release_year
+      has_many :actors, cached: true
+      belongs_to :owner, record_type: :user
+      belongs_to :movie_type
+
+      cache_options enabled: true
+    end
+
+    class ActorSerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :actor
+      attributes :name, :email
+    end
+
+    class MovieTypeSerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :movie_type
+      attributes :name
+    end
+  end
+
+
+  # Namespaced MovieSerializer
+  before(:context) do
+    # namespaced model stub
+    module AppName
+      module V1
+        class MovieSerializer
+          include FastJsonapi::ObjectSerializer
+          # to test if compute_serializer_name works
+        end
+      end
+    end
+  end
+
+
+  # Hyphenated keys for the serializer
+  before(:context) do
+    class HyphenMovieSerializer
+      include FastJsonapi::ObjectSerializer
+      use_hyphen
+      set_type :movie
+      attributes :name, :release_year
+      has_many :actors
+      belongs_to :owner, record_type: :user
+      belongs_to :movie_type
+    end
+
+    class HyphenMovieTypeSerializer
+      include FastJsonapi::ObjectSerializer
+      use_hyphen
+      set_type :movie_type
+      attributes :name
+    end
+  end
+
+
+  # Movie and Actor struct
+  before(:context) do
+    MovieStruct = Struct.new(
+      :id, :name, :release_year, :actor_ids, :actors, :owner_id, :owner, :movie_type_id
+    )
+
+    ActorStruct = Struct.new(
+      :id, :name, :email
+    )
+  end
+
+  after(:context) do
+    classes_to_remove = %i[
+      Movie
+      MovieSerializer
+      Actor
+      ActorSerializer
+      MovieType
+      MovieTypeSerializer
+      AppName::V1::MovieSerializer
+      MovieStruct
+      ActorStruct
+      HyphenMovieSerializer
+    ]
+    classes_to_remove.each do |klass_name|
+      Object.send(:remove_const, klass_name) if Object.constants.include?(klass_name)
+    end
+  end
+
+  let(:movie_struct) do
+
+    actors = []
+
+    3.times.each do |id|
+      a = ActorStruct.new
+      a[:id] = id
+      a[:name] = id.to_s
+      actors << a
+    end
+
+    m = MovieStruct.new
+    m[:id] = 23
+    m[:name] = 'struct movie'
+    m[:release_year] = 1987
+    m[:actor_ids] = [1,2,3]
+    m[:owner_id] = 3
+    m[:movie_type_id] = 2
+    m[:actors] = actors
+    m
+  end
+
+  let(:movie) do
+    m = Movie.new
+    m.id = 232
+    m.name = 'test movie'
+    m.actor_ids = [1, 2, 3]
+    m.owner_id = 3
+    m.movie_type_id = 1
+    m
+  end
+
+  def build_movies(count)
+    count.times.map do |i|
+      m = Movie.new
+      m.id = i + 1
+      m.name = 'test movie'
+      m.actor_ids = [1, 2, 3]
+      m.owner_id = 3
+      m.movie_type_id = 1
+      m
+    end
+  end
+end