friendly 0.3.3

data/spec/unit/document_spec.rb

@@ -0,0 +1,311 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Document" do
+  before do
+    @klass = Class.new { include Friendly::Document }
+    @klass.attribute(:name, String)
+    @storage_proxy = stub
+    @klass.storage_proxy = @storage_proxy
+  end
+
+  it "delegates table_name to it's class" do
+    User.new.table_name.should == User.table_name
+  end
+
+  it "always has an id attribute" do
+    @klass.attributes[:id].type.should == Friendly::UUID
+  end
+
+  it "always has a created_at attribute" do
+    @klass.attributes[:created_at].type.should == Time
+  end
+
+  it "always has a updated_at attribute" do
+    @klass.attributes[:updated_at].type.should == Time
+  end
+
+  describe "saving a new document" do
+    before do
+      @user = @klass.new(:name => "whatever")
+      @storage_proxy.stubs(:create)
+      @user.save
+    end
+
+    it "asks the storage_proxy to create" do
+      @storage_proxy.should have_received(:create).with(@user)
+    end
+  end
+
+  describe "saving an existing document" do
+    before do
+      @user = @klass.new(:name => "whatever", :id => 42, :new_record => false)
+      @storage_proxy.stubs(:update)
+      @user.save
+    end
+
+    it "asks the storage_proxy to update" do
+      @storage_proxy.should have_received(:update).with(@user)
+    end
+  end
+
+  describe "destroying a document" do
+    before do
+      @user = @klass.new
+      @storage_proxy.stubs(:destroy)
+      @user.destroy
+    end
+
+    it "delegates to the storage proxy" do
+      @storage_proxy.should have_received(:destroy).with(@user)
+    end
+  end
+
+  describe "converting a document to a hash" do
+    before do
+      @object = @klass.new(:name => "Stewie")
+    end
+
+    it "creates a hash that contains its attributes" do
+      @object.to_hash.should == {:name       => "Stewie", 
+                                 :id         => @object.id, 
+                                 :created_at => @object.created_at,
+                                 :updated_at => @object.updated_at}
+    end
+  end
+
+  describe "setting the attributes all at once" do
+    before do
+      @object = @klass.new
+      @object.attributes = {:name => "Bond"}
+    end
+
+    it "sets the attributes using the setters" do
+      @object.name.should == "Bond"
+    end
+
+    it "raises ArgumentError when there are duplicate keys of differing type" do
+      lambda { 
+        @object.attributes = {:name => "Bond", "name" => "Bond"}
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "initializing a document" do
+    before do
+      @doc = @klass.new :name => "Bond"
+    end
+
+    it "sets the attributes using the setters" do
+      @doc.name.should == "Bond"
+    end
+  end
+
+  describe "table name" do
+    it "by default: is the class name, converted with pluralize.underscore" do
+      User.table_name.should == "users"
+    end
+
+    it "is overridable" do
+      @klass.table_name = "ASDF"
+      @klass.table_name.should == "ASDF"
+    end
+  end
+
+  describe "new record" do
+    before do
+      @object = @klass.new
+    end
+
+    it "is new_record by default" do
+      @object.should be_new_record
+    end
+
+    it "is not new_record when new_record is set to false" do
+      @object.new_record = false
+      @object.should_not be_new_record
+    end
+  end
+
+  describe "object equality" do
+    it "is never equal if both objects are new_records" do
+      @klass.new(:name => "x").should_not == @klass.new(:name => "x")
+    end
+
+    it "is equal if both objects have the same id" do
+      uuid = Friendly::UUID.new
+      one  = @klass.new(:id => uuid, :new_record => false)
+      one.should == @klass.new(:id => uuid, :new_record => false)
+    end
+
+    it "is equal if the objects point to the same reference" do
+      obj = @klass.new
+      obj.should == obj
+    end
+
+    it "is not equal if two objects are of differing types with the same id" do
+      @klass.new(:id => 1).should_not == User.new(:id => 1)
+    end
+  end
+
+  describe "adding an index" do
+    before do
+      @storage_proxy.stubs(:add)
+      @klass = Class.new { include Friendly::Document }
+      @klass.storage_proxy = @storage_proxy
+      @klass.indexes :name
+    end
+
+    it "delegates to the storage_proxy" do
+      @klass.storage_proxy.should have_received(:add).with([:name])
+    end
+  end
+
+  describe "adding a cache" do
+    before do
+      @storage_proxy.stubs(:cache)
+      @klass.caches_by(:name, :created_at)
+    end
+
+    it "delegates to the storage_proxy" do
+      @storage_proxy.should have_received(:cache).with([:name, :created_at], {})
+    end
+  end
+
+  describe "Document.first" do
+    before do
+      @doc               = stub
+      @query             = stub
+      @query_klass       = stub
+      @klass.query_klass = @query_klass
+      @query_klass.stubs(:new).with(:id => 1).returns(@query)
+      @storage_proxy.stubs(:first).with(@query).returns(@doc)
+    end
+
+    it "creates a query object and delegates to the storage proxy" do
+      @klass.first(:id => 1).should == @doc
+    end
+  end
+
+  describe "Document.all" do
+    before do
+      @docs              = stub
+      @query             = stub
+      @query_klass       = stub
+      @klass.query_klass = @query_klass
+      @query_klass.stubs(:new).with(:name => "x").returns(@query)
+      @storage_proxy.stubs(:all).with(@query).returns(@docs)
+    end
+
+    it "delegates to the storage proxy" do
+      @klass.all(:name => "x").should == @docs
+    end
+  end
+
+  describe "Document.find" do
+    describe "when an object is found" do
+      before do
+        @doc               = stub
+        @query             = stub
+        @query_klass       = stub
+        @klass.query_klass = @query_klass
+        @query_klass.stubs(:new).with(:id => 1).returns(@query)
+        @storage_proxy.stubs(:first).with(@query).returns(@doc)
+      end
+
+      it "queries the storage proxy" do
+        @klass.find(1).should == @doc
+      end
+    end
+
+    describe "when no object is found" do
+      before do
+        @storage_proxy.stubs(:first).returns(nil)
+      end
+
+      it "raises RecordNotFound" do
+        lambda {
+          @klass.find(1)
+        }.should raise_error(Friendly::RecordNotFound)
+      end
+    end
+  end
+
+  describe "Document.all" do
+    before do
+      @query             = stub
+      @query_klass       = stub
+      @klass.query_klass = @query_klass
+      @query_klass.stubs(:new).with(:name => "x").returns(@query)
+      @storage_proxy.stubs(:count).with(@query).returns(25)
+    end
+
+    it "delegates to the storage proxy" do
+      @klass.count(:name => "x").should == 25
+    end
+  end
+
+  describe "Document.create" do
+    before do
+      @storage_proxy.stubs(:create)
+      @doc = @klass.create(:name => "James")
+    end
+
+    it "initializes, then saves the document and returns it" do
+      @storage_proxy.should have_received(:create).with(@doc)
+      @doc.should be_kind_of(@klass)
+    end
+  end
+
+  describe "Document#update_attributes" do
+    before do
+      @storage_proxy.stubs(:update)
+      @doc = @klass.new(:name => "James", :new_record => false)
+      @doc.update_attributes :name => "Steve"
+    end
+
+    it "sets the attributes" do
+      @doc.name.should == "Steve"
+    end
+
+    it "saves the document" do
+      @storage_proxy.should have_received(:update).with(@doc)
+    end
+  end
+
+  describe "when document has been included" do
+    after { Friendly::Document.documents = [] }
+    it "adds the document to the collection" do
+      Friendly::Document.documents.should include(@klass)
+    end
+  end
+
+  describe "Document.paginate" do
+    before do
+      @conditions             = {:name => "Stewie", :page! => 1, :per_page! => 20}
+      @query                  = stub(:page => 1, :per_page => 20)
+      @docs                   = stub
+      @query_klass            = stub
+      @klass.query_klass      = @query_klass
+      @count                  = 10
+      @collection_klass       = stub
+      @collection             = stub
+      @klass.collection_klass = @collection_klass
+      @collection.stubs(:replace).returns(@collection)
+      @collection_klass.stubs(:new).with(1, 20, @count).returns(@collection)
+      @query_klass.stubs(:new).returns(@query)
+      @storage_proxy.stubs(:count).with(@query).returns(@count)
+      @storage_proxy.stubs(:all).with(@query).returns(@docs)
+
+      @pagination = @klass.paginate(@conditions)
+    end
+
+    it "creates an instance of the collection klass and returns it" do
+      @pagination.should == @collection
+    end
+
+    it "fills the collection with objects from the datastore" do
+      @collection.should have_received(:replace).with(@docs)
+    end
+  end
+end
+

data/spec/unit/document_table_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::DocumentTable" do
+  before do
+    @datastore  = stub(:insert => 42, :update => nil, :delete => nil)
+    @klass      = stub(:table_name => "users")
+    @translator = stub
+    @table      = Friendly::DocumentTable.new(@klass, @datastore, @translator)
+    @subject    = @table
+    @document   = FakeDocument.new
+  end
+
+  it "has a table name of klass.table_name" do
+    @table.table_name.should == "users"
+  end
+
+  it { should be_satisfies(query(:id => 1)) }
+  it { should_not be_satisfies(query(:id => 1, :name => "x")) }
+  it { should_not be_satisfies(query(:name => "x")) }
+  it { should_not be_satisfies(query(:id => 1, :order! => :created_at.desc)) }
+
+  describe "saving an object" do
+    before do
+      @document_hash = {:name => "whatever"}
+      @document      = FakeDocument.new :table_name => "users",
+                                        :to_hash    => @document_hash
+      @record = {:created_at => Time.new, :updated_at => Time.new}
+      @translator.stubs(:to_record).with(@document).returns(@record)
+    end
+
+    describe "when it is a new_record?" do
+      before do
+        @document.new_record = true
+        @table.create(@document)
+      end
+
+      it "saves the record from the translator to the database" do
+        @datastore.should have_received(:insert).with(@document, @record)
+      end
+
+      it "sets the created_at on the document" do
+        @document.created_at.should == @record[:created_at]
+      end
+
+      it "sets the updated_at on the document" do
+        @document.updated_at.should == @record[:updated_at]
+      end
+
+      it "sets new_record to false" do
+        @document.should_not be_new_record
+      end
+    end
+
+    describe "updating a record" do
+      before do
+        @document.id         = 24
+        @document.new_record = false
+        @table.update(@document)
+      end
+
+      it "saves the record from the translator" do
+        @datastore.should have_received(:update).with(@document, 24, @record)
+      end
+      
+      it "sets the created_at from the translator" do
+        @document.created_at.should == @record[:created_at]
+      end
+
+      it "sets the updated_at from the translator" do
+        @document.updated_at.should == @record[:updated_at]
+      end
+    end
+  end
+
+  describe "destroying an object" do
+    before do
+      @document.id = 42
+      @table.destroy(@document)
+    end
+
+    it "asks the datastore to delete" do
+      @datastore.should have_received(:delete).with(@document, 42)
+    end
+  end
+
+  describe "finding the first object" do
+    describe "when the object is found" do
+      before do
+        @record   = {:id => 1}
+        @document = stub
+        @datastore.stubs(:first).with(@klass, :id => 1).returns(@record)
+        @translator.stubs(:to_object).with(@klass, @record).returns(@document)
+      end
+
+      it "queries the datastore and translates the object" do
+        @table.first(:id => 1).should == @document
+      end
+    end
+
+    describe "when the object is not found" do
+      before do
+        @datastore.stubs(:first).with(@klass, :id => 1).returns(nil)
+      end
+
+      it "returns nil" do
+        @table.first(:id => 1).should be_nil
+      end
+    end
+  end
+
+  describe "finding many objects" do
+    before do
+      @records  = [row(:id => 1), row(:id => 2)]
+      @document = stub
+      @query    = query(:id => [1,2])
+      @records.each do |r|
+        @translator.stubs(:to_object).with(@klass, r).returns(@document).once
+      end
+      @datastore.stubs(:all).with(@klass, @query).returns(@records)
+    end
+
+    it "queries the datastore and translates the returned records" do
+      @table.all(@query).should == [@document, @document]
+    end
+  end
+end

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