cache_crispies 0.1.0

data/spec/base_spec.rb

@@ -0,0 +1,153 @@
+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
+      end
+    end
+
+    serialize :nutrition_info, with: NutritionSerializer
+
+    serialize :organic, to: :bool
+
+    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'
+      )
+  end
+
+  let(:instance) { CacheCrispiesTestSerializer.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
+      )
+    end
+  end
+
+  describe '.key' do
+    it 'underscores the demodulized class name' do
+      expect(subject.class.key).to eq :cache_crispies_test
+    end
+  end
+
+  describe '.collection_key' do
+    it 'pluralizes the #key' do
+      expect(subject.class.collection_key).to eq :cache_crispies_tests
+    end
+  end
+
+  describe '.do_caching?' do
+    it 'is false by default' do
+      expect(subject.class.do_caching?).to be false
+    end
+  end
+
+  describe '.cache_key_addons' do
+    it 'returns an empty array by default' do
+      expect(subject.class.cache_key_addons).to eq []
+    end
+  end
+
+  describe '.cache_key_base' do
+    # TODO
+  end
+
+  describe '.attributes' do
+    subject { instance.class.attributes }
+
+    it 'contains all the attributes' do
+      expect(subject.length).to eq 6
+    end
+
+    it 'preserves the attribute order' do
+      expect(subject.map(&:key)).to eq(
+        %i[id company name deeply_nested nutrition_info organic]
+      )
+    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].coerce_to).to be String
+      expect(subject[0].nesting).to eq []
+      expect(subject[0].conditions).to eq []
+
+      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].coerce_to).to be String
+      expect(subject[1].nesting).to eq []
+      expect(subject[1].conditions).to eq []
+
+      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].coerce_to).to be nil
+      expect(subject[2].nesting).to eq []
+      expect(subject[2].conditions.length).to be 3
+
+      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].coerce_to).to be nil
+      expect(subject[3].nesting).to eq %i[nested nested_again]
+      expect(subject[3].conditions).to eq []
+
+      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].coerce_to).to be nil
+      expect(subject[4].nesting).to eq []
+      expect(subject[4].conditions).to eq []
+
+      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].coerce_to).to be :bool
+      expect(subject[5].nesting).to eq []
+      expect(subject[5].conditions).to eq []
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe CacheCrispies::Collection do
+  class UncacheableCerealSerializerForCollection < CacheCrispies::Base
+    serialize :name
+  end
+
+  class CacheableCerealSerializerForCollection < CacheCrispies::Base
+    serialize :name
+
+    def self.do_caching?
+      true
+    end
+  end
+
+  let(:name1) { 'Cinnamon Toast Crunch' }
+  let(:name2) { 'Cocoa Puffs' }
+  let(:model1) { OpenStruct.new(name: name1) }
+  let(:model2) { OpenStruct.new(name: name2) }
+  let(:uncacheable_models) { [model1, model2] }
+  let(:cacheable_models) {
+    [model1, model2].tap do |models|
+      def models.cache_key
+        'cereals-key'
+      end
+    end
+  }
+  let(:collection) { cacheable_models }
+  let(:serializer) { CacheableCerealSerializerForCollection }
+  let(:options) { {} }
+  subject { described_class.new(collection, serializer, options) }
+
+  describe '#as_json' do
+    context "when it's not cacheable" do
+      context 'because the collection is not cacheable' do
+        let(:collection) { uncacheable_models }
+
+        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} ]
+        end
+      end
+
+      context 'because the serializer is not cacheable' do
+        let(:serializer) { UncacheableCerealSerializerForCollection }
+
+        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} ]
+        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')
+
+        expect(CacheCrispies::Plan).to receive(:new).with(
+          serializer, model2, options
+        ).and_return double(cache_key: 'cereal-key-2')
+
+        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)
+
+        subject.as_json
+      end
+    end
+  end
+end

data/spec/condition_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe CacheCrispies::Condition do
+  let(:block) { -> {} }
+  subject { described_class.new(block) }
+
+  describe '#uid' do
+    it "is the same as the block's object_id" do
+      expect(subject.uid).to be block.object_id
+    end
+  end
+
+  describe '#true_for?' do
+    let(:block) { ->(_arg1, _arg2) { 'truthy string' } }
+    let(:model) { Object.new }
+    let(:options) { {} }
+
+    it 'calls the block with model and options arguments' do
+      expect(block).to receive(:call).with(model, options)
+      subject.true_for? model, options
+    end
+
+    context 'when the block has one argument' do
+      let(:block) { ->(_arg1) { } }
+
+      it 'calls the block with the model only' do
+        expect(block).to receive(:call).with(model)
+        subject.true_for? model, options
+      end
+    end
+
+    context 'when the block has no arguments' do
+      let(:block) { -> {} }
+
+      it 'calls the block with no arguments' do
+        expect(block).to receive(:call).with(no_args)
+        subject.true_for? model, options
+      end
+    end
+
+    it 'returns a boolean' do
+      expect(subject.true_for?(model, options)).to be true
+    end
+  end
+end

data/spec/controller_spec.rb

