friendly 0.3.3

data/spec/unit/memcached_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Memcached" do
+  before do
+    @cache     = stub(:set => nil)
+    @memcached = Friendly::Memcached.new(@cache)
+  end
+
+  describe "setting a key" do
+    before do
+      @memcached.set("key", "value")
+    end
+
+    it "sets the key in memcached" do
+      @cache.should have_received(:set).with("key", "value")
+    end
+  end
+
+  describe "getting an existing key" do
+    before do
+      @cache.stubs(:get).with("Some Key").returns("Some Value")
+    end
+
+    it "returns the value from cache" do
+      @memcached.get("Some Key").should == "Some Value"
+    end
+  end
+
+  describe "getting a missing key" do
+    before do
+      @cache.stubs(:get).raises(Memcached::NotFound)
+    end
+
+    describe "with no block supplied" do
+      it "returns nil if no block is supplied" do
+        @memcached.get("Some Key").should be_nil
+      end
+    end
+
+    describe "with a block" do
+      before do
+        @returned = @memcached.get("Some Key") { "THE VALUE!" }
+      end
+
+      it "returns the value of the supplied block" do
+        @returned.should == "THE VALUE!"
+      end
+
+      it "sets the key to that value" do
+        @cache.should have_received(:set).with("Some Key", "THE VALUE!")
+      end
+    end
+  end
+
+  describe "getting multiple keys" do
+    describe "when all keys are found" do
+      before do
+        @hits = {"a" => "foo", "b" => "bar", "c" => "baz"}
+        @keys = ["a", "b", "c"]
+        @cache.stubs(:get).with(@keys).returns(@hits)
+      end
+
+      it "delegates to the cache object" do
+        @memcached.multiget(@keys).should == @hits
+      end
+    end
+
+    describe "when only some of the keys are found" do
+      before do
+        @hits = {"a" => "foo", "b" => "bar"}
+        @keys = ["a", "b", "c"]
+        @cache.stubs(:get).with(@keys).returns(@hits)
+        @returned = @memcached.multiget(@keys) { |k| "#{k}/fromblock" }
+      end
+
+      it "fetches the rest of the keys by yielding to the block" do
+        @returned.should == @hits.merge("c" => "c/fromblock")
+      end
+
+      it "sets the missing keys in the cache" do
+        @cache.should have_received(:set).with("c", "c/fromblock")
+      end
+    end
+
+    describe "when the list of keys is empty" do
+      it "returns {}" do
+        @memcached.multiget([]).should == {}
+      end
+    end
+  end
+
+  describe "deleting" do
+    describe "an existing key" do
+      before do
+        @cache.stubs(:delete).returns(nil)
+        @memcached.delete("some key")
+      end
+
+      it "asks the cache to delete" do
+        @cache.should have_received(:delete).with("some key")
+      end
+    end
+
+    describe "a missing key" do
+      before do
+        @cache.stubs(:delete).raises(Memcached::NotFound)
+      end
+
+      it "just returns nil" do
+        lambda { @memcached.delete("some key") }.should_not raise_error
+      end
+    end
+  end
+end

data/spec/unit/query_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Query" do
+  before do
+    @order = :created_at.desc
+    @query = Friendly::Query.new(:name            => "x",
+                                 :limit!          => 10,
+                                 :order!          => @order,
+                                 :preserve_order! => true,
+                                 :offset!         => 2)
+  end
+
+  it "extracts the conditions" do
+    @query.conditions.should == {:name => "x"}
+  end
+
+  it "extracts the limit parameter" do
+    @query.limit.should == 10
+  end
+
+  it "extracts the order parameter" do
+    @query.order.should == @order
+  end
+
+  it "extracts the preserve order parameter" do
+    @query.should be_preserve_order
+  end
+
+  it "extracts the offset parameter" do
+    @query.should be_offset
+    @query.offset.should == 2
+  end
+
+  it "should not be preserver order by default" do
+    Friendly::Query.new({}).should_not be_preserve_order
+  end
+
+  it "converts string representations of UUID to UUID" do
+    uuid       = stub
+    uuid_klass = stub
+    uuid_klass.stubs(:new).with("asdf").returns(uuid)
+    query      = Friendly::Query.new({:id => "asdf"}, uuid_klass)
+    query.conditions[:id].should == uuid
+  end
+
+  it "converts arrays of ids to UUID" do
+    uuid       = stub
+    uuid_klass = stub
+    uuid_klass.stubs(:new).with("asdf").returns(uuid)
+    query      = Friendly::Query.new({:id => ["asdf"]}, uuid_klass)
+    query.conditions[:id].should == [uuid]
+  end
+
+  describe "a pagination query" do
+    describe "page nil" do
+      before do
+        @query = Friendly::Query.new(:page!     => nil,
+                                     :per_page! => 5)
+      end
+
+      it "is page 1" do
+        @query.page.should == 1
+      end
+
+      it "has an offset of 0" do
+        @query.offset.should == 0
+      end
+
+      it "has a limit of :per_page" do
+        @query.limit.should == 5
+      end
+    end
+
+    describe "page 2" do
+      before do
+        @query = Friendly::Query.new(:page!     => 2,
+                                     :per_page! => 5)
+      end
+
+      it "has an offset of :per_page * page-1" do
+        @query.offset.should == 5
+      end
+
+      it "has a limit of :per_page" do
+        @query.limit.should == 5
+      end
+    end
+
+    describe "when page is a string" do
+      before do
+        @query = Friendly::Query.new(:page!     => "2",
+                                     :per_page! => 5)
+      end
+
+      it "has an offset of :per_page * page-1" do
+        @query.offset.should == 5
+      end
+
+      it "has a limit of :per_page" do
+        @query.limit.should == 5
+      end
+    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,218 @@
+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
+end

data/spec/unit/translator_spec.rb

@@ -0,0 +1,96 @@
+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"}
+      @klass = FakeDocument
+      @doc   = @translator.to_object(@klass, @row)
+    end
+
+    it "creates a klass with the attributes from the json" do
+      @doc.name.should == "Stewie"
+    end
+
+    it "sets updated_at" do
+      @doc.updated_at.should == @time
+    end
+
+    it "sets new_record to false" do
+      @doc.new_record.should be_false
+    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