cache_crispies 0.3.1 → 1.0.1

data/spec/cache_crispies/base_spec.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe CacheCrispies::Base do
+  class NutritionSerializer < CacheCrispies::Base
+    serialize :calories
+  end
+
+  class CacheCrispiesTestSerializer < CacheCrispies::Base
+    serialize :id, :company, to: String
+
+    show_if -> { true } do
+      show_if -> { true } do
+        show_if -> { true } do
+          serialize :name, from: :brand
+        end
+      end
+    end
+
+    nest_in :nested do
+      nest_in :nested_again do
+        serialize :deeply_nested do |model, _opts|
+          model.deeply_nested.to_s.upcase
+        end
+      end
+    end
+
+    serialize :nutrition_info, with: NutritionSerializer
+
+    serialize :organic, to: :bool
+    serialize :parent_company, through: :legal
+
+    def id
+      model.id.to_s
+    end
+  end
+
+  let(:model) do
+    OpenStruct.new(
+      id: 42,
+      brand: 'Cookie Crisp',
+      company: 'General Mills',
+      deeply_nested: true,
+      nutrition_info: OpenStruct.new(calories: 1_000),
+      organic: 'true',
+      legal: OpenStruct.new(parent_company: 'Disney probably')
+    )
+  end
+
+  let(:serializer) { CacheCrispiesTestSerializer }
+  let(:instance) { serializer.new(model) }
+  subject { instance }
+
+  describe '#as_json' do
+    it 'serializes to a hash' do
+      expect(subject.as_json).to eq(
+        id: '42',
+        name: 'Cookie Crisp',
+        company: 'General Mills',
+        nested: {
+          nested_again: {
+            deeply_nested: 'TRUE'
+          }
+        },
+        nutrition_info: {
+          calories: 1000
+        },
+        organic: true,
+        parent_company: 'Disney probably'
+      )
+    end
+  end
+
+  describe '.key' do
+    it 'underscores the demodulized class name by default' do
+      expect(serializer.key).to eq :cache_crispies_test
+    end
+
+    context 'with a custom key' do
+      after { serializer.remove_instance_variable :@key }
+
+      it 'sets and returns a custom key' do
+        expect {
+          serializer.key 'custom_key'
+        }.to change { serializer.key }.from(:cache_crispies_test).to :custom_key
+      end
+
+      it 'sets and returns a nil key' do
+        expect {
+          serializer.key nil
+        }.to change { serializer.key }.from(:cache_crispies_test).to nil
+      end
+    end
+  end
+
+  describe '.collection_key' do
+    it 'pluralizes the #key by default' do
+      expect(serializer.collection_key).to eq :cache_crispies_tests
+    end
+
+    context 'with a custom key' do
+      after { serializer.remove_instance_variable :@collection_key }
+
+      it 'sets and returns a custom key' do
+        expect {
+          serializer.collection_key 'custom_key'
+        }.to change {
+          serializer.collection_key
+        }.from(:cache_crispies_tests).to :custom_key
+      end
+
+      it 'sets and returns a nil key' do
+        expect {
+          serializer.collection_key nil
+        }.to change {
+          serializer.collection_key
+        }.from(:cache_crispies_tests).to nil
+      end
+    end
+  end
+
+  describe '.do_caching' do
+    it 'is false by default' do
+      expect(serializer.do_caching).to be false
+    end
+
+    context 'when called with an argument' do
+      after { serializer.remove_instance_variable :@do_caching }
+
+      it 'sets and returns a value' do
+        expect {
+          serializer.do_caching true
+        }.to change {
+          serializer.do_caching
+        }.from(false).to true
+      end
+    end
+  end
+
+  describe '.cache_key_addons' do
+    it 'returns an empty array by default' do
+      expect(serializer.cache_key_addons).to eq []
+    end
+
+    context 'when given a block' do
+      it 'stores the block for later execution' do
+        serializer.cache_key_addons { |opts| opts[:username].downcase }
+        expect(
+          serializer.cache_key_addons(username: 'CapnCrunch')
+        ).to eq ['capncrunch']
+      end
+
+      it 'returns nil' do
+        expect(serializer.cache_key_addons { |_opts| }).to be nil
+      end
+    end
+  end
+
+  describe '.dependency_key' do
+    it 'returns nil by default' do
+      expect(serializer.dependency_key).to be nil
+    end
+
+    context 'after being set' do
+      let(:key) { SecureRandom.hex }
+      before { serializer.dependency_key key }
+
+      it 'returns the set value' do
+        expect(serializer.dependency_key).to be key
+      end
+    end
+  end
+
+  describe '.cache_key_base' do
+    let(:nested_serializer_digest) { 'nutrition-serializer-digest' }
+    let(:serializer_file_path) {
+      File.expand_path('../fixtures/test_serializer.rb', __dir__)
+    }
+    let(:serializer_file_digest) {
+      Digest::MD5.file(serializer_file_path).to_s
+    }
+
+    before do
+      allow(NutritionSerializer).to receive(:file_hash).and_return(
+        nested_serializer_digest
+      )
+      allow(Rails).to receive_message_chain(:root, :join).and_return(
+        serializer_file_path
+      )
+    end
+
+    it 'includes the file name' do
+      expect(serializer.cache_key_base).to include serializer.to_s
+    end
+
+    it "includes a digest of the serializer class file's contents" do
+      expect(serializer.cache_key_base).to include serializer_file_digest
+    end
+
+    it "includes a digest of the nested serializer class file's contents" do
+      expect(serializer.cache_key_base).to include nested_serializer_digest
+    end
+
+    it 'correctly formats the key' do
+      expect(serializer.cache_key_base).to eq(
+        "#{serializer}-#{serializer_file_digest}+#{nested_serializer_digest}"
+      )
+    end
+  end
+
+  describe '.attributes' do
+    subject { instance.class.attributes }
+
+    it 'contains all the attributes' do
+      expect(subject.length).to eq 7
+    end
+
+    it 'preserves the attribute order' do
+      expect(subject.map(&:key)).to eq(
+        %i[id company name deeply_nested nutrition_info organic parent_company]
+      )
+    end
+
+    it 'contains the correct attribute values' do
+      expect(subject[0].method_name).to eq :id
+      expect(subject[0].key).to eq :id
+      expect(subject[0].serializer).to be nil
+      expect(subject[0].through).to be nil
+      expect(subject[0].coerce_to).to be String
+      expect(subject[0].nesting).to eq []
+      expect(subject[0].conditions).to eq []
+      expect(subject[0].block).to be nil
+
+      expect(subject[1].method_name).to eq :company
+      expect(subject[1].key).to eq :company
+      expect(subject[1].serializer).to be nil
+      expect(subject[1].through).to be nil
+      expect(subject[1].coerce_to).to be String
+      expect(subject[1].nesting).to eq []
+      expect(subject[1].conditions).to eq []
+      expect(subject[1].block).to be nil
+
+      expect(subject[2].method_name).to eq :brand
+      expect(subject[2].key).to eq :name
+      expect(subject[2].serializer).to be nil
+      expect(subject[2].through).to be nil
+      expect(subject[2].coerce_to).to be nil
+      expect(subject[2].nesting).to eq []
+      expect(subject[2].conditions.length).to be 3
+      expect(subject[2].block).to be nil
+
+      expect(subject[3].method_name).to eq :deeply_nested
+      expect(subject[3].key).to eq :deeply_nested
+      expect(subject[3].serializer).to be nil
+      expect(subject[3].through).to be nil
+      expect(subject[3].coerce_to).to be nil
+      expect(subject[3].nesting).to eq %i[nested nested_again]
+      expect(subject[3].conditions).to eq []
+      expect(subject[3].block).to be_a_kind_of Proc
+
+      expect(subject[4].method_name).to eq :nutrition_info
+      expect(subject[4].key).to eq :nutrition_info
+      expect(subject[4].serializer).to be NutritionSerializer
+      expect(subject[4].through).to be nil
+      expect(subject[4].coerce_to).to be nil
+      expect(subject[4].nesting).to eq []
+      expect(subject[4].conditions).to eq []
+      expect(subject[4].block).to be nil
+
+      expect(subject[5].method_name).to eq :organic
+      expect(subject[5].key).to eq :organic
+      expect(subject[5].serializer).to be nil
+      expect(subject[5].through).to be nil
+      expect(subject[5].coerce_to).to be :bool
+      expect(subject[5].nesting).to eq []
+      expect(subject[5].conditions).to eq []
+      expect(subject[5].block).to be nil
+
+      expect(subject[6].method_name).to eq :parent_company
+      expect(subject[6].key).to eq :parent_company
+      expect(subject[6].serializer).to be nil
+      expect(subject[6].through).to be :legal
+      expect(subject[6].coerce_to).to be nil
+      expect(subject[6].nesting).to eq []
+      expect(subject[6].conditions).to eq []
+      expect(subject[6].block).to be nil
+    end
+  end
+end

