honkster-friendly 0.5.1

data/spec/unit/scope_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Scope" do
+  before do
+    @klass            = stub
+    @scope_parameters = {:name => "Quagmire", :order! => :created_at.desc}
+    @scope            = Friendly::Scope.new(@klass, @scope_parameters)
+  end
+
+  describe "#all" do
+    before do
+      @documents = stub
+    end
+
+    it "delegates to klass with the scope parameters" do
+      @klass.stubs(:all).with(@scope_parameters).returns(@documents)
+      @scope.all.should == @documents
+    end
+
+    it "merges additional parameters" do
+      merged = @scope_parameters.merge(:name => "Joe")
+      @klass.stubs(:all).with(merged).returns(@documents)
+      @scope.all(:name => "Joe").should == @documents
+    end
+  end
+
+  describe "#first" do
+    before do
+      @document = stub
+    end
+
+    it "delegates to klass with the scope parameters" do
+      @klass.stubs(:first).with(@scope_parameters).returns(@document)
+      @scope.first.should == @document
+    end
+
+    it "merges additional parameters" do
+      merged = @scope_parameters.merge(:name => "Joe")
+      @klass.stubs(:first).with(merged).returns(@document)
+      @scope.first(:name => "Joe").should == @document
+    end
+  end
+
+  describe "#paginate" do
+    before do
+      @documents = stub
+    end
+
+    it "delegates to klass with the scope parameters" do
+      @klass.stubs(:paginate).with(@scope_parameters).returns(@documents)
+      @scope.paginate.should == @documents
+    end
+
+    it "merges additional parameters" do
+      merged = @scope_parameters.merge(:name => "Joe")
+      @klass.stubs(:paginate).with(merged).returns(@documents)
+      @scope.paginate(:name => "Joe").should == @documents
+    end
+  end
+
+  describe "#build" do
+    it "instantiates klass with the scope parameters (minus modifiers)" do
+      @doc = stub
+      @klass.stubs(:new).with(:name => "Quagmire").returns(@doc)
+      @scope.build.should == @doc
+    end
+
+    it "merges additional parameters" do
+      @doc = stub
+      @klass.stubs(:new).with(:name => "Fred").returns(@doc)
+      @scope.build(:name => "Fred").should == @doc
+    end
+  end
+
+  describe "#create" do
+    it "delegates to klass#create with the scope parameters (minus modifiers)" do
+      @doc = stub
+      @klass.stubs(:create).with(:name => "Quagmire").returns(@doc)
+      @scope.create.should == @doc
+    end
+
+    it "merges additional parameters" do
+      @doc = stub
+      @klass.stubs(:create).with(:name => "Fred").returns(@doc)
+      @scope.create(:name => "Fred").should == @doc
+    end
+  end
+
+  describe "chaining another named scope" do
+    before do
+      @recent_params = {:order! => :created_at.desc}
+      @recent        = Friendly::Scope.new(@klass, @recent_params)
+      @klass.stubs(:has_named_scope?).with(:recent).returns(true)
+      @klass.stubs(:recent).returns(@recent)
+      @scope_params  = {:name => "Joe"}
+      @scope         = Friendly::Scope.new(@klass, @scope_params)
+    end
+
+    it "responds to the other scope method" do
+      @scope.should be_respond_to(:recent)
+    end
+
+    it "creates a new scope that merges the two scopes together" do
+      merged_parameters = @scope_params.merge(@recent_params)
+      @scope.recent.parameters.should == merged_parameters
+    end
+
+    it "gives precedence to scopes on the right" do
+      @quagmire = Friendly::Scope.new(@klass, :name => "Quagmire")
+      (@scope + @quagmire).parameters[:name].should == "Quagmire"
+    end
+  end
+end

data/spec/unit/storage_factory_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::StorageFactory" do
+  before do
+    @doc_table       = stub
+    @doc_table_klass = stub(:new => @doc_table)
+    @index           = stub
+    @index_klass     = stub(:new => @index)
+    @cache_by_id     = stub
+    @cache_klass     = stub(:cache_for => @cache_by_id)
+    @factory         = Friendly::StorageFactory.new(@doc_table_klass, @index_klass, 
+                                                      @cache_klass)
+  end
+
+  describe "creating a document table" do
+    before do
+      @klass    = stub
+      @returned = @factory.document_table(@klass)
+    end
+
+    it "returns the result of the constructor" do
+      @returned.should == @doc_table
+    end
+
+    it "passes along the arguments to the constructor" do
+      @doc_table_klass.should have_received(:new).with(@klass)
+    end
+  end
+
+  describe "creating an index table" do
+    before do
+      @klass    = stub
+      @returned = @factory.index(@klass)
+    end
+
+    it "returns the result of the constructor" do
+      @returned.should == @index
+    end
+
+    it "passes along the arguments to the constructor" do
+      @index_klass.should have_received(:new).with(@klass)
+    end
+  end
+
+  describe "creating an id cache table" do
+    before do
+      @klass    = stub
+      @returned = @factory.cache(@klass, [:id])
+    end
+
+    it "delegates to Cache.for" do
+      @returned.should == @cache_by_id
+    end
+
+    it "supplies arguments to Cache" do
+      @cache_klass.should have_received(:cache_for).with(@klass, [:id])
+    end
+  end
+end

