stacks 0.1.0

data/spec/column_dependent_cache_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Stacks::ColumnDependentCache do
+
+  describe ".validate_model" do
+
+    it "throws an exception if the model isn't an activerecord model" do
+      expect do
+        Stacks::ColumnDependentCache.validate_model(FakeModel)
+      end.to raise_error(Stacks::ColumnDependentCache::InvalidModel)
+    end
+
+    it "doesn't throw an exception if the class is valid" do
+      expect do
+        Stacks::ColumnDependentCache.validate_model(TestModel)
+      end.to_not raise_error
+    end
+
+  end
+
+  describe ".get_backend" do
+
+    it "returns a backend namespaced to the model" do
+      backend = Stacks::ColumnDependentCache.get_backend(TestModel)
+      backend.namespace.should == TestModel.to_s
+    end
+
+  end
+
+  describe ".cached" do
+
+    before(:each) do
+      @model = TestModel
+      @columns = [:col1, :col2, :col3]
+      @identifier = "identifier"
+    end
+
+    let(:call) do
+      Stacks::ColumnDependentCache.cached(@model,
+                                           @columns,
+                                           @identifier) { "wussup?" }
+    end
+
+    it "validates the model" do
+      Stacks::ColumnDependentCache.should_receive(:validate_model).with(@model)
+      call
+    end
+
+    context "test actual cacheing" do
+
+      before(:each) do
+        @model = TestClass
+        @model.stub_chain(:nbc_listener, :register_column)
+        Stacks::ColumnDependentCache.stub(:validate_model)
+        @backend = double
+      end
+
+
+      it "uses a backend appropriate to the model" do
+        @backend.stub(:get_or_set)
+
+        Stacks::ColumnDependentCache.should_receive(:get_backend).with(@model).and_return(@backend)
+
+        call
+      end
+
+      it "calls get_or_set on the backend" do
+        item = double
+        Stacks::Items::ColumnDependentBlock.stub(:new) { item }
+        Stacks::ColumnDependentCache.stub(:get_backend) { @backend }
+
+        @backend.should_receive(:get_or_set).with(item,
+                                                  Stacks::ColumnDependentCache.default_ttl)
+
+        call
+      end
+
+    end
+
+  end
+
+  describe ".bust_cache" do
+
+    it "runs" do
+      backend = Stacks::Backends::NamespacedBackend.new
+      backend.namespace = "namespace"
+      Stacks::ColumnDependentCache.stub(:get_backend) { backend }
+      Stacks::ColumnDependentCache.bust_cache(TestModel, [:key1])
+    end
+
+    context "stubbed backend" do
+
+      before(:each) do
+        @backend = double
+        @item = double
+        @item.stub(:clear_value)
+        @backend.stub(:keys) { ["identifier:key1", "identifier:key2"] }
+        Stacks::ColumnDependentCache.stub(:get_backend) { @backend }
+      end
+
+      it "doesn't delete a key when it's a fillable block key" do
+        Stacks::ColumnDependentCache.stub(:fillable_block_keys).and_return do
+          { TestModel => { "identifier:key2" => @item } }
+        end
+
+        Stacks::ColumnDependentCache.should_receive(:make_fill_decision)
+          .with(TestModel, "identifier:key2")
+        @backend.should_receive(:del_key).exactly(0).times
+        Stacks::ColumnDependentCache.bust_cache(TestModel, [:key2])
+      end
+
+      it "should delete each the key with given attribute" do
+        @backend.should_receive(:del_key).exactly(1).times.with("identifier:key1")
+        Stacks::ColumnDependentCache.bust_cache(TestModel, [:key1])
+      end
+
+      it "should delete a key with multiple columns, with one that matches" do
+        @backend.stub(:keys) { ["identifier:key3:key7:key1", "identifier:key2"] }
+        @backend.should_receive(:del_key).exactly(1).times.with("identifier:key3:key7:key1")
+        Stacks::ColumnDependentCache.bust_cache(TestModel, [:key1])
+      end
+
+    end
+
+  end
+
+  describe ".fill_block" do
+
+    it "should set the value when called with the correct key" do
+      Stacks::ColumnDependentCache.define_block(TestModel, [:test_column1], "test_identifier") do
+        "test_value"
+      end
+
+      Stacks::ColumnDependentCache.fillable_block_keys.keys.first.should == TestModel
+      Stacks::ColumnDependentCache.defined_blocks.keys.should == ["test_identifier"]
+
+      Stacks::ColumnDependentCache.fill_block(TestModel,
+                                               "test_identifier:test_column1")
+
+      Stacks::Backends::NamespacedBackend.any_instance.should_not_receive(:set)
+
+      Stacks::ColumnDependentCache.get_block_value("test_identifier").should ==
+        "test_value"
+    end
+
+  end
+
+end

