friendly_postgres 0.4.3

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.detect { |k,v| k == conditions }.last
+  end
+
+  def insert(attributes)
+    inserts << attributes
+    @insert
+  end
+
+  def update(attributes)
+    updates << attributes
+    @update
+  end
+
+  def first(conditions)
+    @first.detect { |k,v| k == conditions }.last
+  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/ad_hoc_scopes_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Querying with an ad-hoc scope" do
+  before do
+    User.all(:name => "Fred").each { |u| u.destroy }
+    @users = (1..10).map { User.create(:name => "Fred") }
+  end
+
+  it "can return all the objects matching the scope" do
+    User.scope(:name => "Fred").all.should == @users
+  end
+
+  it "can return the first object matching the scope" do
+    User.scope(:name => "Fred").first.should == User.first(:name => "Fred")
+  end
+
+  it "can paginate over the matching objects" do
+    found = User.scope(:name => "Fred").paginate(:per_page! => 5)
+    found.should == User.paginate(:name => "Fred", :per_page! => 5)
+  end
+
+  it "can build an object at scope" do
+    User.scope(:name => "Fred", :limit! => 5).build.name.should == "Fred"
+  end
+
+  it "supports overriding parameters when building" do
+    scope = User.scope(:name => "Fred", :limit! => 5)
+    scope.build(:name => "Joe").name.should == "Joe"
+  end
+
+  it "can create an object at scope" do
+    user = User.scope(:name => "Joe").create
+    user.should_not be_new_record
+    user.name.should == "Joe"
+  end
+
+  it "supports overriding parameters when creating" do
+    user = User.scope(:name => "Joe").create(:name => "Fred")
+    user.should_not be_new_record
+    user.name.should == "Fred"
+  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 => Friendly::UUID.new)
+    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