fast_serializer 1.1.2 → 1.1.4

metadata

@@ -1,32 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: fast_serializer
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.4
 platform: ruby
 authors:
-- We Heart It
 - Brian Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-25 00:00:00.000000000 Z
+date: 2023-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,51 +24,16 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-description: Super fast object serialization for API's combining a simple DSL with
-  many optimizations under the hood.
+description:
 email:
-- dev@weheartit.com
 - bbdurand@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
-- Gemfile
-- Gemfile.lock
-- HISTORY.md
-- MIT_LICENSE
+- CHANGELOG.md
+- MIT_LICENSE.txt
 - README.md
-- Rakefile
 - VERSION
 - fast_serializer.gemspec
 - lib/fast_serializer.rb
@@ -93,19 +43,11 @@ files:
 - lib/fast_serializer/serialization_context.rb
 - lib/fast_serializer/serialized_field.rb
 - lib/fast_serializer/serializer.rb
-- spec/array_serializer_spec.rb
-- spec/cache/active_support_cache_spec.rb
-- spec/fast_serializer_spec.rb
-- spec/serialization_context_spec.rb
-- spec/serialized_field_spec.rb
-- spec/serializer_spec.rb
-- spec/spec_helper.rb
-- spec/support/test_models.rb
-homepage: https://github.com/weheartit/fast_serializer
+homepage: https://github.com/bdurand/fast_serializer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,23 +55,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.12
+signing_key:
 specification_version: 4
-summary: Super fast object serialization for API's.
-test_files:
-- spec/array_serializer_spec.rb
-- spec/cache/active_support_cache_spec.rb
-- spec/fast_serializer_spec.rb
-- spec/serialization_context_spec.rb
-- spec/serialized_field_spec.rb
-- spec/serializer_spec.rb
-- spec/spec_helper.rb
-- spec/support/test_models.rb
+summary: Super fast object serialization for API's combining a simple DSL with many
+  optimizations under the hood.
+test_files: []

data/.gitignore

@@ -1,6 +0,0 @@
-pkg
-tmp
-rdoc
-*.rbc
-.tm_properties
-.DS_Store

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-
-rvm:
-  - "2.6"
-
-gemfile:
-  - Gemfile

data/Gemfile

@@ -1,2 +0,0 @@
-source 'https://rubygems.org'
-gemspec

data/Gemfile.lock

