honkster-friendly 0.5.1

data/spec/unit/cache_by_id_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Cache::ByID" do
+  before do
+    @cache    = stub(:set => nil)
+    @klass    = stub(:name => "Product")
+    @id_cache = Friendly::Cache::ByID.new(@klass, [:id], {}, @cache)
+    @subject  = @id_cache
+  end
+
+  it { should be_satisfies(query(:id => "asdf")) }
+  it { should be_satisfies(query(:id => ["asdf"])) }
+  it { should_not be_satisfies(query(:id => ["asdf"], :name => "asdf")) }
+  it { should_not be_satisfies(query(:name => "asdf")) }
+
+  it "has a default version of 0" do
+    @id_cache.version.should == 0
+  end
+
+  it "is possible to override version" do
+    Friendly::Cache::ByID.new(@klass, [:id], {:version => 1}).version.should == 1
+  end
+
+  describe "when an object is created" do
+    before do
+      @uuid = stub(:to_guid => "xxxx-xxx-xxx-xxxx")
+      @doc  = stub(:id => @uuid)
+      @id_cache.create(@doc)
+    end
+
+    it "sets the cache value in the db" do
+      @cache.should have_received(:set).with("Product/0/#{@uuid.to_guid}", @doc)
+    end
+  end
+
+  describe "when an object is updated" do
+    before do
+      @uuid = stub(:to_guid => "xxxx-xxx-xxx-xxxx")
+      @doc  = stub(:id => @uuid)
+      @id_cache.update(@doc)
+    end
+
+    it "sets the cache value in the db" do
+      @cache.should have_received(:set).with("Product/0/#{@uuid.to_guid}", @doc)
+    end
+  end
+
+  describe "when an object is destroyed" do
+    before do
+      @cache.stubs(:delete)
+      @uuid = stub(:to_guid => "xxxx-xxx-xxx-xxxx")
+      @doc  = stub(:id => @uuid)
+      @id_cache.destroy(@doc)
+    end
+
+    it "deletes the object from cache" do
+      @cache.should have_received(:delete).with("Product/0/#{@uuid.to_guid}")
+    end
+  end
+
+  describe "finding a single object in cache" do
+    before do
+      @uuid         = stub(:to_guid => "xxxx-xxx-xxx-xxxx")
+      @doc          = stub
+      @cache.stubs(:get).with("Product/0/xxxx-xxx-xxx-xxxx").returns(@doc).yields
+      @block_called = true
+      @returned = @id_cache.first(query(:id => @uuid)) do
+        @block_called = true
+      end
+    end
+
+    it "returns the document" do
+      @returned.should == @doc
+    end
+
+    it "passes along the block to the memcached object" do
+      @block_called.should be_true
+    end
+  end
+
+  describe "finding many objects in the cache" do
+    before do
+      @uuid         = stub(:to_guid => "xxxx-xxx-xxx-xxxx")
+      @doc          = stub
+      @key          = "Product/0/xxxx-xxx-xxx-xxxx"
+      @cache.stubs(:multiget).with([@key, @key]).
+        returns({@uuid.to_guid => @doc}).yields(@uuid.to_guid)
+      @block_called = []
+      @returned = @id_cache.all(query(:id => [@uuid, @uuid])) do |id|
+        @block_called << id
+      end
+    end
+
+    it "returns the values from the hash" do
+      @returned.should == [@doc]
+    end
+
+    it "passes the block along to the cache" do
+      @block_called.should == [@uuid.to_guid]
+    end
+  end
+end

data/spec/unit/cache_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Cache" do
+  describe "getting a cache object for :id" do
+    before do
+      @cache = Friendly::Cache.cache_for(stub, [:id], {})
+    end
+
+    it "instantiates a Cache::ByID" do
+      @cache.should be_instance_of(Friendly::Cache::ByID)
+    end
+  end
+
+  describe "for other fields" do
+    it "raises NotSupported" do
+      lambda {
+        Friendly::Cache.cache_for(stub, [:asdf], {})
+      }.should raise_error(Friendly::NotSupported)
+    end
+  end
+end

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