fast_jsonapi 1.0.17 → 1.1.0

data/spec/lib/extensions/active_record_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'sqlite3'
-
-describe 'active record' do
-
-  # Setup DB
-  before(:all) do
-    @db_file = "test.db"
-
-    # Open a database
-    db = SQLite3::Database.new @db_file
-
-    # Create tables
-    db.execute_batch <<-SQL
-      create table suppliers (
-        name varchar(30),
-        id int primary key
-      );
-
-      create table accounts (
-        name varchar(30),
-        id int primary key,
-        supplier_id int,
-        FOREIGN KEY (supplier_id) REFERENCES suppliers(id)
-      );
-    SQL
-
-    # Insert records
-    @account_id = 2
-    @supplier_id = 1
-    db.execute_batch <<-SQL
-      insert into suppliers values ('Supplier1', #{@supplier_id});
-      insert into accounts values ('Dollar Account', #{@account_id}, #{@supplier_id});
-    SQL
-  end
-
-  # Setup Active Record
-  before(:all) do
-    class Supplier < ActiveRecord::Base
-      has_one :account
-    end
-
-    class Account < ActiveRecord::Base
-      belongs_to :supplier
-    end
-
-    ActiveRecord::Base.establish_connection(
-      :adapter => 'sqlite3',
-      :database  => @db_file
-    )
-  end
-
-  context 'has one patch' do
-
-    it 'has account_id method for a supplier' do
-      expect(Supplier.first.respond_to?(:account_id)).to be true
-      expect(Supplier.first.account_id).to eq @account_id
-    end
-
-  end
-
-  # Clean up DB
-  after(:all) do
-    File.delete(@db_file) if File.exist?(@db_file)
-  end
-end

data/spec/lib/object_serializer_caching_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe FastJsonapi::ObjectSerializer do
-  include_context 'movie class'
-
-  context 'when caching has_many' do
-    before(:each) do
-      rails = OpenStruct.new
-      rails.cache = ActiveSupport::Cache::MemoryStore.new
-      stub_const('Rails', rails)
-    end
-
-    it 'returns correct hash when serializable_hash is called' do
-      options = {}
-      options[:meta] = { total: 2 }
-      options[:include] = [:actors]
-      serializable_hash = CachingMovieSerializer.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 = CachingMovieSerializer.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 'uses cached values for the record' do
-      previous_name = movie.name
-      previous_actors = movie.actors
-      CachingMovieSerializer.new(movie).serializable_hash
-
-      movie.name = 'should not match'
-      allow(movie).to receive(:actor_ids).and_return([99])
-
-      expect(previous_name).not_to eq(movie.name)
-      expect(previous_actors).not_to eq(movie.actors)
-      serializable_hash = CachingMovieSerializer.new(movie).serializable_hash
-
-      expect(serializable_hash[:data][:attributes][:name]).to eq(previous_name)
-      expect(serializable_hash[:data][:relationships][:actors][:data].length).to eq movie.actors.length
-    end
-
-    it 'uses cached values for has many as specified' do
-      previous_name = movie.name
-      previous_actors = movie.actors
-      CachingMovieWithHasManySerializer.new(movie).serializable_hash
-
-      movie.name = 'should not match'
-      allow(movie).to receive(:actor_ids).and_return([99])
-
-      expect(previous_name).not_to eq(movie.name)
-      expect(previous_actors).not_to eq(movie.actors)
-      serializable_hash = CachingMovieWithHasManySerializer.new(movie).serializable_hash
-
-      expect(serializable_hash[:data][:attributes][:name]).to eq(previous_name)
-      expect(serializable_hash[:data][:relationships][:actors][:data].length).to eq previous_actors.length
-    end
-  end
-end

data/spec/lib/object_serializer_class_methods_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe FastJsonapi::ObjectSerializer do
-
-  include_context 'movie class'
-
-  context 'when testing class methods of object serializer' do
-
-    before(:example) do
-      MovieSerializer.relationships_to_serialize = {}
-    end
-
-    it 'returns correct relationship hash for a has_many relationship' do
-      MovieSerializer.has_many :roles
-      relationship = MovieSerializer.relationships_to_serialize[:roles]
-      expect(relationship).to be_instance_of(Hash)
-      expect(relationship.keys).to all(be_instance_of(Symbol))
-      expect(relationship[:id_method_name]).to end_with '_ids'
-      expect(relationship[:record_type]).to eq 'roles'.singularize.to_sym
-    end
-
-    it 'returns correct relationship hash for a has_many relationship with overrides' do
-      MovieSerializer.has_many :roles, id_method_name: :roles_only_ids, record_type: :super_role
-      relationship = MovieSerializer.relationships_to_serialize[:roles]
-      expect(relationship[:id_method_name]).to be :roles_only_ids
-      expect(relationship[:record_type]).to be :super_role
-    end
-
-    it 'returns correct relationship hash for a belongs_to relationship' do
-      MovieSerializer.belongs_to :area
-      relationship = MovieSerializer.relationships_to_serialize[:area]
-      expect(relationship).to be_instance_of(Hash)
-      expect(relationship.keys).to all(be_instance_of(Symbol))
-      expect(relationship[:id_method_name]).to end_with '_id'
-      expect(relationship[:record_type]).to eq 'area'.singularize.to_sym
-    end
-
-    it 'returns correct relationship hash for a belongs_to relationship with overrides' do
-      MovieSerializer.has_many :area, id_method_name: :blah_id, record_type: :awesome_area, serializer: :my_area
-      relationship = MovieSerializer.relationships_to_serialize[:area]
-      expect(relationship[:id_method_name]).to be :blah_id
-      expect(relationship[:record_type]).to be :awesome_area
-      expect(relationship[:serializer]).to be :MyAreaSerializer
-    end
-
-    it 'returns correct relationship hash for a has_one relationship' do
-      MovieSerializer.has_one :area
-      relationship = MovieSerializer.relationships_to_serialize[:area]
-      expect(relationship).to be_instance_of(Hash)
-      expect(relationship.keys).to all(be_instance_of(Symbol))
-      expect(relationship[:id_method_name]).to end_with '_id'
-      expect(relationship[:record_type]).to eq 'area'.singularize.to_sym
-    end
-
-    it 'returns correct relationship hash for a has_one relationship with overrides' do
-      MovieSerializer.has_one :area, id_method_name: :blah_id, record_type: :awesome_area
-      relationship = MovieSerializer.relationships_to_serialize[:area]
-      expect(relationship[:id_method_name]).to be :blah_id
-      expect(relationship[:record_type]).to be :awesome_area
-    end
-
-    it 'returns serializer name correctly with namespaces' do
-      AppName::V1::MovieSerializer.has_many :area, id_method_name: :blah_id
-      relationship = AppName::V1::MovieSerializer.relationships_to_serialize[:area]
-      expect(relationship[:serializer]).to be :'AppName::V1::AreaSerializer'
-    end
-  end
-
-end

data/spec/lib/object_serializer_hyphen_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe FastJsonapi::ObjectSerializer do
-  include_context 'movie class'
-  include_context 'ams movie class'
-
-  context 'when using hyphens for word separation in the JSON API members' do
-    it 'returns correct hash when serializable_hash is called' do
-      serializable_hash = HyphenMovieSerializer.new([movie, movie]).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][:relationships]).to have_key('movie-type'.to_sym)
-      expect(serializable_hash[:data][0][:attributes].length).to eq 2
-      expect(serializable_hash[:data][0][:attributes]).to have_key("release-year".to_sym)
-
-      serializable_hash = HyphenMovieSerializer.new(movie_struct).serializable_hash
-      expect(serializable_hash[:data][:relationships].length).to eq 3
-      expect(serializable_hash[:data][:relationships]).to have_key('movie-type'.to_sym)
-      expect(serializable_hash[:data][:attributes].length).to eq 2
-      expect(serializable_hash[:data][:attributes]).to have_key('release-year'.to_sym)
-      expect(serializable_hash[:data][:id]).to eq movie_struct.id.to_s
-    end
-
-    it 'returns same thing as ams' do
-      ams_movie = build_ams_movies(1).first
-      movie = build_movies(1).first
-      our_json = HyphenMovieSerializer.new([movie]).serialized_json
-      ams_json = ActiveModelSerializers::SerializableResource.new([ams_movie], key_transform: :dash).to_json
-      expect(our_json.length).to eq (ams_json.length)
-    end
-
-    it 'returns type hypenated when trying to serializing a class with multiple words' do
-      movie_type = MovieType.new
-      movie_type.id = 3
-      movie_type.name = "x"
-      serializable_hash = HyphenMovieTypeSerializer.new(movie_type).serializable_hash
-      expect(serializable_hash[:data][:type].to_sym).to eq 'movie-type'.to_sym
-    end
-  end
-end