data/spec/{collection_spec.rb → cache_crispies/collection_spec.rb}

@@ -7,10 +7,7 @@ describe CacheCrispies::Collection do
 
   class CacheableCerealSerializerForCollection < CacheCrispies::Base
     serialize :name
-
-    def self.do_caching?
-      true
-    end
+    do_caching true
   end
 
   let(:name1) { 'Cinnamon Toast Crunch' }
@@ -35,8 +32,8 @@ describe CacheCrispies::Collection do
 
         it "doesn't cache the results" do
           expect(CacheCrispies::Plan).to_not receive(:new)
-          expect(Rails).to_not receive :cache
-          expect(subject.as_json).to eq [ {name: name1}, {name: name2} ]
+          expect(CacheCrispies).to_not receive :cache
+          expect(subject.as_json).to eq [{ name: name1 }, { name: name2 }]
         end
       end
 
@@ -45,29 +42,42 @@ describe CacheCrispies::Collection do
 
         it "doesn't cache the results" do
           expect(CacheCrispies::Plan).to_not receive(:new)
-          expect(Rails).to_not receive :cache
-          expect(subject.as_json).to eq [ {name: name1}, {name: name2} ]
+          expect(CacheCrispies).to_not receive :cache
+          expect(subject.as_json).to eq [{ name: name1 }, { name: name2 }]
         end
       end
     end
 
     context 'when it is cacheable' do
