fast_jsonapi 1.0.17 → 1.1.0

data/spec/lib/object_serializer_struct_spec.rb

@@ -1,31 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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

data/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-require 'fast_jsonapi'
-require 'rspec-benchmark'
-require 'multi_json'
-require 'byebug'
-require 'active_model_serializers'
-
-Dir[File.dirname(__FILE__) + '/shared/contexts/*.rb'].each {|file| require file }
-
-RSpec.configure do |config|
-  config.include RSpec::Benchmark::Matchers
-end
-
-ActiveModel::Serializer.config.adapter = :json_api
-ActiveModel::Serializer.config.key_transform = :underscore
-ActiveModelSerializers.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new('/dev/null'))