wayne-friendly 0.5.1

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,30 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "An attribute with a default value" do
+  describe "before saving" 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
+
+  describe "after saving" do
+    before do
+      @user = User.new
+      @user.save
+      @user = User.find(@user.id)
+    end
+
+    it "doesn't set the existing attributes as dirty" do
+      @user.should_not be_changed
+      @user.should_not be_happy_changed
+    end
+  end
+end

data/spec/integration/dirty_tracking_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Changing an attribute" do
+  describe "before a record is saved" do
+    before do
+      @user      = User.new
+      @user.name = "James"
+    end
+
+    it "responds to the attribute being changed" do
+      @user.should be_name_changed
+    end
+
+    it "returns the original value of the attribute" do
+      @user.name_was.should == ""
+    end
+
+    it "is changed" do
+      @user.should be_changed
+    end
+  end
+
+  describe "after saving a record with changed attributes" do
+    before do
+      @user      = User.create
+      @user.name = "James"
+      @user.save
+    end
+
+    it "is no longer attribute_changed?" do
+      @user.should_not be_name_changed
+    end
+
+    it "returns nil for attribute_was" do
+      @user.name_was.should be_nil
+    end
+
+    it "is no longer changed" do
+      @user.should_not be_changed
+    end
+  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,71 @@
+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
+
+describe "all with only order" do
+  it "queries the index" do
+    Address.create
+      Address.all(:order! => :created_at.desc, :limit! => 5)
+  end
+end

data/spec/integration/has_many_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Has many associations" do
+  before do
+    @user      = User.create :name => "Fred"
+    @addresses = (0..2).map { Address.create :user_id => @user.id }
+  end
+
+  it "returns the objects whose foreign keys match the object's id" do
+    found = @user.addresses.all.sort { |a, b| a.id <=> b.id }
+    found.should == @addresses.sort { |a, b| a.id <=> b.id }
+  end
+
+  it "accepts class_name and foreign_key overrides" do
+    found = @user.addresses_override.all.sort { |a, b| a.id <=> b.id }
+    found.should == @addresses.sort { |a, b| a.id <=> b.id }
+  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/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