arunthampi-friendly 0.5.1

data/spec/integration/index_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../spec_helper", __FILE__)
+require 'active_support/duration'
+require 'active_support/core_ext/integer'
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/numeric'
+
+describe "Finding one object with an index" do
+  before do
+    @created_user = User.new(:name => "Cleveland")
+    @created_user.save
+    @found_user   = User.first(:name => "Cleveland")
+  end
+
+  it "finds the object" do
+    @found_user.should == @created_user
+  end
+end
+
+describe "Finding one object that doesn't exist in the index" do
+  it "returns nil" do
+    User.first(:name => "asdf").should be_nil
+  end
+end
+
+describe "Finding object on an index that doesn't exist" do
+  it "raises Friendly::MissingIndex" do
+    lambda {
+      User.first(:age => 3) 
+    }.should raise_error(Friendly::MissingIndex)
+  end
+end
+
+describe "Finding ordered objects" do
+  before do
+    @three = User.new(:name => "Brian", :created_at => 4.hours.ago)
+    @two   = User.new(:name => "Brian", :created_at => 2.hours.ago)
+    @one   = User.new(:name => "Brian", :created_at => 5.minutes.ago)
+    [@one, @two, @three].each { |i| i.save }
+  end
+
+  after do
+    [@one, @two, @three].each { |i| i.destroy }
+  end
+
+  it "can return the objects in desc order" do
+    found_users = User.all(:name => "Brian", :order! => :created_at.desc)
+    found_users.should == [@one, @two, @three]
+  end
+
+  it "can return the objects in asc order" do
+    found_users = User.all(:name => "Brian", :order! => :created_at.asc)
+    found_users.length.should == 3
+    found_users.should == [@three, @two, @one]
+  end
+end
+

data/spec/integration/named_scope_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "named_scope" do
+  describe "calling a single named_scope" do
+    before do
+      User.all(:name => "Quagmire").each { |q| q.destroy }
+      5.times { User.create(:name => "Quagmire") }
+    end
+
+    describe "all" do
+      it "returns all objects matching the conditions" do
+        User.named_quagmire.all.should == User.all(:name => "Quagmire")
+      end
+
+      it "accepts extra conditions" do
+        User.create(:name => "Fred")
+        found = User.named_quagmire.all(:name => "Fred")
+        found.should == User.all(:name => "Fred")
+      end
+    end
+
+    describe "first" do
+      it "returns the first object matching the conditions" do
+        User.named_quagmire.first.should == User.first(:name => "Quagmire")
+      end
+
+      it "accepts extra conditions" do
+        User.create(:name => "Fred")
+        found = User.named_quagmire.first(:name => "Fred")
+        found.should == User.first(:name => "Fred")
+      end
+    end
+  end
+end

data/spec/integration/offline_indexing_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Building an index offline" do
+  before do
+    $db.drop_table :awesome_things if $db.table_exists?(:awesome_things)
+
+    if $db.table_exists?(:index_awesome_things_on_name)
+      $db.drop_table :index_awesome_things_on_name
+    end
+
+    @klass = Class.new do
+      def self.name; "AwesomeThing"; end
+      def self.table_name; "awesome_things"; end
+
+      include Friendly::Document
+
+      attribute :name, String
+    end
+    @klass.create_tables!
+
+    @jameses = [@klass.create(:name => "James"), @klass.create(:name => "James")]
+
+    @klass.indexes :name
+    @klass.create_tables!
+  end
+
+  describe "" do
+    before do
+      Friendly::Indexer.populate(@klass, :name)
+    end
+
+    it "builds the missing index rows for all the rows in the doc table" do
+      @klass.all(:name => "James").should == @jameses
+    end
+
+    it "ignores records that are already in the index" do
+      lambda {
+        Friendly::Indexer.populate(@klass, :name)
+      }.should_not raise_error
+    end
+  end
+
+  describe "with more than `Indexer.objects_per_iteration` objects" do
+    before do
+      Friendly::Indexer.objects_per_iteration = 1
+      Friendly::Indexer.populate(@klass, :name)
+    end
+
+    it "builds the missing index rows for all the rows in the doc table" do
+      @klass.all(:name => "James").should == @jameses
+    end
+  end
+end