@@ -0,0 +1,54 @@
+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
+    serialize :name
+
+    def self.key
+      'cereal'
+    end
+  end
+
+  let(:cereal_names) { ['Count Chocula', 'Eyeholes'] }
+  let(:collection) { cereal_names.map { |name| Cereal.new(name: name) } }
+
+  subject { CerealController.new }
+
+  before do
+    allow_any_instance_of(
+      CacheCrispies::Plan
+    ).to receive(:etag).and_return 'test-etag'
+    allow(subject).to receive_message_chain(:response, :weak_etag=).with 'test-etag'
+  end
+
+  describe '#cache_render' do
+    it 'renders a json collection' do
+      expect(subject).to receive(:render).with(
+        json: {
+          cereals: cereal_names.map { |name| { name: name } }
+        }.to_json
+      )
+
+      subject.cache_render CerealSerializerForController, collection
+    end
+
+    it 'renders a single json object' do
+      expect(subject).to receive(:render).with(
+        json: { cereal: { name: cereal_names.first } }.to_json
+      )
+
+      subject.cache_render CerealSerializerForController, collection.first
+    end
+  end
+end

data/spec/fixtures/test_serializer.rb

@@ -0,0 +1,2 @@
+# Nothing has to actually be in this file.
+# It's just here so test can MD5 sum it's content.

data/spec/hash_builder_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe CacheCrispies::HashBuilder do
+  # These example serializers are meant to show a variety of options,
+  # configurations, and data types in order to really put the HashBuilder class
+  # through the ringer.
+  class IngredientSerializer < CacheCrispies::Base
+    serialize :name
+  end
+
+  class MarketingBsSerializer < CacheCrispies::Base
+    serialize :tagline, :small_print
+
+    def tagline
+      "#{model.tagline}#{options[:footnote_marker]}"
+    end
+
+    def small_print
+      "#{options[:footnote_marker]}this doesn't mean jack-squat"
+    end
+  end
+
+  class CerealSerializerForHashBuilder < CacheCrispies::Base
+    serialize :uid, from: :id, to: String
+    serialize :name, :company
+    merge :itself, with: MarketingBsSerializer
+
+    nest_in :about do
+      nest_in :nutritional_information do
+        serialize :calories
+        serialize :ingredients, with: IngredientSerializer
+      end
+    end
+
+    show_if ->(model, options) { options[:be_trendy] } do
+      nest_in :health do
+        serialize :organic
+
+        show_if ->(model) { model.organic } do
+          serialize :certification
+        end
+      end
+    end
+
+    def certification
+      'Totally Not A Scam Certifiers Inc'
+    end
+  end
+
+  let(:organic) { false }
+  let(:ingredients) {
+    [
+      OpenStruct.new(name: 'Sugar'),
+      OpenStruct.new(name: 'Other Kind of Sugar')
+    ]
+  }
+  let(:model) {
+    OpenStruct.new(
+      id: 42,
+      name: 'Lucky Charms',
+      company: 'General Mills',
+      calories: 1_000,
+      organic: organic,
+      tagline: "Part of a balanced breakfast",
+      ingredients: ingredients
+    )
+  }
+  let(:options) { { footnote_marker: '*' } }
+  let(:serializer) { CerealSerializerForHashBuilder.new(model, options) }
+  subject { described_class.new(serializer) }
+
+  describe '#call' do
+    it 'correctly renders the hash' do
+      expect(subject.call).to eq ({
+        uid: '42',
+        name: 'Lucky Charms',
+        company: 'General Mills',
+        tagline: 'Part of a balanced breakfast*',
+        small_print: "*this doesn't mean jack-squat",
+        about: {
+          nutritional_information: {
+            calories: 1000,
+            ingredients: [
+              { name: 'Sugar' },
+              { name: 'Other Kind of Sugar' },
+            ]
+          }
+        }
+      })
+    end
+
+    context 'when the outer show_if is true' do
+      let(:options) { { footnote_marker: '†', be_trendy: true } }
+
+      it 'builds values wrapped in the outer if' do
+        expect(subject.call).to eq ({
+          uid: '42',
+          name: 'Lucky Charms',
+          company: 'General Mills',
+          tagline: 'Part of a balanced breakfast†',
+          small_print: "†this doesn't mean jack-squat",
+          about: {
+            nutritional_information: {
+              calories: 1000,
+              ingredients: [
+                { name: 'Sugar' },
+                { name: 'Other Kind of Sugar' },
+              ]
+            }
+          },
+          health: {
+            organic: false
+          }
+        })
+      end
+
+      context 'when the inner show_if is true' do
+        let(:organic) { true }
+
+        it 'builds values wrapped in the outer and inner if' do
+          expect(subject.call).to eq ({
+            uid: '42',
+            name: 'Lucky Charms',
+            company: 'General Mills',
+            tagline: 'Part of a balanced breakfast†',
+            small_print: "†this doesn't mean jack-squat",
+            about: {
+              nutritional_information: {
+                calories: 1000,
+                ingredients: [
+                  { name: 'Sugar' },
+                  { name: 'Other Kind of Sugar' },
+                ]
+              }
+            },
+            health: {
+              organic: true,
+              certification: 'Totally Not A Scam Certifiers Inc'
+            }
+          })
+        end
+      end
+    end
+  end
+end

