ihoka-friendly 0.6.3 → 0.7.0

data/spec/unit/data_store_spec.rb

@@ -0,0 +1,201 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::DataStore" do
+  before do
+    @users     = DatasetFake.new(:insert => 42)
+    @db        = DatabaseFake.new("users" => @users)
+    @datastore = Friendly::DataStore.new(@db)
+    @klass     = stub(:table_name => "users")
+  end
+
+  describe "inserting data" do
+    before do
+      @return = @datastore.insert(@klass, :name => "Stewie")
+    end
+
+    it "inserts it in to the table in the datastore" do
+      @users.inserts.length.should == 1
+      @users.inserts.should include(:name => "Stewie")
+    end
+
+    it "returns the id from the dataset" do
+      @return.should == 42
+    end
+  end
+
+  describe "retrieving all based on a query" do
+    before do
+      @users.where = {{:name => "Stewie"} => stub(:map => [{:id => 1}])}
+      @return = @datastore.all(@klass, query(:name => "Stewie"))
+    end
+
+    it "gets the data from the dataset for the klass and makes it an arary" do
+      @return.should == [{:id => 1}]
+    end
+  end
+
+  describe "retrieving all with a limit" do
+    before do
+      @filtered    = stub
+      @filtered.stubs(:limit).with(10, nil).returns(stub(:map => [{:id => 1}]))
+      @users.where = {{:name => "Stewie"} => @filtered}
+      @query       = query(:name => "Stewie", :limit! => 10)
+      @return      = @datastore.all(@klass, @query)
+    end
+
+    it "limits the filtered dataset and returns the results" do
+      @return.should == [{:id => 1}]
+    end
+  end
+
+  describe "retrieving all with a offset" do
+    before do
+      @filtered    = stub
+      @filtered.stubs(:limit).with(nil, 10).returns(stub(:map => [{:id => 1}]))
+      @users.where = {{:name => "Stewie"} => @filtered}
+      @query       = query(:name => "Stewie", :offset! => 10)
+      @return      = @datastore.all(@klass, @query)
+    end
+
+    it "offsets the filtered dataset and returns the results" do
+      @return.should == [{:id => 1}]
+    end
+  end
+
+  describe "retrieving all with order" do
+    before do
+      @filtered    = stub
+      @filtered.stubs(:order).with(:created_at).returns(stub(:map => [{:id => 1}]))
+      @users.where = {{:name => "Stewie"} => @filtered}
+      @query       = query(:name => "Stewie", :order! => :created_at)
+      @return      = @datastore.all(@klass, @query)
+    end
+
+    it "orders the filtered dataset and returns the results" do
+      @return.should == [{:id => 1}]
+    end
+  end
+
+  describe "all without conditions" do
+    before do
+      @all         = stub(:map => [])
+      @users.stubs(:order).with(:created_at).returns(@all)
+      @query       = query(:order! => :created_at)
+      @return      = @datastore.all(@klass, @query)
+    end
+
+    it "orders the filtered dataset and returns the results" do
+      @return.should == []
+    end
+  end
+
+  describe "retrieving first with conditions" do
+    before do
+      @users.first = {{:id => 1} => {:id => 1}}
+      @return = @datastore.first(@klass, query(:id => 1))
+    end
+
+    it "gets the first object matching the conditions from the dataset" do
+      @return.should == {:id => 1}
+    end
+  end
+
+  describe "updating data" do
+    before do
+      @filtered    = DatasetFake.new(:update => true)
+      @users.where = {{:id => 1} => @filtered}
+      @return = @datastore.update(@klass, 1, :name => "Peter")
+    end
+
+    it "filter the dataset by id and update the filtered row" do
+      @filtered.updates.length.should == 1
+      @filtered.updates.should include(:name => "Peter")
+    end
+  end
+
+  describe "deleting data" do
+    before do
+      @filtered = stub
+      @filtered.stubs(:delete)
+      @users.where = {{:id => 1} => @filtered}
+      @datastore.delete(@klass, 1)
+    end
+
+    it "filters the dataset by id and deletes" do
+      @filtered.should have_received(:delete)
+    end
+  end
+
+  describe "when a batch transaction has been started" do
+    before do
+      @datastore.start_batch
+      @persistable = stub(:table_name => "some_table")
+      @datastore.insert(@persistable, {:some => "attrs"})
+    end
+
+    after { Thread.current[:friendly_batch] = nil }
+
+    it "adds the attributes to the batch for that table" do
+      inserts = Thread.current[:friendly_batch]["some_table"]
+      inserts.length.should == 1
+      inserts.should include(:some => "attrs")
+    end
+  end
+
+  describe "starting a batch" do
+    before do
+      @datastore.start_batch
+    end
+
+    after { Thread.current[:friendly_batch] = nil }
+
+    it "sets Thread.current[:friendly_batch] to empty hash" do
+      Thread.current[:friendly_batch].should == {}
+    end
+  end
+
+  describe "resetting a batch transaction" do
+    before do
+      @db.stubs(:from)
+      Thread.current[:friendly_batch] = {"users" => [{:a => "b"}]}
+      @datastore.reset_batch
+    end
+    after { Thread.current[:friendly_batch] = nil }
+
+    it "sets Thread.current[:friendly_batch] to nil without inserting" do
+      Thread.current[:friendly_batch].should be_nil
+      @db.should have_received(:from).never
+    end
+  end
+
+  describe "flushing a batch" do
+    before do
+      @records = [{:name => "Stewie"}, {:name => "Brian"}]
+      Thread.current[:friendly_batch] = {"users" => @records}
+      @users.stubs(:multi_insert)
+      @datastore.flush_batch
+    end
+    after { Thread.current[:friendly_batch] = nil }
+
+    it "performs the multi_insert on each table" do
+      @users.should have_received(:multi_insert).
+          with(@records, :commit_every => 1000)
+    end
+
+    it "resets the batch" do
+      Thread.current[:friendly_batch].should be_nil
+    end
+  end
+
+  describe "counting" do
+    before do
+      @filtered = stub(:count => 10)
+      @users.stubs(:where).with(:name => "James").returns(@filtered)
+    end
+
+    it "fitlers and counts in the db" do
+      @datastore.count(@klass, query(:name => "James")).should == 10
+    end
+  end
+end
+