data/spec/items/column_dependent_block_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Stacks::Items::ColumnDependentBlock do
+
+  before(:each) do
+    @model = TestModel
+    @columns = [:column1]
+    @identifier = "identifier"
+    @proc = lambda { "woo" }
+
+    @cdb = Stacks::Items::ColumnDependentBlock.new(@model,
+                                                    @columns,
+                                                    @identifier,
+                                                    @proc)
+  end
+
+  describe "#key" do
+
+    it "consists of the identifier and the columns" do
+      @cdb.key.should == "identifier:column1"
+    end
+
+  end
+
+  describe ".key_to_columns" do
+
+    it "drops the identifier from the key and returns the columns"do
+      Stacks::Items::ColumnDependentBlock.key_to_columns("identifier:column1").should ==
+        ["column1"]
+    end
+
+  end
+
+  describe "#value" do
+
+    it "just calls the proc" do
+      @cdb.value.should == "woo"
+    end
+
+  end
+
+end

data/spec/items/method_call_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Stacks::Items::MethodCall do
+
+  before(:each) do
+    @instance = TestClass.new
+    @args = ["woo", "yoo"]
+    @method_call = Stacks::Items::MethodCall.new(@instance, :test_method, @args)
+  end
+
+  describe "#key_str" do
+
+    it "contains the method name" do
+      @method_call.key_str.include?(:test_method.to_s).should be_true
+    end
+
+    it "contains the marshaled object" do
+      @method_call.key_str.include?(Marshal.dump(@instance)).should be_true
+    end
+
+    it "contains the marshaled arguments" do
+      @method_call.key_str.include?(Marshal.dump(@args)).should be_true
+    end
+
+  end
+
+  describe "#key" do
+
+    it "contains the SHA2 value of the key_str" do
+      @method_call.key.should == Digest::SHA2.hexdigest(@method_call.key_str)
+    end
+
+  end
+
+  describe "#value" do
+
+    it "calls the method with the arguments" do
+      @method_call.value.should == "My arguments: woo and yoo"
+    end
+
+  end
+
+end

data/spec/items/proc_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Stacks::Items::Proc do
+
+  describe "#initialize" do
+
+    it "keeps track of a proc" do
+      test_proc = proc { "hello" }
+      item = Stacks::Items::Proc.new("test-identifier", test_proc)
+
+      item.key.should == "test-identifier"
+      item.value.should == "hello"
+    end
+
+  end
+
+end