data/spec/lib/object_serializer_performance_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe FastJsonapi::ObjectSerializer do
-  include_context 'movie class'
-  include_context 'ams movie class'
-
-  context 'when testing performance of serialization' do
-    it 'should create a hash of 1000 records in less than 25 ms' do
-      movies = 1000.times.map { |_i| movie }
-      expect { MovieSerializer.new(movies).serializable_hash }.to perform_under(25).ms
-    end
-
-    it 'should serialize 1000 records to jsonapi in less than 30 ms' do
-      movies = 1000.times.map { |_i| movie }
-      expect { MovieSerializer.new(movies).serialized_json }.to perform_under(30).ms
-    end
-
-    it 'should create a hash of 1000 records with includes and meta in less than 75 ms' do
-      count = 1000
-      movies = count.times.map { |_i| movie }
-      options = {}
-      options[:meta] = { total: count }
-      options[:include] = [:actors]
-      expect { MovieSerializer.new(movies, options).serializable_hash }.to perform_under(75).ms
-    end
-
-    it 'should serialize 1000 records to jsonapi with includes and meta in less than 75 ms' do
-      count = 1000
-      movies = count.times.map { |_i| movie }
-      options = {}
-      options[:meta] = { total: count }
-      options[:include] = [:actors]
-      expect { MovieSerializer.new(movies, options).serialized_json }.to perform_under(75).ms
-    end
-  end
-
-  def print_stats(count, ams_time, our_time)
-    format = '%-15s %-10s %s'
-    puts ''
-    puts format(format, 'Serializer', 'Records', 'Time')
-    puts format(format, 'AMS serializer', count, ams_time.round(2).to_s + ' ms')
-    puts format(format, 'Fast serializer', count, our_time.round(2).to_s + ' ms')
-  end
-
-  context 'when comparing with AMS 0.10.x' do
-    [1, 25, 250, 1000].each do |movie_count|
-      speed_factor = 25
-      it "should serialize #{movie_count} records atleast #{speed_factor} times faster than AMS" do
-        ams_movies = build_ams_movies(movie_count)
-        movies = build_movies(movie_count)
-        our_json = nil
-        ams_json = nil
-        our_serializer = MovieSerializer.new(movies)
-        ams_serializer = ActiveModelSerializers::SerializableResource.new(ams_movies)
-        our_time = Benchmark.measure { our_json = our_serializer.serialized_json }.real * 1000
-        ams_time = Benchmark.measure { ams_json = ams_serializer.to_json }.real * 1000
-        print_stats(movie_count, ams_time, our_time)
-        expect(our_json.length).to eq ams_json.length
-        expect { our_serializer.serialized_json }.to perform_faster_than { ams_serializer.to_json }.at_least(speed_factor).times
-      end
-    end
-  end
-
-  context 'when comparing with AMS 0.10.x and with includes and meta' do
-    [1, 25, 250, 1000].each do |movie_count|
-      speed_factor = 25
-      it "should serialize #{movie_count} records atleast #{speed_factor} times faster than AMS" do
-        ams_movies = build_ams_movies(movie_count)
-        movies = build_movies(movie_count)
-        our_json = nil
-        ams_json = nil
-
-        options = {}
-        options[:meta] = { total: movie_count }
-        options[:include] = [:actors, :movie_type]
-
-        our_serializer = MovieSerializer.new(movies, options)
-        ams_serializer = ActiveModelSerializers::SerializableResource.new(ams_movies, include: options[:include], meta: options[:meta])
-        our_time = Benchmark.measure { our_json = our_serializer.serialized_json }.real * 1000
-        ams_time = Benchmark.measure { ams_json = ams_serializer.to_json }.real * 1000
-        print_stats(movie_count, ams_time, our_time)
-        expect(our_json.length).to eq ams_json.length
-        expect { our_serializer.serialized_json }.to perform_faster_than { ams_serializer.to_json }.at_least(speed_factor).times
-      end
-    end
-  end
-end

data/spec/lib/object_serializer_spec.rb

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