data/spec/unit/document/attributes_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe "Friendly::Document::Attributes" do
+  before do
+    @klass = Class.new do
+      include Friendly::Document::Attributes
+
+      attribute :name, String
+    end
+  end
+
+  describe "#initialize" do
+    it "sets the attributes using the setters" do
+      @doc = @klass.new :name => "Bond"
+      @doc.name.should == "Bond"
+    end
+
+    it "assigns the default values" do
+      @klass.attribute :id, Friendly::UUID
+      @klass.attributes[:id]   = stub(:assign_default_value => nil)
+      @klass.attributes[:name] = stub(:assign_default_value => nil,
+                                      :typecast             => "Bond")
+      @doc = @klass.new :name => "Bond"
+      @klass.attributes[:id].should have_received(:assign_default_value).with(@doc)
+      @klass.attributes[:name].should have_received(:assign_default_value).with(@doc)
+    end
+  end
+
+  describe "#attributes=" 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 "#to_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"}
+    end
+  end
+
+  describe "#assign" do
+    before do
+      @object = @klass.new
+      @object.assign(:name, "James Bond")
+    end
+
+    it "assigns the value to the attribute" do
+      @object.name.should == "James Bond"
+    end
+  end
+
+  describe "#will_change" do
+    before do
+      @klass.send(:attr_accessor, :some_variable)
+      @object = @klass.new
+      @object.some_variable = "Some value"
+      @object.will_change(:some_variable)
+    end
+
+    it "makes the object #changed?" do
+      @object.should be_changed
+    end
+
+    it "returns the value of the variable for #attribute_was" do
+      @object.attribute_was(:some_variable).should == "Some value"
+    end
+
+    it "returns true for attribute_changed?(:some_variable)" do
+      @object.should be_attribute_changed(:some_variable)
+    end
+  end
+
+  describe "#reset_changes" do
+    before do
+      @klass.send(:attr_accessor, :some_variable)
+      @object = @klass.new
+      @object.some_variable = "Some value"
+      @object.will_change(:some_variable)
+      @object.reset_changes
+    end
+
+    it "resets the changed status of the object" do
+      @object.should_not be_changed
+    end
+
+    it "returns nil for attribute_was(:some_variable)" do
+      @object.attribute_was(:some_variable).should be_nil
+    end
+
+    it "returns false for attribute_changed?(:some_variable)" do
+      @object.should_not be_attribute_changed(:some_variable)
+    end
+  end
+
+  describe "#new_without_change_tracking" do
+    before do
+      @klass = Class.new do
+        attr_reader :name
+
+        def name=(name)
+          will_change(:name)
+          @name = name
+        end
+
+        include Friendly::Document::Attributes
+      end
+      @doc = @klass.new_without_change_tracking(:name => "James")
+    end
+
+    it "initializes and then calls reset_changes" do
+      @doc.name.should == "James"
+      @doc.should_not be_changed
+    end
+  end
+end

data/spec/unit/document_spec.rb

@@ -0,0 +1,318 @@
+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 "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
+
+  describe "creating a named_scope" do
+    before do
+      @scope_proxy           = stub(:add_named => nil)
+      @klass.scope_proxy     = @scope_proxy
+      @klass.named_scope(:by_name, :order => :name)
+    end
+
+    it "asks the named_scope_set to add it" do
+      @klass.scope_proxy.should have_received(:add_named).
+                                  with(:by_name, :order => :name)
+    end
+  end
+
+  describe "Document.has_named_scope?" do
+    it "delegates to the scope_proxy" do
+      @scope_proxy       = stub
+      @scope_proxy.stubs(:has_named_scope?).with(:whatever).returns(true)
+      @klass.scope_proxy = @scope_proxy
+      @klass.has_named_scope?(:whatever).should be_true
+    end
+  end
+
+  describe "accessing an ad-hoc scope" do
+    before do
+      @scope             = stub
+      @scope_proxy       = stub
+      @scope_proxy.stubs(:ad_hoc).with(:order! => :name).returns(@scope)
+      @klass.scope_proxy = @scope_proxy
+    end
+
+    it "asks the named_scope_set to add it" do
+      @klass.scope(:order! => :name).should == @scope
+    end
+  end
+
+  describe "adding an association" do
+    before do
+      @assoc_set             = stub(:add => nil)
+      @klass.association_set = @assoc_set
+      @klass.has_many :addresses
+    end
+
+    it "asks the association set to add it" do
+      @assoc_set.should have_received(:add).with(:addresses, {})
+    end
+  end
+end
+