data/spec/method_cache_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Stacks::MethodCache do
+
+  before(:each) do
+    @instance = TestClass.new
+  end
+
+  describe ".cached" do
+
+    before(:each) do
+      Stacks::MethodCache.cached(@instance,
+                                  :test_method2,
+                                  ["woo", "yoo"],
+                                  666).should == "My arguments: woo and yoo"
+    end
+
+    it "should return the method value" do
+      Stacks::MethodCache.cached(@instance,
+                                  :test_method2,
+                                  ["woo", "yoo"],
+                                  666).should == "My arguments: woo and yoo"
+    end
+
+    it "should return the same value even if the method result" do
+      TestClass.prefix = "HAHA"
+      @instance.test_method2("woo", "yoo").should == "HAHA: woo and yoo"
+
+      Stacks::MethodCache.cached(@instance,
+                                  :test_method2,
+                                  ["woo", "yoo"],
+                                  666).should == "My arguments: woo and yoo"
+      TestClass.prefix = "My arguments"
+    end
+
+    it "shouldn't conflict with other cached methods" do
+      Stacks::MethodCache.cached(@instance,
+                                  :test_method3,
+                                  [],
+                                  666).should == "this is a test"
+    end
+
+  end
+
+end

data/spec/model_extensions_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe Stacks::ModelExtensions do
+
+  describe ".bust_cache_for_column" do
+
+    it "documents that a cache is watching a column" do
+      Stacks.model_listening_caches.each do |cache|
+        cache.should_receive(:bust_cache).with(TestModel, [:test_column])
+      end
+
+      Stacks::ModelExtensions.bust_cache_for_column(TestModel, :test_column)
+    end
+
+  end
+
+end
+
+describe Stacks::ModelExtensions::Extension do
+
+  describe ".stacks_watched_columns" do
+
+    it "is attached to every model" do
+      ActiveRecord::Base.stacks_watched_columns.is_a?(Set).should be_true
+    end
+
+  end
+
+  describe ".stacks_watch_columns" do
+
+    after(:each) { TestModel.stacks_watched_columns.clear }
+
+    it "adds a column to the watch set" do
+      TestModel.stacks_watched_columns.should == Set.new
+
+      TestModel.stacks_watch_column(:test_column1)
+      TestModel.stacks_watch_column(:test_column2)
+
+      TestModel.stacks_watched_columns.should == Set.new([:test_column1, :test_column2])
+    end
+
+  end
+
+  describe ".bust_stackss" do
+
+    after(:each) { TestModel.stacks_watched_columns.clear }
+
+    it "busts caches for each watched attribute" do
+      TestModel.stacks_watch_column(:test_column1)
+      TestModel.stacks_watch_column(:test_column2)
+
+      TestModel.stacks_watched_columns.count.should == 2
+
+      Stacks::ModelExtensions.should_receive(:bust_cache_for_columns).with(TestModel,
+                                                                            Set.new([:test_column1,
+                                                                                     :test_column2]))
+
+      TestModel.bust_stacks
+    end
+
+  end
+
+  describe ".stacks_check_columns" do
+
+    it "is included in all models now" do
+      ActiveRecord::Base.instance_methods.include?(:stacks_check_columns).should be_true
+    end
+
+    context "modify column" do
+
+      before(:each) do
+        TestModel.stacks_watch_column(:test_column1)
+      end
+
+      after(:each) { TestModel.stacks_watched_columns.clear }
+
+      it "busts the column cache when the attribute is modified" do
+        Stacks.model_listening_caches.each do |cache|
+          cache.should_receive(:bust_cache).exactly(1).times.with(TestModel, [:test_column1])
+        end
+
+        y = TestModel.create
+        y.test_column1 = "hello!"
+        y.save!
+      end
+
+      it "busts the column cache when the attribute is modified at creation time" do
+        Stacks.model_listening_caches.each do |cache|
+          cache.should_receive(:bust_cache).exactly(1).times.with(TestModel, [:test_column1])
+        end
+
+        y = TestModel.create(:test_column1 => "hello!")
+      end
+
+      it "doesn't trigger the callback for a non-watched column" do
+        Stacks.model_listening_caches.each do |cache|
+          cache.should_receive(:bust_cache).exactly(0).times
+        end
+
+        y = TestModel.create(:test_column2 => "hello!")
+      end
+
+    end
+
+  end
+end