data/spec/integration/pagination_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path("../../spec_helper", __FILE__)
+require 'active_support/core_ext'
+
+describe "Paginating" do
+  before do
+    User.all(:name => "Fred").each { |u| u.destroy }
+    @users = (0...15).map do |i|
+      User.create(:name       => "Fred", 
+                  :created_at => i.hours.ago)
+    end
+  end
+
+  describe "fetching the nil page" do
+    before do
+      @found = User.paginate(:name      => "Fred", 
+                             :order!    => :created_at.desc,
+                             :page!     => nil,
+                             :per_page! => 5)
+    end
+
+    it "returns the first :per_page results" do
+      @found.should == @users.slice(0,5)
+    end
+
+    it "returns an instance of WillPaginate::Collection" do
+      @found.should be_instance_of(WillPaginate::Collection)
+    end
+  end
+
+  describe "fetching a page by number" do
+    before do
+      @found = User.paginate(:name      => "Fred", 
+                             :order!    => :created_at.desc,
+                             :page!     => 2,
+                             :per_page! => 5)
+    end
+
+    it "returns the :per_page results starting at offset :per_page * page" do
+      @found.should == @users.slice(5,5)
+    end
+
+    it "returns an instance of WillPaginate::Collection" do
+      @found.should be_instance_of(WillPaginate::Collection)
+    end
+  end
+
+  describe "when :page is a string" do
+    before do
+      @found = User.paginate(:name      => "Fred", 
+                             :order!    => :created_at.desc,
+                             :page!     => "2",
+                             :per_page! => 5)
+    end
+
+    it "returns the :per_page results starting at offset :per_page * page" do
+      @found.should == @users.slice(5,5)
+    end
+
+    it "returns an instance of WillPaginate::Collection" do
+      @found.should be_instance_of(WillPaginate::Collection)
+    end
+  end
+end

data/spec/integration/scope_chaining_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path("../../spec_helper", __FILE__)
+require "active_support/core_ext"
+
+describe "Chaining scopes together" do
+  describe "then calling #all" do
+    before do
+      User.all(:name => "Quagmire").each { |q| q.destroy }
+      @users = (0...10).map do |i|
+        User.create :name       => "Quagmire",
+                    :created_at => i.hours.ago
+      end
+    end
+
+    it "queries using a combination of both scopes" do
+      User.named_quagmire.recent.all.should == @users.slice(0, 3)
+    end
+
+    it "gives scopes on the right priority" do
+      User.named_joe.named_quagmire.first.name.should == "Quagmire"
+    end
+  end
+end

