friendly_postgres 0.4.3

data/spec/unit/associations/set_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe "Friendly::Associations::Set" do
+  before do
+    @klass             = Class.new
+    @association_klass = stub
+    @set               = Friendly::Associations::Set.new(@klass, @association_klass)
+    @assoc             = stub
+    @association_klass.stubs(:new).
+      with(@klass, :my_awesome_association, {}).returns(@assoc)
+  end
+
+  describe "adding an association" do
+    before do
+      @set.add(:my_awesome_association)
+    end
+
+    it "creates an association and adds it to its hash by name" do
+      @set.associations[:my_awesome_association].should == @assoc
+    end
+
+    it "adds an instance method to the klass through which to acces the assoc" do
+      @doc   = @klass.new
+      @scope = stub
+      @klass.stubs(:association_set).returns(@set)
+      @assoc.stubs(:scope).with(@doc).returns(@scope)
+      @doc.my_awesome_association.should == @scope
+    end
+  end
+
+  it "can return the association by name" do
+    @set.add(:my_awesome_association)
+    @set.get(:my_awesome_association).should == @assoc
+  end
+
+  it "provides the scope for an association by name" do
+    @doc   = stub
+    @scope = stub
+    @assoc.stubs(:scope).with(@doc).returns(@scope)
+    @set.add(:my_awesome_association)
+    @set.get_scope(:my_awesome_association, @doc).should == @scope
+  end
+end

data/spec/unit/attribute_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Attribute" do
+  before do
+    @klass   = Class.new
+    @name    = Friendly::Attribute.new(@klass, :name, String)
+    @id      = Friendly::Attribute.new(@klass, :id, Friendly::UUID)
+    @no_type = Friendly::Attribute.new(@klass, :no_type, nil)
+    @default = Friendly::Attribute.new(@klass, :default, String, :default => "asdf")
+    @false   = Friendly::Attribute.new(@klass, :default, String, :default => false)
+    @klass.stubs(:attributes).returns({:name    => @name, 
+                                       :id      => @id, 
+                                       :default => @default,
+                                       :false   => @false})
+    @object = @klass.new
+  end
+
+  it "creates a setter and a getter on klass" do
+    @object.name = "Something"
+    @object.name.should == "Something"
+  end
+
+  it "typecasts values using the converter function" do
+    uuid = Friendly::UUID.new
+    @id.typecast(uuid.to_s).should == uuid
+  end
+
+  it "doesn't typecast values if they are of the right type" do
+    uuid = Friendly::UUID.new
+    @id.typecast(uuid).should == uuid
+  end
+
+  it "raises a useful error if it can't typecast" do
+    attribute = Friendly::Attribute.new(@klass, :weird, Class)
+    lambda {
+      attribute.typecast("ASDF")
+    }.should raise_error(Friendly::NoConverterExists)
+  end
+
+  it "creates a getter with a default value" do
+    @object.id.should be_instance_of(Friendly::UUID)
+  end
+
+  it "has a default value of type.new" do
+    @id.default.should be_instance_of(Friendly::UUID)
+  end
+
+  it "has a default of nil if the type doesn't respond to :new" do
+    Friendly::Attribute.new(@klass, :age, Integer).default.should be_nil
+  end
+
+  it "doesn't try to convert when there's no type" do
+    @no_type.typecast(true).should == true
+  end
+
+  it "can have a default value" do
+    @default.default.should == "asdf"
+    @klass.new.default.should == "asdf"
+  end
+
+  it "has a default value even if it's false" do
+    @false.default.should be_false
+  end
+
+  describe "registering a type" do
+    before do
+      @klass = Class.new
+      Friendly::Attribute.register_type(@klass, "binary(16)") { |t| t.to_i }
+    end
+
+    after { Friendly::Attribute.deregister_type(@klass) }
+
+    it "tells Attribute about the sql_type" do
+      Friendly::Attribute.sql_type(@klass).should == "binary(16)"
+    end
+
+    it "registers the conversion method" do
+      Friendly::Attribute.new(@klass, :something, @klass).convert("1").should == 1
+    end
+
+    it "is custom_type?(@klass)" do
+      Friendly::Attribute.should be_custom_type(@klass)
+    end
+  end
+
+  describe "deregistering a type" do
+    before do
+      @klass = Class.new
+      Friendly::Attribute.register_type(@klass, "whatever") {}
+      Friendly::Attribute.deregister_type(@klass)
+    end
+
+    it "removes the converter method" do
+      Friendly::Attribute.converters.should_not be_has_key(@klass)
+    end
+
+    it "removes the sql_type" do
+      Friendly::Attribute.sql_types.should_not be_has_key(@klass)
+    end
+
+    it "is not custom_type?(@klass)" do
+      Friendly::Attribute.should_not be_custom_type(@klass)
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Config" do
+end

data/spec/unit/data_store_spec.rb

@@ -0,0 +1,188 @@
+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 "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
+