mongoid-cached-json 1.5.1 → 1.5.2

data/spec/config_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Mongoid::CachedJson::Config do
+  before :each do
+    @cache = Mongoid::CachedJson::Config.cache
+  end
+  after :each do
+    Mongoid::CachedJson::Config.cache = @cache
+  end
+  it 'configures a cache store' do
+    cache = Class.new
+    Mongoid::CachedJson.configure do |config|
+      config.cache = cache
+    end
+    expect(cache).to receive(:fetch).once
+    JsonFoobar.new.as_json
+  end
+  it 'sets disable_caching to false' do
+    expect(Mongoid::CachedJson.config.disable_caching).to be_falsey
+  end
+end

data/spec/dalli_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'active_support/cache/dalli_store'
+
+describe ActiveSupport::Cache::DalliStore do
+  before :each do
+    @cache = Mongoid::CachedJson::Config.cache
+    Mongoid::CachedJson.configure do |config|
+      config.cache = ActiveSupport::Cache.lookup_store(:dalli_store)
+    end
+  end
+  after :each do
+    Mongoid::CachedJson::Config.cache = @cache
+  end
+  it 'uses dalli_store' do
+    expect(Mongoid::CachedJson.config.cache).to be_a ActiveSupport::Cache::DalliStore
+  end
+  context 'read_multi' do
+    context 'array' do
+      it 'uses a local cache to fetch repeated objects' do
+        options = { properties: :all, is_top_level_json: true, version: :unspecified }
+        tool1 = Tool.create!(name: 'hammer')
+        tool1_key = Tool.cached_json_key(options, Tool, tool1.id)
+        tool2 = Tool.create!(name: 'screwdriver')
+        tool2_key = Tool.cached_json_key(options, Tool, tool2.id)
+        expect(Mongoid::CachedJson.config.cache).not_to receive(:fetch)
+        expect(Mongoid::CachedJson.config.cache).to receive(:read_multi).with(tool1_key, tool2_key).once.and_return(
+          tool1_key => { _id: tool1.id.to_s },
+          tool2_key => { _id: tool2.id.to_s }
+        )
+        expect([tool1, tool2].as_json(properties: :all)).to eq([
+          { tool_box: nil, _id: tool1.id.to_s },
+          { tool_box: nil, _id: tool2.id.to_s }
+        ])
+      end
+    end
+  end
+end

data/spec/hash_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Hash do
+  it 'hash' do
+    expect({ x: 'x', y: 'y' }.as_json).to eq(x: 'x', y: 'y')
+  end
+  it 'materializes multiple objects that may or may not respond to as_json_partial' do
+    foobar1 = JsonFoobar.create(foo: 'FOO1', baz: 'BAZ', bar: 'BAR')
+    foobar2 = JsonFoobar.create(foo: 'FOO2', baz: 'BAZ', bar: 'BAR')
+    expect({
+      :x => :y,
+      :foobar1 => foobar1,
+      :foobar2 => foobar2,
+      :z => {
+        foobar1: foobar1
+      },
+      :t => [foobar1, :y],
+      'empty' => []
+    }.as_json).to eq(
+      :x => 'y',
+      :foobar1 => { :foo => 'FOO1', 'Baz' => 'BAZ', :default_foo => 'DEFAULT_FOO' },
+      :foobar2 => { :foo => 'FOO2', 'Baz' => 'BAZ', :default_foo => 'DEFAULT_FOO' },
+      :z => { foobar1: { :foo => 'FOO1', 'Baz' => 'BAZ', :default_foo => 'DEFAULT_FOO' } },
+      :t => [{ :foo => 'FOO1', 'Baz' => 'BAZ', :default_foo => 'DEFAULT_FOO' }, 'y'],
+      'empty' => []
+    )
+  end
+  context 'without read_multi' do
+    before :each do
+      Mongoid::CachedJson.config.cache.instance_eval { undef :read_multi }
+    end
+    it 'uses a local cache to fetch repeated objects' do
+      tool = Tool.create!(name: 'hammer')
+      expect(Mongoid::CachedJson.config.cache).to receive(:fetch).once.and_return(
+        x: :y
+      )
+      expect({
+        t1: tool,
+        t2: tool,
+        t3: tool
+      }.as_json(properties: :all)).to eq(
+        t1: { tool_box: nil, x: :y },
+        t2: { tool_box: nil, x: :y },
+        t3: { tool_box: nil, x: :y }
+      )
+    end
+  end
+  context 'with read_multi' do
+    it 'uses a local cache to fetch repeated objects' do
+      tool = Tool.create!(name: 'hammer')
+      tool_key = "as_json/unspecified/Tool/#{tool.id}/all/true"
+      expect(Mongoid::CachedJson.config.cache).to receive(:read_multi).once.with(tool_key).and_return(
+        tool_key => { x: :y }
+      )
+      expect({
+        t1: tool,
+        t2: tool,
+        t3: tool
+      }.as_json(properties: :all)).to eq(
+        t1: { tool_box: nil, x: :y },
+        t2: { tool_box: nil, x: :y },
+        t3: { tool_box: nil, x: :y }
+      )
+    end
+  end
+end

