friendly_postgres 0.4.3

data/spec/unit/friendly_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly" do
+  describe "configuring friendly" do
+    before do
+      @datastore = stub
+      Friendly::DataStore.stubs(:new).returns(@datastore)
+      @db = stub(:meta_def => nil)
+      Sequel.stubs(:connect).returns(@db)
+      Friendly.configure(:host => "localhost")
+    end
+
+    it "creates a db object by delegating to Sequel" do
+      Sequel.should have_received(:connect).with(:host => "localhost")
+    end
+
+    it "creates a datastore object with the db object" do
+      Friendly::DataStore.should have_received(:new).with(@db)
+    end
+
+    it "sets the datastore as the default" do
+      Friendly.datastore.should == @datastore
+    end
+  end
+end

data/spec/unit/index_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Index" do
+  before do
+    @klass = stub(:table_name => "users")
+    @index = Friendly::Index.new(@klass, [:name, :age])
+  end
+
+  it "satisfies query when all the fields are indexed" do
+    @index.should be_satisfies(query({:name => "x", :age => "y"}))
+  end
+
+  it "doesn't satisfy query when some fields are not indexed" do
+    @index.should_not be_satisfies(query({:name => "x", :dob => "12/01/1980"}))
+  end
+
+  it "doesn't satisfy if it only uses keys on the right of the index" do
+    @index.should_not be_satisfies(query({:age => "y"}))
+  end
+
+  it "satisfies if it only uses keys on the left of the index" do
+    @index.should be_satisfies(query({:name => "y"}))
+  end
+
+  it "satisfies an ordered query if it uses all fields and order is rightmost" do
+    @index.should be_satisfies(query(:name => "y", :order! => :age.desc))
+  end
+
+  it "doesn't satisfy an ordered query if it uses all fields and order ! leftmost" do
+    @index.should_not be_satisfies(query(:name => "Stewie", :order! => :name.desc))
+  end
+
+  it "doesn't satisfy an ordered query if it uses a field after a gap" do
+    ix = Friendly::Index.new(@klass, [:name, :height, :age])
+    ix.should_not be_satisfies(query(:name => "James", :order! => :age.desc))
+  end
+
+  describe "with one field" do
+    before do
+      @index = Friendly::Index.new(@klass, [:name])
+    end
+
+    it "has an appropriate table name" do
+      @index.table_name.should == "index_users_on_name"
+    end
+  end
+
+  describe "with multiple fields" do
+    before do
+      @index = Friendly::Index.new(@klass, [:name, :age])
+    end
+
+    it "has an appropriate table name" do
+      @index.table_name.should == "index_users_on_name_and_age"
+    end
+  end
+
+  describe "finding the first record matching a query" do
+    before do
+      @result    = row(:id => 42)
+      @datastore = stub(:first => @result)
+      @index     = Friendly::Index.new(@klass, [:name], @datastore)
+      @doc       = stub
+      @klass.stubs(:first).with(:id => 42).returns(@doc)
+      @result    = @index.first(:name => "x")
+    end
+
+    it "queries the datastore with the attributes from the query" do
+      @datastore.should have_received(:first).once
+      @datastore.should have_received(:first).with(@index, :name => "x")
+    end
+
+    it "finds the document by the id returned by the datastore" do
+      @klass.should have_received(:first).with(:id => 42)
+    end
+
+    it "returns the document returned by the klass" do
+      @result.should == @doc
+    end
+
+    describe "when no result is found" do
+      before do
+        @datastore.stubs(:first).returns(nil)
+        @result = @index.first(:name => "x")
+      end
+
+      it "returns nil" do
+        @result.should be_nil
+      end
+    end
+  end
+
+  describe "finding all the rows matching a query" do
+    before do
+      @results   = [row(:id => 42), row(:id => 43), row(:id => 44)]
+      @query     = query(:name => "x")
+      @datastore = stub(:all => @results)
+      @index     = Friendly::Index.new(@klass, [:name], @datastore)
+      @documents = stub
+      @klass.stubs(:all).with(:id              => [42, 43, 44], 
+                              :preserve_order! => false).returns(@documents)
+      @result    = @index.all(@query)
+    end
+
+    it "queries the datastore with the conditions" do
+      @datastore.should have_received(:all).once
+      @datastore.should have_received(:all).with(@index, @query)
+    end
+
+    it "then queries the klass for the ids it found in the index" do
+      @klass.should have_received(:all).with(:id              => [42, 43, 44],
+                                             :preserve_order! => false)
+    end
+
+    it "returns the result from the klass.all call" do
+      @result.should == @documents
+    end
+  end
+
+  describe "finding all the rows matching a query in order" do
+    before do
+      @results   = [row(:id => 42), row(:id => 43), row(:id => 44)]
+      @query     = query(:name => "x", :order! => :created_at.desc)
+      @datastore = stub(:all => @results)
+      @index     = Friendly::Index.new(@klass, [:name], @datastore)
+      @documents = stub
+      @klass.stubs(:all).with(:id              => [42, 43, 44], 
+                              :preserve_order! => true).returns(@documents)
+      @result    = @index.all(@query)
+    end
+
+    it "queries the klass with preserve_order! => true" do
+      @klass.should have_received(:all).with(:id              => [42, 43, 44],
+                                             :preserve_order! => true)
+    end
+  end
+
+  describe "updating the indexes" do
+    before do
+      @datastore = stub(:insert => nil, :update => nil)
+      @index     = Friendly::Index.new(stub, [:name], @datastore)
+      @document  = stub(:name    => "Stewie", 
+                        :indexes => [@index],
+                        :id      => 42)
+      @index_record = {:name => "Stewie", :id => 42}
+    end
+
+    describe "indexing a new document" do
+      before do
+        @index.create(@document)
+      end
+
+      it "inserts a record in to the datastore with the indexed vals and id" do
+        @datastore.should have_received(:insert).with(@index, @index_record)
+      end
+    end
+
+    describe "indexing an existing document" do
+      before do
+        @index.update(@document)
+      end
+
+      it "updates the index records in the database" do
+        @datastore.should have_received(:update).with(@index, 42, @index_record)
+      end
+    end
+  end
+
+  describe "destroying the index rows" do
+    before do
+      @datastore = stub(:delete => nil)
+      @index     = Friendly::Index.new(stub, [:name], @datastore)
+      @document  = stub(:name    => "Stewie", 
+                        :indexes => [@index],
+                        :id      => 42)
+      @index.destroy(@document)
+    end
+
+    it "deletes the records in the index" do
+      @datastore.should have_received(:delete).with(@index, 42)
+    end
+  end
+
+  describe "counting rows matching a query" do
+    before do
+      @datastore = stub
+      @query     = query(:name => "Stewie")
+      @index     = Friendly::Index.new(@klass, [:name], @datastore)
+      @datastore.stubs(:count).with(@index, @query).returns(10)
+    end
+
+    it "delegates to the datastore" do
+      @index.count(@query).should == 10
+    end
+  end
+end

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/named_scope_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::NamedScope" do
+  before do
+    @klass       = stub
+    @scope       = stub
+    @scope_klass = stub
+    @parameters  = {:name => "James"}
+    @scope_klass.stubs(:new).with(@klass, @parameters).returns(@scope)
+    @named_scope = Friendly::NamedScope.new(@klass, @parameters, @scope_klass)
+  end
+
+  it "provides scope instances with the given parameters" do
+    @named_scope.scope.should == @scope
+  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