friendly 0.3.3

data/spec/fakes/database_fake.rb

@@ -0,0 +1,12 @@
+class DatabaseFake
+  attr_accessor :from
+
+  def initialize(from)
+    @from = from
+  end
+
+  def from(table)
+    @from[table]
+  end
+end
+

data/spec/fakes/dataset_fake.rb

@@ -0,0 +1,28 @@
+class DatasetFake
+  attr_accessor :where, :insert, :inserts, :update, :updates, :first
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+    @inserts ||= []
+    @updates ||= []
+  end
+
+  def where(conditions)
+    @where[conditions]
+  end
+
+  def insert(attributes)
+    inserts << attributes
+    @insert
+  end
+
+  def update(attributes)
+    updates << attributes
+    @update
+  end
+
+  def first(conditions)
+    @first[conditions]
+  end
+end
+

data/spec/fakes/document.rb

@@ -0,0 +1,18 @@
+class FakeDocument
+  attr_accessor :id, :created_at, :to_hash, :new_record, :table_name,
+                :indexes, :name, :updated_at, :where_clause
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+    new_record = true if new_record.nil?
+  end
+
+  def new_record?
+    new_record
+  end
+
+  def attributes=(attrs)
+    attrs.each { |k,v| send("#{k}=", v) }
+  end
+end
+

data/spec/fakes/serializer_fake.rb

@@ -0,0 +1,12 @@
+class SerializerFake
+  attr_writer :generate
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+  end
+
+  def generate(args)
+    @generate[args]
+  end
+end
+

data/spec/fakes/time_fake.rb

@@ -0,0 +1,12 @@
+class TimeFake
+  attr_writer :time
+
+  def initialize(time)
+    @time = time
+  end
+
+  def new
+    @time
+  end
+end
+

data/spec/integration/basic_object_lifecycle_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Creating and retrieving an object" do
+  before do
+    @user       = User.new :name => "Stewie Griffin",
+                           :age  => 3
+    @user.save
+    @found_user = User.find(@user.id)
+  end
+
+  it "finds the user in the database" do
+    @found_user.name.should == @user.name
+    @found_user.age.should  == @user.age
+    @found_user.id.should   == @user.id
+  end
+
+  it "locates an object that is == to the created object" do
+    @found_user.should == @user
+  end
+
+  it "sets the created_at timestamp for the record" do
+    @user.created_at.should_not be_nil
+    @user.created_at.should be_instance_of(Time)
+  end
+
+  it "sets the created_at on the way out of the database" do
+    @found_user.created_at.should_not be_nil
+    @found_user.created_at.to_i.should == @user.created_at.to_i
+  end
+
+  it "sets the updated_at on the way out of the database" do
+    @found_user.updated_at.should_not be_nil
+    @found_user.updated_at.to_i.should == @user.updated_at.to_i
+  end
+
+  it "sets the updated_at" do
+    @user.updated_at.to_i.should == @user.created_at.to_i
+  end
+
+  it "doesn't serialize id, created_at, or updated_at in the attributes column" do
+    result = $db.from("users").first(:id => @user.id)
+    attrs  = JSON.parse(result[:attributes])
+    attrs.keys.should_not include("id")
+    attrs.keys.should_not include("created_at")
+    attrs.keys.should_not include("updated_at")
+  end
+
+  it "has an id of type Friendly::UUID" do
+    @user.id.should be_kind_of(Friendly::UUID)
+  end
+end
+
+describe "Updating an object" do
+  before do
+    @user = User.new :name => "Stewie Griffin",
+                     :age  => 3
+    @user.save
+    @created_id = @user.id
+    @created_at = @user.created_at
+
+    sleep(0.1)
+    @user.name = "Brian Griffin"
+    @user.age  = 8
+    @user.save
+
+    @found_user = User.find(@created_id)
+  end
+
+  it "sets the updated_at column" do
+    @user.updated_at.should_not be_nil
+    @user.updated_at.should_not == @user.created_at
+    @user.updated_at.should > @user.created_at
+  end
+
+  it "doesn't change the created_at" do
+    @user.created_at.should == @created_at
+  end
+
+  it "doesn't change the id" do
+    @user.id.should == @created_id
+  end
+
+  it "saves the new attrs to the db" do
+    @found_user.name.should == "Brian Griffin"
+    @found_user.age.should  == 8
+  end
+end
+
+describe "destroying a document" do
+  before do
+    @user = User.new :name => "Stewie Griffin"
+    @user.save
+    @user.destroy
+  end
+
+  it "removes it from the database" do
+    User.first(:id => @user.id).should be_nil
+  end
+end
+
+describe "Finding an object by id" do
+  it "raises Friendly::RecordNotFound if it doesn't exist" do
+    lambda { User.find(12345) }.should raise_error(Friendly::RecordNotFound)
+  end
+end
+
+describe "An object that has a foreign key" do
+  it "is saveable in the database" do
+    lambda {
+        Address.create :user_id => Friendly::UUID.new
+    }.should_not raise_error
+  end
+end
+

data/spec/integration/batch_insertion_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Batch inserting several documents" do
+  it "inserts them when the block returns" do
+    Friendly.batch do
+      user = User.new(:name => "Lois")
+      user.save
+      User.all(:name => "Lois").should be_empty
+    end
+
+    User.all(:name => "Lois").should_not be_empty
+  end
+
+  it "doesn't insert anything if an error is raised" do
+    begin
+      Friendly.batch do
+        user = User.new(:name => "Meg")
+        user.save
+        raise "AHHHH!"
+      end
+    rescue RuntimeError => e
+      @bubbled_up = true
+    end
+
+    @bubbled_up.should be_true
+
+    User.all(:name => "Meg").should be_empty
+  end
+end