-      it 'caches the results' do
-        expect(CacheCrispies::Plan).to receive(:new).with(
-          serializer, model1, options
-        ).and_return double(cache_key: 'cereal-key-1')
+      context 'when the collection cache key misses' do
+        before do
+          allow(CacheCrispies).to receive_message_chain(
+            :cache, :fetch
+          ).with('cacheable-collection-key').and_yield
+        end
 
-        expect(CacheCrispies::Plan).to receive(:new).with(
-          serializer, model2, options
-        ).and_return double(cache_key: 'cereal-key-2')
+        it 'fetches the cache for each object in the collection' do
+          expect(CacheCrispies::Plan).to receive(:new).with(
+            serializer, model1, options
+          ).and_return double('plan-dbl-1', cache_key: 'cereal-key-1')
 
-        expect(Rails).to receive_message_chain(:cache, :fetch_multi).with(
-          %w[cereal-key-1 cereal-key-2]
-        ).and_yield('cereal-key-1').and_return(name: name1)
-          .and_yield('cereal-key-2').and_return(name: name2)
+          expect(CacheCrispies::Plan).to receive(:new).with(
+            serializer, model2, options
+          ).and_return double('plan-dbl-2', cache_key: 'cereal-key-2')
 
-        subject.as_json
+          expect(CacheCrispies).to receive_message_chain(
+            :cache, :fetch_multi
+          ).with(
+            'cereal-key-1', 'cereal-key-2'
+          ).and_yield('cereal-key-1').and_return(
+            name: name1
+          ).and_yield('cereal-key-2').and_return(
+            name: name2
+          )
+
+          subject.as_json
+        end
       end
     end
   end