data/spec/unit/storage_proxy_spec.rb

@@ -0,0 +1,244 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::StorageProxy" do
+  before do
+    @klass          = stub
+    @index          = stub(:create     => nil, 
+                           :update     => nil, 
+                           :destroy    => nil,
+                           :satsifies? => nil)
+    @table          = stub(:satisfies? => false, :create => nil, 
+                           :update => nil,       :destroy => nil)
+    @storage_factory  = stub(:index => @index)
+    @storage_factory.stubs(:document_table).with(@klass).returns(@table)
+    @storage        = Friendly::StorageProxy.new(@klass, @storage_factory)
+  end
+
+  it "instantiates and adds a document table by default" do
+    @storage.tables.should include(@table)
+  end
+
+  describe "doing a `first`" do
+    before do
+      @id     = stub
+      @index  = stub(:satisfies? => true, :first => @id)
+      @storage.tables << @index
+    end
+
+    describe "when there's an index that matches the conditions" do
+      before do
+        @result = @storage.first(:name => "x")
+      end
+
+      it "delegates to the index that satisfies the conditions" do
+        @index.should have_received(:first).once
+        @index.should have_received(:first).with(:name => "x")
+      end
+
+      it "returns id" do
+        @result.should == @id
+      end
+    end
+
+    describe "when there's no index that matches" do
+      before do
+        @index.stubs(:satisfies?).returns(false)
+      end
+
+      it "raises MissingIndex" do
+        lambda {
+          @storage.first(:name => "x")
+        }.should raise_error(Friendly::MissingIndex)
+      end
+    end
+  end
+
+  describe "doing an `all`" do
+    before do
+      @ids    = [stub]
+      @index  = stub(:satisfies? => true, :all => @ids)
+      @storage.tables << @index
+    end
+
+    describe "when there's an index that matches the conditions" do
+      before do
+        @query  = query(:name => "x")
+        @result = @storage.all(@query)
+      end
+
+      it "delegates to the index that satisfies the conditions" do
+        @index.should have_received(:all).once
+        @index.should have_received(:all).with(@query)
+      end
+
+      it "returns the results" do
+        @result.should == @ids
+      end
+    end
+
+    describe "when there's no index that matches" do
+      before do
+        @index.stubs(:satisfies?).returns(false)
+      end
+
+      it "raises MissingIndex" do
+        lambda {
+          @storage.all(:name => "x")
+        }.should raise_error(Friendly::MissingIndex)
+      end
+    end
+
+    describe "when :preserve_order is true" do
+      before do
+        @docs  = [stub(:id => 4), stub(:id => 3), stub(:id => 2)]
+        @index.stubs(:all).returns(@docs)
+        @result = @storage.all(query(:id => [2,3,4], :preserve_order! => true))
+      end
+
+      it "sorts the results based on the order they're supplied in the query" do
+        @result.should == @docs.reverse
+      end
+    end
+  end
+
+  describe "adding an index to the set" do
+    before do
+      @storage.add(:name, :age)
+    end
+
+    it "creates an index" do
+      @storage_factory.should have_received(:index).once
+      @storage_factory.should have_received(:index).with(@klass, :name, :age)
+    end
+
+    it "adds the index to the set" do
+      @storage.tables.should include(@index)
+    end
+  end
+
+  describe "saving data" do
+    before do
+      @index_two = stub(:create => nil, :update => nil, :destroy => nil)
+      @storage_factory.stubs(:index).returns(@index).then.returns(@index_two)
+      @cache     = stub(:create => nil, :update => nil, :destroy => nil)
+      @storage_factory.stubs(:cache).returns(@cache)
+      @storage.add(:name)
+      @storage.add(:age)
+      @storage.cache([:id])
+      @doc = stub
+    end
+
+    describe "on create" do
+      before do
+        @storage.create(@doc)
+      end
+
+      it "delegates to all of the storage including caches" do
+        @index.should have_received(:create).with(@doc)
+        @index_two.should have_received(:create).with(@doc)
+        @table.should have_received(:create).with(@doc)
+        @cache.should have_received(:create).with(@doc)
+      end
+    end
+
+    describe "on update" do
+      before do
+        @storage.update(@doc)
+      end
+
+      it "delegates to all of the storage including caches" do
+        @index.should have_received(:update).with(@doc)
+        @index_two.should have_received(:update).with(@doc)
+        @table.should have_received(:update).with(@doc)
+        @cache.should have_received(:update).with(@doc)
+      end
+    end
+
+    describe "on destroy" do
+      before do
+        @storage.destroy(@doc)
+      end
+
+      it "delegates to all of the storage including caches" do
+        @index.should have_received(:destroy).with(@doc)
+        @index_two.should have_received(:destroy).with(@doc)
+        @table.should have_received(:destroy).with(@doc)
+        @cache.should have_received(:destroy).with(@doc)
+      end
+    end
+  end
+
+  describe "adding a cache object" do
+    before do
+      @cache = stub
+      @storage_factory.stubs(:cache).returns(@cache)
+      @storage.cache([:id])
+    end
+
+    it "gets one from the storage_proxy" do
+      @storage_factory.should have_received(:cache).with(@klass, [:id], {})
+    end
+
+    it "adds it to its set of caches" do
+      @storage.caches.should include(@cache)
+    end
+  end
+
+  describe "finding with a matching cache" do
+    before do
+      @cache = stub(:satisfies? => true, :first => nil)
+      @storage_factory.stubs(:cache).returns(@cache)
+      @storage.cache([:id])
+    end
+
+    describe "when there's a hit" do
+      before do
+        @doc = stub
+        @cache.stubs(:first).returns(@doc)
+      end
+
+      it "returns the result from the cache" do
+        @storage.first(:id => "x").should == @doc
+      end
+    end
+  end
+
+  describe "counting objects" do
+    before do
+      @index = stub(:count => 10)
+      @index.stubs(:satisfies?).with(:x => 1).returns(true)
+      @storage_factory.stubs(:index).returns(@index)
+      @storage.add(:a)
+    end
+
+    it "delegates to a satisfying index" do
+      @storage.count(:x => 1).should == 10
+    end
+  end
+
+  describe "getting the index that matches a set of fields" do
+    before do
+      @storage_factory = stub(:document_table => @document_table)
+
+      [[:name, :created_at], [:name]].each do |fields|
+        @storage_factory.stubs(:index).
+          with(@klass, *fields).returns(stub(:fields => fields))
+      end
+
+      @storage = Friendly::StorageProxy.new(@klass, @storage_factory)
+      @storage.add(:name, :created_at)
+      @storage.add(:name)
+    end
+
+    it "matches if and only if all the fields are present and in order" do
+      @storage.index_for_fields([:name, :created_at]).fields.should == 
+        [:name, :created_at]
+    end
+
+    it "raises missing index if there's no matching index" do
+      lambda {
+        @storage.index_for_fields([:created_at, :name])
+      }.should raise_error(Friendly::MissingIndex)
+    end
+  end
+end

