friendly 0.3.3

data/spec/spec_helper.rb

@@ -0,0 +1,90 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+Dir[File.expand_path(File.dirname(__FILE__)) + "/fakes/*.rb"].each do |f|
+  require f
+end
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'sequel'
+require 'json'
+gem     'jferris-mocha'
+require 'mocha'
+require 'memcached'
+require 'friendly'
+
+Friendly.configure "mysql://root@localhost/friendly_test"
+$db = Friendly.db
+Sequel::MySQL.default_engine = "InnoDB"
+
+$db.drop_table :users if $db.table_exists?("users")
+$db.drop_table :index_users_on_name if $db.table_exists?("index_users_on_name")
+if $db.table_exists?("index_users_on_name_and_created_at")
+  $db.drop_table :index_users_on_name_and_created_at
+end
+
+datastore          = Friendly::DataStore.new($db)
+Friendly.datastore = datastore
+
+$cache = Memcached.new
+Friendly.cache     = Friendly::Memcached.new($cache)
+
+class User
+  include Friendly::Document
+
+  attribute :name,  String
+  attribute :age,   Integer
+  attribute :happy, Friendly::Boolean, :default => true
+  attribute :sad,   Friendly::Boolean, :default => false
+
+  indexes   :name
+  indexes   :name, :created_at
+end
+
+User.create_tables!
+
+class Address
+  include Friendly::Document
+
+  attribute :user_id, Friendly::UUID
+  attribute :street,  String
+
+  indexes   :user_id
+  indexes   :street
+  caches_by :id
+end
+
+Address.create_tables!
+
+module Mocha
+  module API
+    def setup_mocks_for_rspec
+      mocha_setup
+    end
+    def verify_mocks_for_rspec
+      mocha_verify
+    end
+    def teardown_mocks_for_rspec
+      mocha_teardown
+    end 
+  end
+end
+
+module Factory
+  def row(opts = {})
+    { :id => 1, :created_at => Time.new, :updated_at => Time.new }.merge(opts)
+  end
+
+  def query(conditions)
+    stub(:order           => conditions.delete(:order!), 
+         :limit           => conditions.delete(:limit!),
+         :preserve_order? => conditions.delete(:preserve_order!),
+         :conditions      => conditions,
+         :offset          => conditions.delete(:offset!))
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with Mocha::API
+  config.include Factory
+end

data/spec/unit/attribute_spec.rb

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