-end
+end

data/spec/cache_crispies/configuration_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe CacheCrispies::Configuration do
+  describe '#cache_store' do
+    context 'when Rails.cache is defined' do
+      let(:cache_double) { double }
+      before { expect(Rails).to receive(:cache).and_return cache_double }
+
+      it 'is Rails.cache by default' do
+        expect(subject.cache_store).to be cache_double
+      end
+    end
+
+    context 'when Rails.cache is nil' do
+      before { expect(Rails).to receive(:cache).and_return nil }
+
+      it 'is NullStore by default' do
+        expect(subject.cache_store).to be_kind_of ActiveSupport::Cache::NullStore
+      end
+    end
+
+    it 'can be changed' do
+      cache_store = ActiveSupport::Cache::NullStore.new
+
+      expect {
+        subject.cache_store = cache_store
+      }.to change { subject.cache_store }.to cache_store
+    end
+  end
+
+  describe '#etags' do
+    it 'is false by default' do
+      expect(subject.etags).to be false
+    end
+
+    it 'can be changed' do
+      expect {
+        subject.etags = true
+      }.to change { subject.etags }.to true
+    end
+  end
+end

data/spec/cache_crispies/controller_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'active_model'
+require 'action_controller'
+
+describe CacheCrispies::Controller do
+  class Cereal
+    include ActiveModel::Model
+    attr_accessor :name
+  end
+
+  class CerealController < ActionController::Base
+    include CacheCrispies::Controller
+  end
+
+  class CerealSerializerForController < CacheCrispies::Base
+    key 'cereal'
+    serialize :name
+  end
+
+  let(:cereal_names) { ['Count Chocula', 'Eyeholes'] }
+  let(:collection) { cereal_names.map { |name| Cereal.new(name: name) } }
+
+  subject { CerealController.new }
+
+  describe '#cache_render' do
+    let(:etags) { false }
+    let(:single_json) { { cereal: { name: cereal_names.first } }.to_json }
+    let(:collection_json) {
+      { cereals: cereal_names.map { |name| { name: name } } }.to_json
+    }
+
+    before do
+      expect(
+        CacheCrispies
+      ).to receive_message_chain(:config, :etags?).and_return etags
+    end
+
+    context 'with etags disabled' do
+      it 'does not set etags' do
+        expect(subject).to receive(:render).with json: collection_json
+        response_double = double
+        allow(subject).to receive(:response).and_return response_double
+        expect(response_double).to_not receive(:weak_etag=)
+
+        subject.cache_render CerealSerializerForController, collection
+      end
+    end
+
+    context 'with etags enabled' do
+      let(:etags) { true }
+
+      it 'sets etags' do
+        expect(subject).to receive(:render).with json: collection_json
+        expect_any_instance_of(
+          CacheCrispies::Plan
+        ).to receive(:etag).and_return 'test-etag'
+        expect(subject).to receive_message_chain(:response, :weak_etag=).with 'test-etag'
+
+        subject.cache_render CerealSerializerForController, collection
+      end
+    end
+
+    it 'renders a json collection' do
+      expect(subject).to receive(:render).with json: collection_json
+
+      subject.cache_render CerealSerializerForController, collection
+    end
+
+    it 'renders a single json object' do
+      expect(subject).to receive(:render).with json: single_json
+
+      subject.cache_render CerealSerializerForController, collection.first
+    end
+
+    context 'with a status: option' do
+      it 'passes the status option to the Rails render call' do
+        expect(subject).to receive(:render).with(
+          json: single_json,
+          status: 418
+        )
+
+        subject.cache_render(
+          CerealSerializerForController,
+          collection.first,
+          status: 418
+        )
+      end
+    end
+  end
+end