data/spec/report_cache_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+
+describe Stacks::ReportCache do
+
+  before(:each) do
+    @report = Stacks::ReportCache.new("test report", 100)
+  end
+
+  describe "#backend" do
+
+    it "uses a namespaced backend customized to the report name" do
+      backend = @report.backend
+      backend.namespace.should == "test report"
+    end
+
+  end
+
+  describe ".report" do
+
+    it "allows defining values through passing a block" do
+      report = Stacks::ReportCache.report("test report", 100) do
+        value("a test value") { "woooo" }
+      end
+
+      report.report_name.should == "test report"
+      report.ttl.should == 100
+      report.values["a test value"].key.should == "a test value"
+      report.values["a test value"].value.should == "woooo"
+    end
+
+  end
+
+  describe "#value" do
+
+    it "defines a value for the report" do
+      @report.value("hello there") { "wussup" }
+      @report.values["hello there"].value.should == "wussup"
+    end
+
+  end
+
+  describe "#get_value" do
+
+    it "returns the cached value stored for the key" do
+      @report.value("hello there") { "wussup" }
+      @report.get_value("hello there").should == "wussup"
+    end
+
+    it "doesn't return a cached value if cache_condition evaluates to false" do
+      @report.value("hello there") { "wussup" }
+      @report.set_cache_condition { false }
+      item = @report.values["hello there"]
+      item.should_receive(:value)
+      @report.backend.should_receive(:get_or_set).exactly(0).times
+
+      @report.get_value("hello there")
+    end
+
+    it "returns a cached value if cache_condition evaluates to true" do
+      @report.value("hello there") { "wussup" }
+      @report.set_cache_condition { true }
+      item = @report.values["hello there"]
+      @report.backend.should_receive(:get_or_set)
+
+      @report.get_value("hello there")
+    end
+
+  end
+
+  describe "#fill_cache" do
+
+    it "should fill the cache" do
+      @report.value("hello there") { "wussup" }
+      @report.value("yo") { "ratchet" }
+
+      @report.values["hello there"].class.should == Stacks::Items::Proc
+      @report.values["yo"].class.should == Stacks::Items::Proc
+
+      @report.backend.should_receive(:fill).with(@report.values["hello there"], 100)
+      @report.backend.should_receive(:fill).with(@report.values["yo"], 100)
+
+      timestamp = double
+
+      Stacks::Items::Timestamp.stub(:new).and_return(timestamp)
+      @report.backend.should_receive(:fill).with(timestamp, 100)
+
+      @report.fill_cache
+    end
+
+    it "shouldn't do anything if the cache condition isn't satisfied" do
+      @report.value("yo") { "ratchet" }
+      @report.values["yo"].class.should == Stacks::Items::Proc
+      @report.set_cache_condition { false }
+      @report.backend.should_receive(:fill).exactly(0).times
+
+      @report.fill_cache
+    end
+
+  end
+
+  describe ".reports" do
+
+    it "keeps track of all defined reports" do
+      report = Stacks::ReportCache.report("test report", 100) do
+        value("a test value") { "woooo" }
+      end
+
+      Stacks::ReportCache.reports["test report"].should == report
+      Stacks::ReportCache.get_report("test report").should == report
+    end
+
+  end
+
+  describe "#register_instance_variables" do
+
+    it "transfers create attributes for each value" do
+      instance = TestClass.new
+      report = Stacks::ReportCache.report("test report", 100) do
+        value("my_attr") { "woooo" }
+      end
+
+      report.register_instance_variables(instance)
+      instance.instance_eval { @my_attr }.should == "woooo"
+    end
+
+  end
+
+  describe "#timestamp" do
+
+    it "it returns a timestamp" do
+      report = Stacks::ReportCache.report("test report", 100) do
+        value("my_attr") { "woooo" }
+      end
+
+      report.timestamp.class.should == Time
+    end
+
+  end
+
+
+end