@@ -1,50 +0,0 @@
-PATH
-  remote: .
-  specs:
-    fast_serializer (1.1.2)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (6.0.2.1)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    concurrent-ruby (1.1.5)
-    diff-lcs (1.3)
-    i18n (1.8.2)
-      concurrent-ruby (~> 1.0)
-    minitest (5.14.0)
-    rake (13.0.1)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
-    thread_safe (0.3.6)
-    tzinfo (1.2.6)
-      thread_safe (~> 0.1)
-    zeitwerk (2.2.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (>= 4.0)
-  bundler (~> 2.0)
-  fast_serializer!
-  rake
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   2.1.4

data/HISTORY.md

@@ -1,30 +0,0 @@
-### 1.1.2
-
-* Handle converting ActiveSupport::TimeWithZone to a Time so it can be better dumped to non-JSON formats.
-* Sanity check for unsupported options
-
-### 1.1.1
-
-* Add `array` class method to serializers.
-
-### 1.1.0
-
-* Add helper method for scope option.
-
-* Pass serialization options to child serializers.
-
-* Add `if` option to conditionally include fields.
-
-* Better cache keys handling for more complex objects.
-
-### 1.0.2
-
-* Better integration with ActiveSupport caching.
-
-### 1.0.1
-
-* Compatibility with change to fetch_multi in ActiveSupport 4.2.
-
-### 1.0.0
-
-* Initial release

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec

data/spec/array_serializer_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe FastSerializer::ArraySerializer do
-
-  it "should serialize an array of regular objects" do
-    array = [1, 2, 3]
-    serializer = FastSerializer::ArraySerializer.new(array)
-    expect(serializer.as_json).to eq array
-  end
-
-  it "should serialize any Enumerable" do
-    hash = {:a => 1, :b => 2}
-    serializer = FastSerializer::ArraySerializer.new(hash)
-    expect(serializer.as_json).to eq hash.to_a
-  end
-
-  it "should serializer an array of objects using a specific serializer" do
-    model_1 = SimpleModel.new(:id => 1, :name => "foo")
-    model_2 = SimpleModel.new(:id => 2, :name => "bar")
-    serializer = FastSerializer::ArraySerializer.new([model_1, model_2], :serializer => SimpleSerializer)
-    expect(JSON.load(serializer.to_json)).to eq [
-      {"id" => 1, "name" => "foo", "validated" => false},
-      {"id" => 2, "name" => "bar", "validated" => false}
-    ]
-  end
-
-  it "should serializer an array of objects using a specific serializer with options" do
-    model_1 = SimpleModel.new(:id => 1, :name => "foo")
-    model_2 = SimpleModel.new(:id => 2, :name => "bar")
-    serializer = FastSerializer::ArraySerializer.new([model_1, model_2], :serializer => SimpleSerializer, :serializer_options => {:include => :description})
-    expect(JSON.load(serializer.to_json)).to eq [
-      {"id" => 1, "name" => "foo", "validated" => false, "description" => nil},
-      {"id" => 2, "name" => "bar", "validated" => false, "description" => nil}
-    ]
-  end
-
-  it "should be able to use the array helper method on a serializer to serialize an array of objects" do
-    model_1 = SimpleModel.new(:id => 1, :name => "foo")
-    model_2 = SimpleModel.new(:id => 2, :name => "bar")
-    array_serializer = FastSerializer::ArraySerializer.new([model_1, model_2], :serializer => SimpleSerializer, :serializer_options => {:include => :description})
-    helper_serializer = SimpleSerializer.array([model_1, model_2], :serializer_options => {:include => :description})
-    expect(array_serializer.to_json).to eq helper_serializer.to_json
-  end
-
-  it "should not respond to_hash methods" do
-    array = [1, 2, 3]
-    serializer = FastSerializer::ArraySerializer.new(array)
-    expect(serializer.respond_to?(:to_hash)).to eq false
-    expect(serializer.respond_to?(:to_h)).to eq false
-  end
-
-  it "should respond to to_a" do
-    array = [1, 2, 3]
-    serializer = FastSerializer::ArraySerializer.new(array)
-    expect(serializer.to_a).to eq array
-  end
-
-  it "should pull cacheable serializers from a cache" do
-    model_1 = SimpleModel.new(:id => 1, :name => "foo")
-    model_2 = SimpleModel.new(:id => 2, :name => "bar")
-    serializer = FastSerializer::ArraySerializer.new([model_1, model_2], serializer: CachedSerializer)
-    expect(serializer.cacheable?).to eq true
-    already_cached_json = CachedSerializer.new(model_1).as_json
-    expect(serializer.as_json.collect(&:object_id)).to eq [already_cached_json.object_id, CachedSerializer.new(model_2).as_json.object_id]
-  end
-
-end

data/spec/cache/active_support_cache_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe FastSerializer::Cache::ActiveSupportCache do
-
-  it "should fetch from an ActiveSupport cache store" do
-    cache_store = ActiveSupport::Cache::MemoryStore.new
-    cache = FastSerializer::Cache::ActiveSupportCache.new(cache_store)
-    serializer = SimpleSerializer.new(SimpleModel.new(:id => 1))
-
-    expect(cache.fetch(serializer, 60){|s| s.as_json} ).to eq serializer.as_json
-    expect(cache.fetch(serializer, 60){ raise "boom" }).to eq serializer.as_json
-  end
-
-  it "should fetch multiple from an ActiveSupport cache store" do
-    cache_store = ActiveSupport::Cache::MemoryStore.new
-    cache = FastSerializer::Cache::ActiveSupportCache.new(cache_store)
-    s1 = SimpleSerializer.new(SimpleModel.new(:id => 1))
-    s2 = SimpleSerializer.new(SimpleModel.new(:id => 2))
-
-    expect(cache.fetch_all([s1, s2], 60){|s| s.as_json} ).to eq [s1.as_json, s2.as_json]
-    expect(cache.fetch_all([s1, s2], 60){ raise "boom" }).to eq [s1.as_json, s2.as_json]
-  end
-
-end

data/spec/fast_serializer_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe FastSerializer do
-
-  it "should be able to set and get a global cache" do
-    expect(FastSerializer.cache).to eq nil
-    begin
-      cache = TestCache.new
-      FastSerializer.cache = cache
-      expect(FastSerializer.cache).to eq cache
-    ensure
-      FastSerializer.cache = nil
-    end
-    expect(FastSerializer.cache).to eq nil
-  end
-
-  it "should set the cache to Rails.cache with the value :rails" do
-    begin
-      rails = double(:cache => :rails_cache)
-      stub_const("Rails", rails)
-      FastSerializer.cache = :rails
-      expect(FastSerializer.cache).to be_a FastSerializer::Cache::ActiveSupportCache
-      expect(FastSerializer.cache.cache).to eq :rails_cache
-    ensure
-      FastSerializer.cache = nil
-    end
-  end
-
-  it "should set the cache with an ActiveSupport cache" do
-    begin
-      cache_store = ActiveSupport::Cache::MemoryStore.new
-      FastSerializer.cache = cache_store
-      expect(FastSerializer.cache).to be_a FastSerializer::Cache::ActiveSupportCache
-      expect(FastSerializer.cache.cache).to eq cache_store
-    ensure
-      FastSerializer.cache = nil
-    end
-  end
-
-end

data/spec/serialization_context_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe FastSerializer::SerializationContext do
-
-  it "should get a single context only within a block" do
-    expect(FastSerializer::SerializationContext.current).to eq nil
-    FastSerializer::SerializationContext.use do
-      context = FastSerializer::SerializationContext.current
-      expect(FastSerializer::SerializationContext.current).to_not eq nil
-      FastSerializer::SerializationContext.use do
-        expect(FastSerializer::SerializationContext.current).to eq context
-      end
-      expect(FastSerializer::SerializationContext.current).to eq context
-    end
-    expect(FastSerializer::SerializationContext.current).to eq nil
-  end
-
-  it "should create serializers and reload them from cache with the same object and options" do
-    context = FastSerializer::SerializationContext.new
-    object = SimpleModel.new(:id => 1, :name => "foo")
-
-    serializer = context.load(SimpleSerializer, object, :count => 1)
-    expect(serializer).to be_a SimpleSerializer
-    expect(serializer.object).to eq object
-    expect(serializer.options).to eq(:count => 1)
-
-    expect(context.load(SimpleSerializer, object, :count => 1).object_id).to eq serializer.object_id
-    expect(context.load(SimpleSerializer, SimpleModel.new(:id => 2, :name => "bar"), :count => 1).object_id).to_not eq serializer.object_id
-    expect(context.load(SimpleSerializer, object, :count => 2).object_id).to_not eq serializer.object_id
-  end
-
-end

data/spec/serialized_field_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe FastSerializer::SerializedField do
-
-  let(:field){ FastSerializer::SerializedField.new(:test) }
-  let(:model){ SimpleModel.new(:id => 1, :name => "foo") }
-
-  it "should integers" do
-    expect(field.serialize(1)).to eq 1
-  end
-
-  it "should serialize floats" do
-    expect(field.serialize(1.5)).to eq 1.5
-  end
-
-  it "should serialize strings" do
-    expect(field.serialize("foo")).to eq "foo"
-  end
-
-  it "should serialize symbols" do
-    expect(field.serialize(:foo)).to eq :foo
-  end
-
-  it "should serialize nil" do
-    expect(field.serialize(nil)).to eq nil
-  end
-
-  it "should serialize booleans" do
-    expect(field.serialize(true)).to eq true
-    expect(field.serialize(false)).to eq false
-  end
-
-  it "should serialize times" do
-    time = Time.now
-    expect(field.serialize(time)).to eq time
-  end
-
-  it "should serialize dates" do
-    date = Date.today
-    expect(field.serialize(date)).to eq date
-  end
-
-  it "should serialize datetimes" do
-    datetime = DateTime.now
-    expect(field.serialize(datetime)).to eq datetime
-  end
-
-  it "should serialize ActiveSupport::TimeWithZone as a DateTime" do
-    time = ActiveSupport::TimeZone.new("UTC").now
-    expect(field.serialize(time)).to eq time
-    expect(field.serialize(time).class).to eq Time
-  end
-
-  it "should serialize a field using a specified serializer" do
-    field = FastSerializer::SerializedField.new(:test, serializer: SimpleSerializer)
-    expect(field.serialize(model)).to eq({:id => 1, :name => "foo", :validated => false})
-  end
-
-  it "should serialize an enumerable field using a specified serializer" do
-    field = FastSerializer::SerializedField.new(:test, serializer: SimpleSerializer, enumerable: true)
-    expect(field.serialize(model)).to eq([{:id => 1, :name => "foo", :validated => false}])
-  end
-
-  it "should serialize a field value by calling as_json on the field" do
-    expect(field.serialize(model)).to eq({:id => 1, :name => "foo", :description => nil, :number => nil})
-  end
-
-  it "should serialize a hash of objects" do
-    expect(field.serialize(:name => "Test", :object => model)).to eq({
-      :name => "Test",
-      :object => {:id => 1, :name => "foo", :description => nil, :number => nil}
-    })
-  end
-
-  it "should serialize an array of objects" do
-    expect(field.serialize([model, model])).to eq([
-      {:id => 1, :name => "foo", :description => nil, :number => nil},
-      {:id => 1, :name => "foo", :description => nil, :number => nil}
-    ])
-  end
-
-end

data/spec/serializer_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-
-describe FastSerializer::Serializer do
-
-  let(:model){ SimpleModel.new(:id => 1, :name => "foo", :description => "foobar", :number => 12) }
-
-  it "should serialize object to JSON compatible format" do
-    serializer = SimpleSerializer.new(model)
-    expect(serializer.as_json).to eq({:id => 1, :name => "foo", :validated => false})
-    expect(serializer.to_hash).to eq({:id => 1, :name => "foo", :validated => false})
-    expect(serializer.to_h).to eq({:id => 1, :name => "foo", :validated => false})
-  end
-
-  it "should serialize nil as nil" do
-    expect(SimpleSerializer.new(nil).as_json).to eq nil
-  end
-
-  it "should include optional fields only if included in the options" do
-    expect(SimpleSerializer.new(model).as_json).to eq({:id => 1, :name => "foo", :validated => false})
-    expect(SimpleSerializer.new(model, :include => :nothing).as_json).to eq({:id => 1, :name => "foo", :validated => false})
-    expect(SimpleSerializer.new(model, :include => :description).as_json).to eq({:id => 1, :name => "foo", :validated => false, :description => "foobar"})
-    expect(SimpleSerializer.new(model, :include => ["description"]).as_json).to eq({:id => 1, :name => "foo", :validated => false, :description => "foobar"})
-  end
-
-  it "should exclude specified fields" do
-    expect(SimpleSerializer.new(model, :exclude => :name).as_json).to eq({:id => 1, :validated => false})
-    expect(SimpleSerializer.new(model, :exclude => ["id", "validated"]).as_json).to eq({:name => "foo"})
-  end
-
-  it "should allow aliasing fields" do
-    number_model = SimpleModel.new(:number => 50.5)
-    expect(SimpleSerializer.new(number_model, :include => :amount).as_json).to eq({:id => nil, :name => nil, :validated => false, :amount => 50.5})
-  end
-
-  it "should pull cached serializers from a cache" do
-    serializer = SimpleSerializer.new(model)
-    cached_serializer = CachedSerializer.new(model)
-
-    expect(serializer.cacheable?).to eq false
-    expect(cached_serializer.cacheable?).to eq true
-
-    expect(serializer.cache_ttl).to eq nil
-    expect(cached_serializer.cache_ttl).to eq 2
-
-    expect(cached_serializer.as_json).to eq serializer.as_json
-    expect(cached_serializer.as_json.object_id).to eq cached_serializer.as_json.object_id
-  end
-
-  it "should allow setting cache and ttl on parent serializers" do
-    class SubCacheSerializer1 < CachedSerializer
-      self.cache_ttl = 5
-      self.cache = :mock
-    end
-
-    class SubCacheSerializer2 < CachedSerializer
-    end
-
-    expect(SubCacheSerializer1.cacheable?).to eq true
-    expect(SubCacheSerializer2.cacheable?).to eq true
-
-    expect(SubCacheSerializer1.cache).to eq :mock
-    expect(SubCacheSerializer2.cache).to eq CachedSerializer.cache
-
-    expect(SubCacheSerializer1.cache_ttl).to eq 5
-    expect(SubCacheSerializer2.cache_ttl).to eq 2
-  end
-
-  it "should allow setting cache and ttl on instances" do
-    serializer = SimpleSerializer.new(model, :cacheable => true, :cache => :mock, :cache_ttl => 10)
-    expect(serializer.cacheable?).to eq true
-    expect(serializer.cache).to eq :mock
-    expect(serializer.cache_ttl).to eq 10
-  end
-
-  it "should get the cache from the global setting by default" do
-    class SubCacheSerializerGlobalInheritTest
-      include FastSerializer::Serializer
-      self.cacheable
-    end
-
-    expect(SubCacheSerializerGlobalInheritTest.cache).to eq nil
-    allow(FastSerializer).to receive_messages(:cache => :mock)
-    expect(SubCacheSerializerGlobalInheritTest.cache).to eq :mock
-  end
-
-  it "should not break on cached serializers if no cache is set" do
-    serializer = CachedSerializer.new(model, :cache => nil)
-    expect(serializer.as_json).to eq({:id => 1, :name => "foo", :validated => false})
-  end
-
-  it "should serialize complex objects" do
-    other_model = SimpleModel.new(:id => 3, :name => "other")
-    complex = SimpleModel.new(:id => 2, :name => :complex, :parent => model, :associations => [model, other_model])
-    serializer = ComplexSerializer.new(complex, :serial_number => 15)
-    expect(serializer.as_json).to eq({
-      :id => 2, :name => :complex, :validated => false, :serial_number => 15,
-      :associations => [
-        {:id => 1, :name => "foo", :validated => false},
-        {:id => 3, :name => "other", :validated => false}
-      ],
-      :parent => {:id => 1, :name => "foo", :validated => false}
-    })
-  end
-
-  it "should pass include and exclude options to child serializers" do
-    other_model = SimpleModel.new(:id => 3, :name => "other")
-    complex = SimpleModel.new(:id => 2, :name => :complex, :parent => model, :associations => [model, other_model])
-    serializer = ComplexSerializer.new(complex, :serial_number => 15, :exclude => {:associations => [:validated]}, :include => {:parent => :amount})
-    expect(serializer.as_json).to eq({
-      :id => 2, :name => :complex, :validated => false, :serial_number => 15,
-      :associations => [
-        {:id => 1, :name => "foo"},
-        {:id => 3, :name => "other"}
-      ],
-      :parent => {:id => 1, :name => "foo", :validated => false, :amount => 12}
-    })
-  end
-
-  it "should have a scope option" do
-    serializer = CachedSerializer.new(model, :scope => :foo)
-    expect(serializer.scope).to eq :foo
-  end
-
-  it "should return identical serialized values for serializers on the same object and options inside the same context" do
-    other_model = SimpleModel.new(:id => 3, :name => "other")
-    complex = SimpleModel.new(:id => 2, :name => "complex", :associations => [model, other_model, model])
-    serializer = ComplexSerializer.new(complex)
-    json = serializer.as_json
-    expect(json[:associations][0].object_id).to_not eq json[:associations][1].object_id
-    expect(json[:associations][0].object_id).to eq json[:associations][2].object_id
-  end
-
-  it "should dump the object to JSON" do
-    complex = SimpleModel.new(:id => 2, :name => "complex", :parent => model, :associations => [model])
-    serializer = ComplexSerializer.new(complex)
-    expect(JSON.load(serializer.to_json)).to eq({
-      "id" => 2,
-      "name" => "complex",
-      "validated" => false,
-      "serial_number" => nil,
-      "associations" => [
-        {"id" => 1, "name" => "foo", "validated" => false}
-      ],
-      "parent" => {"id" => 1, "name" => "foo", "validated" => false, "description"=>"foobar"}
-    })
-  end
-
-  it "should allow passing options for JSON dumping" do
-    complex = SimpleModel.new(:id => 2, :name => "complex", :parent => model, :associations => [model])
-    serializer = ComplexSerializer.new(complex)
-    expect(serializer.to_json(:pretty => true)).to be_a(String)
-  end
-
-  it "should expose options from the options hash by name" do
-    serializer = CachedSerializer.new(model, :foo => "bar")
-    expect(serializer.option(:foo)).to eq "bar"
-    expect(serializer.option(:other)).to eq nil
-  end
-
-  it "should return nil value for options if none are set" do
-    serializer = CachedSerializer.new(model, nil)
-    expect(serializer.option(:foo)).to eq nil
-  end
-
-  it "should not get into infinite loops" do
-    model = SimpleModel.new(:id => 1)
-    model.parent = model
-    serializer = CircularSerializer.new(model)
-    expect{ serializer.as_json }.to raise_error(FastSerializer::CircularReferenceError)
-  end
-
-  it "should allow conditionals on serialized fields" do
-    expect(ConditionalSerializer.new(model).as_json).to eq({:id => 1})
-    expect(ConditionalSerializer.new(model, :scope => :description).as_json).to eq({:id => 1,  :description => "foobar"})
-    expect(ConditionalSerializer.new(model, :scope => :name).as_json).to eq({:id => 1,  :name => "foo"})
-  end
-end