honkster-friendly 0.5.1

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,64 @@
+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)
+    @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"
+  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

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