arunthampi-friendly 0.5.1

data/spec/unit/associations/association_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe "Friendly::Associations::Association" do
+  before do
+    @owner_klass = stub(:name => "User")
+    @klass       = stub
+    # FIXME: ugh.
+    String.any_instance.stubs(:constantize).returns(@klass)
+    @assoc_klass = Friendly::Associations::Association
+  end
+
+  describe "with defaults" do
+    before do
+      @association = @assoc_klass.new(@owner_klass, :addresses)
+    end
+
+    it "has a default klass of name.classify.constantize" do
+      @association.klass.should == @klass
+    end
+
+    it "has a foreign_key of owner_klass.name.singularize + '_id'" do
+      @association.foreign_key.should == :user_id
+    end
+
+    it "returns a scope on klass of {:foreign_key => document.id}" do
+      @scope = stub
+      @klass.stubs(:scope).with(:user_id => 42).returns(@scope)
+
+      @association.scope(stub(:id => 42)).should == @scope
+    end
+  end
+
+  describe "with overridden attributes" do
+    before do
+      @klass      = stub
+      @class_name = "SomeOtherClass"
+      @class_name.stubs(:constantize).returns(@klass)
+      @association = @assoc_klass.new @owner_klass, :whatever, 
+                                      :class_name  => @class_name,
+                                      :foreign_key => :other_id
+    end
+
+    it "uses the overridden class_name to get the class" do
+      @association.klass.should == @klass
+    end
+
+    it "uses the overridden foreign_key" do
+      @association.foreign_key.should == :other_id
+    end
+
+    it "uses the override foreign_key in the scope" do
+      @scope = stub
+      @klass.stubs(:scope).with(:other_id => 42).returns(@scope)
+      @association.scope(stub(:id => 42)).should == @scope
+    end
+  end
+end

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,125 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Friendly::Attribute" do
+  before do
+    @klass   = Class.new { def will_change(a); end }
+    @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, :false,   String, :default => false)
+    @klass.stubs(:attributes).returns({:name    => @name, 
+                                       :id      => @id, 
+                                       :default => @default,
+                                       :false   => @false})
+    @object = @klass.new
+  end
+
+  it "creates a getting on klass that notifies it of a change" do
+    @object.stubs(:will_change)
+    @object.name = "Something"
+    @object.should have_received(:will_change).with(:name)
+  end
+
+  it "creates a getter on klass" do
+    @object.name = "Something"
+    @object.name.should == "Something"
+  end
+
+  it "creates an 'attr_was' getter" do
+    @object.instance_variable_set(:@name_was, "Joe the Plumber")
+    @object.name_was.should == "Joe the Plumber"
+  end
+
+  it "creates an attr_changed? query method" do
+    @object.stubs(:attribute_changed?).with(:name).returns(true)
+    @object.should be_name_changed
+  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 "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"
+    @obj = @klass.new
+    @default.assign_default_value(@obj)
+    @obj.default.should == "asdf"
+  end
+
+  it "has a default value even if it's false" do
+    @false.default.should be_false
+  end
+
+  it "knows how to assign its own default" do
+    @object = stub(:false= => nil)
+    @false.assign_default_value(@object)
+    @object.should have_received(:false=).with(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/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
+