data/spec/mongoid_criteria_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Mongoid::Criteria do
+  it 'mongoid_criteria' do
+    tool_box = ToolBox.create!(color: 'red')
+    Tool.create!(name: 'hammer', tool_box: tool_box)
+    Tool.create!(name: 'screwdriver', tool_box: tool_box)
+    expect(Tool.where(tool_box_id: tool_box.id).as_json(properties: :all)).to eq([
+      { tool_box: { color: 'red' }, name: 'hammer' },
+      { tool_box: { color: 'red' }, name: 'screwdriver' }
+    ])
+  end
+  context 'without read_multi' do
+    before :each do
+      Mongoid::CachedJson.config.cache.instance_eval { undef :read_multi }
+    end
+    it 'materializes multiple objects using a single partial' do
+      tool_box = ToolBox.create!(color: 'red')
+      Tool.create!(name: 'hammer', tool_box: tool_box)
+      Tool.create!(name: 'screwdriver', tool_box: tool_box)
+      # once per tool and once for the tool box
+      expect(Mongoid::CachedJson.config.cache).to receive(:fetch).exactly(3).times.and_return(
+        x: :y
+      )
+      expect(tool_box.tools.as_json(properties: :all)).to eq([
+        { tool_box: { x: :y }, x: :y },
+        { tool_box: { x: :y }, x: :y }
+      ])
+    end
+  end
+  context 'with read_multi' do
+    it 'responds to read_multi' do
+      expect(Mongoid::CachedJson.config.cache).to respond_to :read_multi
+    end
+    it 'materializes multiple objects using a single partial' do
+      tool_box = ToolBox.create!(color: 'red')
+      tool1 = Tool.create!(name: 'hammer', tool_box: tool_box)
+      tool2 = Tool.create!(name: 'screwdriver', tool_box: tool_box)
+      # once per tool and once for the tool box
+      keys = [
+        "as_json/unspecified/Tool/#{tool1.id}/all/true",
+        "as_json/unspecified/ToolBox/#{tool_box.id}/all/false",
+        "as_json/unspecified/Tool/#{tool2.id}/all/true"
+      ]
+      expect(Mongoid::CachedJson.config.cache).to receive(:read_multi).once.with(*keys).and_return(
+        keys[0] => { x: :y },
+        keys[1] => { x: :y },
+        keys[2] => { x: :y }
+      )
+      expect(tool_box.tools.as_json(properties: :all)).to eq([
+        { tool_box: { x: :y }, x: :y },
+        { tool_box: { x: :y }, x: :y }
+      ])
+    end
+    it 'does not call fetch for missing objects, only write' do
+      tool_box = ToolBox.create!(color: 'red')
+      tool1 = Tool.create!(name: 'hammer', tool_box: tool_box)
+      tool2 = Tool.create!(name: 'screwdriver', tool_box: tool_box)
+      # once per tool and once for the tool box
+      keys = [
+        "as_json/unspecified/Tool/#{tool1.id}/all/true",
+        "as_json/unspecified/ToolBox/#{tool_box.id}/all/false",
+        "as_json/unspecified/Tool/#{tool2.id}/all/true"
+      ]
+      expect(Mongoid::CachedJson.config.cache).to receive(:read_multi).once.with(*keys).and_return(
+        keys[0] => { x: :y },
+        keys[1] => { x: :y }
+      )
+      # read_multi returned only 2 of 3 things, don't call fetch, just store the third value
+      expect(Mongoid::CachedJson.config.cache).not_to receive(:fetch)
+      expect(Mongoid::CachedJson.config.cache).to receive(:write).with("as_json/unspecified/Tool/#{tool2.id}/all/true",  name: 'screwdriver')
+      expect(tool_box.tools.as_json(properties: :all)).to eq([
+        { tool_box: { x: :y }, x: :y },
+        { tool_box: { x: :y }, name: 'screwdriver' }
+      ])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'mongoid-cached-json'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
+  require f
+end
+
+Mongoid.configure do |config|
+  config.connect_to('cached_json_test')
+end
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.after :each do
+    Mongoid::CachedJson.config.reset!
+  end
+end

data/spec/support/awesome_artwork.rb

@@ -0,0 +1,11 @@
+class AwesomeArtwork
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name
+  has_one :awesome_image
+
+  json_fields \
+    name: {},
+    image: { type: :reference, definition: :awesome_image }
+end

data/spec/support/awesome_image.rb

@@ -0,0 +1,14 @@
+class AwesomeImage
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name
+  field :nickname, default: 'Mona'
+  field :url, default: 'http://example.com/404.html'
+  belongs_to :awesome_artwork
+
+  json_fields \
+    name: {},
+    nickname: {},
+    url: { properties: :public }
+end