data/spec/unit/translator_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path("../../spec_helper", __FILE__)
+require 'ostruct'
+
+describe "Friendly::Translator" do
+  before do
+    @serializer = stub
+    @time       = stub
+    @translator = Friendly::Translator.new(@serializer, @time)
+  end
+
+  describe "translating a row to an object" do
+    before do
+      @serializer.stubs(:parse).with("THE JSON").returns(:name => "Stewie")
+      @time  = Time.new
+      @row   = {:added_id   => 12345,
+                :created_at => @time,
+                :updated_at => @time,
+                :attributes => "THE JSON"}
+      @doc   = stub
+      @klass = stub
+      @klass.stubs(:new_without_change_tracking).
+              with(:updated_at => @time,    :new_record => false, 
+                   :name       => "Stewie", :created_at => @time).returns(@doc)
+    end
+
+    it "creates a new object without change tracking" do
+      @translator.to_object(@klass, @row).should == @doc
+    end
+  end
+
+  describe "translating from a document in to a record" do
+    describe "when the document has yet to be saved" do
+      before do
+        @hash = {:name => "Stewie"}
+        @time.stubs(:new).returns(Time.new)
+        @serializer.stubs(:generate).with(@hash).returns("SOME JSON")
+        @document = stub(:to_hash     => @hash, 
+                         :new_record? => true, 
+                         :created_at  => nil,
+                         :id          => 12345)
+        @record = @translator.to_record(@document)
+      end
+
+      it "serializes the attributes" do
+        @record[:attributes].should == "SOME JSON"
+      end
+
+      it "sets updated_at" do
+        @record[:updated_at].should == @time.new
+      end
+
+      it "sets the id from the document" do
+        @record[:id].should == 12345
+      end
+    end
+
+    describe "when the document has already been saved" do
+      before do
+        @created_at = Time.new
+        @hash = {:name       => "Stewie",
+                 :id         => 1,
+                 :created_at => @created_at,
+                 :updated_at => Time.new}
+        @time.stubs(:new).returns(Time.new + 5000)
+        @serializer.stubs(:generate).returns("SOME JSON")
+        @document = stub(:to_hash     => @hash, 
+                         :created_at  => @created_at,
+                         :new_record? => false,
+                         :id          => 12345)
+        @record = @translator.to_record(@document)
+      end
+
+      it "serializes the attributes" do
+        @serializer.should have_received(:generate).with(:name => "Stewie")
+        @record[:attributes].should == "SOME JSON"
+      end
+
+      it "doesn't bump the created_at" do
+        @record[:created_at].should == @created_at
+      end
+
+      it "should bump the updated_at" do
+        @record[:updated_at].should == @time.new
+      end
+
+      it "takes the id from the documetn" do
+        @record[:id].should == 12345
+      end
+    end
+  end
+end