data/spec/integration/convenience_api_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Document.create" do
+  before do
+    @user = User.create(:name => "James")
+  end
+
+  it "initializes the document, saves it, and returns it" do
+    @user.name.should == "James"
+    @user.should_not be_new_record
+    User.find(@user.id).should_not be_nil
+  end
+end
+
+describe "Document#update_attributes" do
+  before do
+    @user = User.create
+    @user.update_attributes :name => "James"
+    @user = User.find(@user.id)
+  end
+
+  it "updates the attributes in the database" do
+    @user.name.should == "James"
+  end
+end

data/spec/integration/count_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Counting the objects matching a query" do
+  before do
+    User.all(:name => "Evil Monkey").each { |u| u.destroy }
+    5.times { User.create :name => "Evil Monkey" }
+  end
+
+  it "does a count in the index to find out what matches" do
+    User.count(:name => "Evil Monkey").should == 5
+  end
+end

data/spec/integration/default_value_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "An attribute with a default value" do
+  before do
+    @user = User.new
+  end
+
+  it "has the value by default" do
+    @user.happy.should be_true
+  end
+
+  it "has a default vaue even when it's false" do
+    @user.sad.should be_false
+  end
+end

data/spec/integration/find_via_cache_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Finding objects in the cache" do
+  def cache_key(user)
+    ["Address", 0, user.id.to_guid].join("/")
+  end
+
+  describe "by id" do
+    before do
+      @address = Address.create :street => "Spooner"
+    end
+
+    describe "if the user is in cache" do
+      before do
+        $cache.set(cache_key(@address), "the address")
+      end
+
+      it "returns the object from cache if its there" do
+        Address.first(:id => @address.id).should == "the address"
+      end
+    end
+
+    describe "if the user isn't there" do
+      before do
+        $cache.delete(cache_key(@address))
+        @found = Address.first(:id => @address.id)
+      end
+
+      it "finds the object in the database" do
+        @found.should == @address
+      end
+
+      it "stores the object in cache (read through)" do
+        $cache.get(cache_key(@address)).should == @address
+      end
+    end
+  end
+
+  describe "several objects via id" do
+    before do
+      @addresses = (0..3).map { Address.create :street => "Spooner" }
+    end
+
+    describe "when all objects are found" do
+      before do
+        @addresses.each { |a| $cache.set(cache_key(a), "the address") }
+      end
+
+      it "returns all the objects from cache" do
+        Address.all(:id => @addresses.map { |u| u.id }).should == ["the address"] * 4
+      end
+    end
+
+    describe "when some objects are missing" do
+      before do
+        $cache.delete(cache_key(@addresses.first))
+        @found = Address.all(:id => @addresses.map { |u| u.id })
+      end
+
+      it "finds the object and returns it" do
+        expected = @addresses.sort { |a,b| a.id <=> b.id }
+        @found.sort { |a,b| a.id <=> b.id }.should == expected
+      end
+
+      it "writes the object through to the cache" do
+        lambda {
+          $cache.get(cache_key(@addresses.first))
+        }.should_not raise_error
+      end
+    end
+  end
+
+  describe "calling all when the array of ids is empty" do
+    it "returns nothing" do
+      Address.all(:id => [])
+    end
+  end
+
+  describe "finding several objects in order via cache" do
+    before do
+      @addresses = (0...5).map { Address.create :street => "Spooner" }
+    end
+
+    it "returns them in order" do
+      fnd = Address.all(:id => @addresses.map { |a| a.id }, :preserve_order! => true)
+      fnd.should == @addresses
+    end
+  end
+
+  describe "when there's an object in the index that doesn't really exist" do
+    before do
+      table = $db.from("index_addresses_on_street")
+      table.where(:street => "Quahog").delete
+      table.insert(:street => "Quahog", :id => "12345")
+    end
+
+    it "just returns [] silently on #all" do
+      Address.all(:street => "Quahog").should == []
+    end
+  end
+end

data/spec/integration/finder_spec.rb

@@ -0,0 +1,64 @@
+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 multiple objects by id" do
+  before do
+    @user_one = User.new
+    @user_two = User.new
+    @user_one.save
+    @user_two.save
+    @users    = User.all(:id => [@user_one.id, @user_two.id])
+  end
+
+  it "finds the objects in the database" do
+    @users.length.should == 2
+    @users.should include(@user_one)
+    @users.should include(@user_two)
+  end
+
+  describe "when no objects are found" do
+    it "returns an empty array" do
+      User.all(:id => [9999, 12345, 999]).should == []
+    end
+  end
+
+  describe "when one object is found, but others aren't" do
+    it "returns the found objects" do
+      User.all(:id => [@user_one.id, 12345]).should == [@user_one]
+    end
+  end
+end
+
+describe "Limiting a query" do
+  before do
+    10.times { User.new(:name => "Stewie").save }
+    @results = User.all(:name => "Stewie", :limit! => 5)
+  end
+
+  it "returns the number of results you asked for" do
+    @results.length.should == 5
+  end
+end
+
+describe "limiting a query with offset" do
+  before do
+    @objects = (0..10).map do |i| 
+      User.new(:name => "Joe", :created_at => i.minutes.from_now).tap do |u|
+        u.save
+      end
+    end
+  end
+
+  after { @objects.each { |o| o.destroy } }
+
+  it "returns results starting from the offset to hte limit" do
+    User.all(:name    => "Joe", 
+             :offset! => 2, 
+             :limit!  => 2,
+             :order!  => :created_at.desc).should == @objects.reverse.slice(2, 2)
+  end
+end

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

@@ -0,0 +1,52 @@
+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
+
+      indexes [:name, :created_at]
+    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]
+  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 "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