data/spec/support/fast_json_artwork.rb

@@ -0,0 +1,15 @@
+class FastJsonArtwork
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name, default: 'Artwork'
+  field :display_name, default: 'Awesome Artwork'
+  field :price, default: 1000
+  has_one :fast_json_image
+
+  json_fields \
+    name: {},
+    display_name: { properties: :public },
+    price: { properties: :all },
+    image: { type: :reference, definition: :fast_json_image }
+end

data/spec/support/fast_json_image.rb

@@ -0,0 +1,12 @@
+class FastJsonImage
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name, default: 'Image'
+  belongs_to :fast_json_artwork
+  has_and_belongs_to_many :fast_json_urls
+
+  json_fields \
+    name: {},
+    urls: { type: :reference, definition: :fast_json_urls }
+end

data/spec/support/fast_json_url.rb

@@ -0,0 +1,12 @@
+class FastJsonUrl
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :url, default: 'http://art.sy/omg.jpeg'
+  field :is_public, default: false
+  has_and_belongs_to_many :fast_json_image
+
+  json_fields \
+    url: {},
+    is_public: { properties: :all }
+end

data/spec/support/json_embedded_foobar.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'json_polymorphic_embedded_foobar')
+
+class JsonEmbeddedFoobar < JsonPolymorphicEmbeddedFoobar
+  field :foo, type: String
+end

data/spec/support/json_employee.rb

@@ -0,0 +1,12 @@
+class JsonEmployee
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name
+  field :nickname, default: 'My Favorite'
+  belongs_to :json_manager
+
+  json_fields \
+    name: {},
+    nickname: { properties: :all }
+end

data/spec/support/json_foobar.rb

@@ -0,0 +1,19 @@
+class JsonFoobar
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :foo
+  field :bar
+  field :baz
+  field :default_foo, default: 'DEFAULT_FOO'
+
+  json_fields \
+    :foo => { properties: :short },
+    :bar => { properties: :public },
+    'Baz' => { definition: :baz, version: :unspecified },
+    'Taz' => { definition: :baz, version: :v2 },
+    'Naz' => { definition: :baz, versions: [:v2, :v3] },
+    :renamed_baz => { properties: :all, definition: :baz },
+    :default_foo => {}, # default value for properties is :short
+    :computed_field => { properties: :all, definition: lambda { |x| "#{x.foo}#{x.bar}" } }
+end

data/spec/support/json_manager.rb

@@ -0,0 +1,14 @@
+class JsonManager
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name
+  field :ssn, default: '123-45-6789'
+  has_many :json_employees
+  belongs_to :supervisor, class_name: 'JsonSupervisor'
+
+  json_fields \
+    name: {},
+    ssn: { properties: :all },
+    employees: { type: :reference, definition: :json_employees }
+end

data/spec/support/json_math.rb

@@ -0,0 +1,9 @@
+class JsonMath
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :number
+
+  json_fields \
+    number: {}
+end

data/spec/support/json_parent_foobar.rb

@@ -0,0 +1,11 @@
+class JsonParentFoobar
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  belongs_to :json_polymorphic_referenced_foobar
+  embeds_one :json_polymorphic_embedded_foobar
+
+  json_fields \
+    json_polymorphic_referenced_foobar: { type: :reference },
+    json_polymorphic_embedded_foobar: { type: :reference }
+end

data/spec/support/json_polymorphic_embedded_foobar.rb

@@ -0,0 +1,9 @@
+class JsonPolymorphicEmbeddedFoobar
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  embedded_in :json_parent_foobar
+
+  json_fields \
+    foo: { properties: :short }
+end

data/spec/support/json_polymorphic_referenced_foobar.rb

@@ -0,0 +1,9 @@
+class JsonPolymorphicReferencedFoobar
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  has_one :json_parent_foobar
+
+  json_fields \
+    foo: { properties: :short }
+end

data/spec/support/json_referenced_foobar.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'json_polymorphic_referenced_foobar')
+
+class JsonReferencedFoobar < JsonPolymorphicReferencedFoobar
+  field :foo, type: String
+end

data/spec/support/json_supervisor.rb

@@ -0,0 +1,13 @@
+class JsonSupervisor
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :name
+  field :ssn, default: '123-45-6789'
+  has_many :json_managers
+
+  json_fields \
+    name: {},
+    ssn: { properties: :all },
+    managers: { type: :reference, definition: :json_managers, properties: :all, reference_properties: :short }
+end

data/spec/support/json_transform.rb

@@ -0,0 +1,13 @@
+class JsonTransform
+  include Mongoid::Document
+  include Mongoid::CachedJson
+
+  field :upcase
+  field :downcase
+  field :nochange
+
+  json_fields \
+    upcase: { transform: :upcase },
+    downcase: { transform: :downcase },
+    nochange: {}
+end