data/spec/integration/table_creator_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Creating the tables for a model" do
+  before do
+    @klass = Class.new do
+      include Friendly::Document
+
+      def self.table_name; "stuffs"; end
+
+      attribute :name,    String
+      attribute :user_id, Friendly::UUID
+
+      indexes [:name, :created_at]
+      indexes :user_id
+    end
+
+    @klass.create_tables!
+    @schema           = Friendly.db.schema(:stuffs)
+    @unique_id_index  = Friendly.db.indexes(:stuffs)
+    @table            = Hash[*@schema.map { |s| [s.first, s.last] }.flatten]
+    @index_schema     = Friendly.db.schema(:index_stuffs_on_name_and_created_at)
+    @index_table      = Hash[*@index_schema.map { |s| [s.first, s.last] }.flatten]
+    @id_idx_schema    = Friendly.db.schema(:index_stuffs_on_user_id)
+    @id_index_table   = Hash[*@id_idx_schema.map { |s| [s.first, s.last] }.flatten]
+  end
+
+  after do
+    Friendly.db.drop_table(:stuffs) 
+    Friendly.db.drop_table(:index_stuffs_on_name_and_created_at) 
+  end
+
+  it "creates a table for the document" do
+    @table.keys.length.should == 5
+    @table[:added_id][:db_type].should == "int(11)"
+    @table[:added_id][:primary_key].should be_true
+    @table[:id][:db_type].should == "binary(16)"
+    @table[:attributes][:db_type].should == "text"
+    @table[:created_at][:db_type].should == "datetime"
+    @table[:updated_at][:db_type].should == "datetime"
+    
+    @unique_id_index.keys.length.should == 1
+    @unique_id_index[:id][:columns].should == [:id]
+    @unique_id_index[:id][:unique].should be_true
+  end
+
+  it "creates a table for each index" do
+    @index_table.keys.length.should == 3
+    @index_table[:name][:db_type].should == "varchar(255)"
+    @index_table[:name][:primary_key].should be_true
+    @index_table[:created_at][:db_type].should == "datetime"
+    @index_table[:created_at][:primary_key].should be_true
+    @index_table[:id][:db_type].should == "binary(16)"
+    @index_table[:id][:primary_key].should be_true
+  end
+
+  it "knows how to create an index for a field of a custom type" do
+    @id_index_table.keys.length.should == 2
+    @id_index_table[:user_id][:db_type].should == "binary(16)"
+    @id_index_table[:user_id][:primary_key].should be_true
+    @id_index_table[:id][:db_type].should == "binary(16)"
+    @id_index_table[:id][:primary_key].should be_true
+  end
+
+  it "doesn't raise if the tables already exist" do
+    lambda {
+      @klass.create_tables!
+    }.should_not raise_error
+  end
+end

data/spec/integration/write_through_cache_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Writing through to cache on create" do
+  before do
+    @address = Address.create :street => "Spooner"
+  end
+  
+  it "writes through to memcache using the model street and guid as cache key" do
+    $cache.get("Address/0/#{@address.id.to_guid}").should == @address
+  end
+end
+
+describe "Writing with a version number" do
+  before do
+    Address.storage_proxy.caches.clear
+    Address.caches_by :id, :version => 1
+    @address = Address.create :street => "Spooner"
+  end
+
+  after do
+    Address.storage_proxy.caches.clear
+    Address.caches_by :id
+  end
+
+  it "adds the version number to the cache key" do
+    $cache.get("Address/1/#{@address.id.to_guid}").should == @address
+  end
+end
+
+describe "Writing through to cache on update" do
+  before do
+    @address = Address.create :street => "Spooner"
+    @address.street = "Joe"
+    @address.save
+  end
+  
+  it "writes through to memcache using the model street and guid as cache key" do
+    $cache.get("Address/0/#{@address.id.to_guid}").street.should == @address.street
+  end
+end
+
+describe "Writing through to cache on destroy" do
+  before do
+    @address = Address.create :street => "Spooner"
+    @address.destroy
+  end
+  
+  it "removes the object from cache" do
+    lambda {
+      $cache.get("Address/0/#{@address.id.to_guid}") 
+    }.should raise_error(Memcached::NotFound)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color --backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,105 @@
+$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/pure'
+gem     'jferris-mocha'
+require 'mocha'
+require 'memcached'
+require 'friendly'
+
+config = YAML.load(File.read(File.dirname(__FILE__) + "/config.yml"))['test']
+Friendly.configure config
+$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
+  attribute :friend,     Friendly::UUID
+
+  indexes   :happy
+  indexes   :friend
+  indexes   :name
+  indexes   :name, :created_at
+
+  named_scope :named_joe,      :name   => "Joe"
+  named_scope :named_quagmire, :name   => "Quagmire"
+  named_scope :recent,         :order! => :created_at.desc,
+                               :limit! => 3
+
+  has_many    :addresses
+  has_many    :addresses_override, :class_name  => "Address",
+                                   :foreign_key => :user_id
+end
+
+User.create_tables!
+
+class Address
+  include Friendly::Document
+
+  attribute :user_id, Friendly::UUID
+  attribute :street,  String
+
+  indexes   :user_id
+  indexes   :street
+  indexes   :created_at
+
+  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