data/spec/memoizer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe CacheCrispies::Memoizer do
+  describe '#fetch' do
+    it 'only calls the block once per key' do
+      block = -> {}
+
+      expect { |block| subject.fetch 1, &block }.to yield_with_no_args
+      expect { |block| subject.fetch 1, &block }.to_not yield_with_no_args
+      expect { |block| subject.fetch 2, &block }.to yield_with_no_args
+    end
+
+    it "returns the block's initial cached value" do
+      block = -> {
+        @num ||= 0
+        @num += 1
+      }
+
+      expect(subject.fetch(:a, &block)).to eq 1
+      expect(subject.fetch(:a, &block)).to eq 1
+      expect(subject.fetch(:b, &block)).to eq 2
+    end
+  end
+end

data/spec/plan_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe CacheCrispies::Plan do
+  class CerealSerializerForPlan < CacheCrispies::Base
+    def self.key
+      :cereal
+    end
+
+    def self.cache_key_addons(options)
+      ['addon1', options[:extra_addon]]
+    end
+
+    serialize :name
+  end
+
+  let(:serializer) { CerealSerializerForPlan }
+  let(:serializer_file_path) {
+    File.expand_path('fixtures/test_serializer.rb', __dir__)
+  }
+  let(:model_cache_key) { 'model-cache-key' }
+  let(:model) { OpenStruct.new(name: 'Sugar Smacks', cache_key: model_cache_key) }
+  let(:cacheable) { model }
+  let(:options) { {} }
+  let(:instance) { described_class.new(serializer, cacheable, options) }
+  subject { instance }
+
+  before do
+    allow(Rails).to receive_message_chain(:root, :join).and_return(
+      serializer_file_path
+    )
+  end
+
+  describe '#collection?' do
+    context 'when not a collection' do
+      let(:cacheable) { Object.new }
+
+      it 'returns false' do
+        expect(subject.collection?).to be false
+      end
+    end
+
+    context 'when a collection' do
+      let(:cacheable) { [Object.new] }
+
+      it 'returns false' do
+        expect(subject.collection?).to be true
+      end
+    end
+  end
+
+  describe '#etag' do
+
+  end
+
+  describe '#cache_key' do
+    let(:options) { { extra_addon: 'addon2' } }
+
+    it 'returns a string' do
+      expect(subject.cache_key).to be_a String
+    end
+
+    it 'includes the CACHE_KEY_PREFIX' do
+      expect(subject.cache_key).to include CacheCrispies::CACHE_KEY_PREFIX
+    end
+
+    it "includes the serializer's #cache_key_base" do
+      expect(subject.cache_key).to include serializer.cache_key_base
+    end
+
+    it "includes the addons_key" do
+      expect(subject.cache_key).to include(
+        Digest::MD5.hexdigest('addon1|addon2')
+      )
+    end
+
+    it "includes the cacheable #cache_key" do
+      expect(subject.cache_key).to include model_cache_key
+    end
+
+    it 'includes the CACHE_KEY_SEPARATOR' do
+      expect(subject.cache_key).to include CacheCrispies::CACHE_KEY_SEPARATOR
+    end
+
+    it 'generates the key correctly' do
+      expect(subject.cache_key).to eq(
+        'cache-crispies' \
+        "+CerealSerializerForPlan-#{Digest::MD5.file(serializer_file_path)}" \
+        "+#{Digest::MD5.hexdigest('addon1|addon2')}" \
+        '+model-cache-key'
+      )
+    end
+
+    context 'without addons' do
+      it 'generates the key without that section' do
+        expect(serializer).to receive(:cache_key_addons).and_return []
+
+        expect(subject.cache_key).to eq(
+          'cache-crispies' \
+          "+CerealSerializerForPlan-#{Digest::MD5.file(serializer_file_path)}" \
+          '+model-cache-key'
+        )
+      end
+    end
+  end
+
+  describe '#cache' do
+  end
+
+  describe '#wrap' do
+    let(:json_hash) { { name: 'Kix' } }
+    subject { instance.wrap(json_hash) }
+
+    context 'when the serializer has no key' do
+      before { expect(serializer).to receive(:key).and_return nil }
+
+      it 'returns the json Hash directly' do
+        expect(subject).to be json_hash
+      end
+    end
+
+    context 'when key is false' do
+      let(:options) { { key: false } }
+
+      it 'returns json_hash unchanged' do
+        expect(subject).to be json_hash
+      end
+    end
+
+    context 'with an optional key' do
+      let(:options) { { key: :cereal_test } }
+
+      it 'wraps the hash using the provided key option' do
+        expect(subject).to eq cereal_test: json_hash
+      end
+    end
+
+    context "when it's a colleciton" do
+      let(:cacheable) { [model] }
+
+      it "wraps the hash in the serializer's colleciton_key" do
+        expect(subject).to eq cereals: json_hash
+      end
+    end
+
+    context "when it's not a collection" do
+      it "wraps the hash in the serializer's key" do
+        expect(subject).to eq cereal: json_hash
+      end
+    end
+  end
+end