cequel 0.5.6 → 1.0.0.pre.1

data/spec/examples/model/dirty_spec.rb

@@ -1,39 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::Dirty do
-  let(:post) { Post.new(:id => 1) }
-
-  it 'should not have changed attributes by default' do
-    post.changed_attributes.should be_empty
-  end
-
-  it 'should have changed attributes if attributes change' do
-    post.title = 'Cequel'
-    post.changed_attributes.should == {:title => nil}.with_indifferent_access
-  end
-
-  it 'should not have changed attributes if attribute set to the same thing' do
-    post.title = nil
-    post.changed_attributes.should be_empty
-  end
-
-  it 'should support *_changed? method' do
-    post.title = 'Cequel'
-    post.title_changed?.should be_true
-  end
-
-  it 'should not have changed attributes after save' do
-    connection.stub(:execute)
-    post.title = 'Cequel'
-    post.save
-    post.changed_attributes.should be_empty
-  end
-
-  it 'should have previous changes after save' do
-    connection.stub(:execute)
-    post.title = 'Cequel'
-    post.save
-    post.previous_changes.
-      should == { :title => [nil, 'Cequel'] }.with_indifferent_access
-  end
-end

data/spec/examples/model/dynamic_spec.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::Dynamic do
-
-  let(:category) { Category.new(:id => 1, :name => 'Big Data') }
-
-  it 'should allow getting and setting of dynamic attributes' do
-    category[:tag] = 'bigdata'
-    category[:tag].should == 'bigdata'
-  end
-
-  it 'should insert dynamic values' do
-    category[:tag] = 'bigdata'
-    connection.should_receive(:execute).
-      with "INSERT INTO categories (?) VALUES (?)", ['id', 'name', 'tag'], [1, 'Big Data', 'bigdata']
-    category.save
-  end
-
-  it 'should update dynamic values' do
-    category[:tag] = 'bigdata'
-    connection.stub(:execute).
-      with "INSERT INTO categories (?) VALUES (?)", ['id', 'name', 'tag'], [1, 'Big Data', 'bigdata']
-    category.save
-    category[:tag] = 'big-data'
-    category[:color] = 'blue'
-    connection.should_receive(:execute).
-      with "UPDATE categories SET ? = ?, ? = ? WHERE ? = ?", 'tag', 'big-data', 'color', 'blue', :id, 1
-    category.save
-  end
-
-  it 'should delete dynamic values' do
-    category[:tag] = 'bigdata'
-    connection.stub(:execute).
-      with "INSERT INTO categories (?) VALUES (?)", ['id', 'name', 'tag'], [1, 'Big Data', 'bigdata']
-    category.save
-    category[:tag] = nil
-    connection.should_receive(:execute).
-      with "DELETE ? FROM categories WHERE ? = ?", ['tag'], :id, 1
-    category.save
-  end
-end

data/spec/examples/model/inheritable_spec.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::Inheritable do
-  it 'should inherit key from superclass' do
-    Photo.key_alias.should == :id
-  end
-
-  it 'should inherit columns from superclass' do
-    Photo.column_names.should == [:id, :class_name, :label, :checksum, :url]
-  end
-
-  it 'should return ::base_class for base class' do
-    Asset.base_class.should == Asset
-  end
-
-  it 'should return ::base_class for subclass' do
-    Photo.base_class.should == Asset
-  end
-
-  it 'should not allow overriding a class without a type column' do
-    base = Class.new do
-      include Cequel::Model
-      key :id, :integer
-    end
-    expect { sub = Class.new(base) }.to raise_error(ArgumentError)
-  end
-
-  it 'should set type on initialization' do
-    Photo.new.class_name.should == 'Photo'
-  end
-
-  it 'should query correct column family when querying subclass' do
-    connection.stub(:execute).
-      with("SELECT * FROM assets WHERE ? = ? LIMIT 1", :id, 1).
-      and_return result_stub(:id => 1, :label => 'Cequel')
-    Photo.find(1)
-  end
-
-  it 'should hydrate correct model class when querying base class' do
-    connection.stub(:execute).
-      with('SELECT * FROM assets WHERE ? = ? LIMIT 1', :id, 1).
-      and_return result_stub(:id => 1, :class_name => 'Photo', :label => 'Cequel')
-    Asset.find(1).should be_a(Photo)
-  end
-end

data/spec/examples/model/magic_spec.rb

@@ -1,199 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::Magic do
-  describe '::find_by_*' do
-    it 'should magically look up one record by given value' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :title, 'Cequel').
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.find_by_title('Cequel').id.should == 1
-    end
-
-    it 'should magically look up one record by multiple values' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1, :title => 'Cequel', :published => true)
-
-      Post.find_by_title_and_published('Cequel', true).id.should == 1
-    end
-
-    it 'should magically work on scopes' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? = ? AND ? = ? LIMIT 1", [:id], :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1)
-
-      Post.select(:id).find_by_title_and_published('Cequel', true).id.should == 1
-    end
-
-    it 'should raise error if specified columns different from arg count' do
-      expect { Post.find_by_title_and_published('Cequel') }.
-        to raise_error(ArgumentError)
-    end
-  end
-
-  describe '::find_all_by_*' do
-    context 'with existing record specified as args' do
-      it 'should magically look up one record by multiple values' do
-        connection.stub(:execute).
-          with("SELECT * FROM posts WHERE ? = ? AND ? = ?", :title, 'Cequel', :published, true).
-          and_return result_stub(
-            {:id => 1, :title => 'Cequel', :published => true},
-            {:id => 2, :title => 'Cequel2', :published => true }
-          )
-
-        Post.find_all_by_title_and_published('Cequel', true).map(&:id).
-          should == [1, 2]
-      end
-
-      it 'should magically work on scopes' do
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ? AND ? = ?", [:id], :title, 'Cequel', :published, true).
-          and_return result_stub(
-            {:id => 1},
-            {:id => 2}
-          )
-
-        Post.select(:id).find_all_by_title_and_published('Cequel', true).map(&:id).
-          should == [1, 2]
-      end
-    end
-  end
-
-  describe '::find_or_create_by_*' do
-    it 'should return existing record from args' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1, :title => 'Cequel', :published => true)
-
-      Post.find_or_create_by_title_and_published('Cequel', true).id.should == 1
-    end
-
-    it 'should create new record from args' do
-      now = Time.now
-      Time.stub!(:now).and_return now
-      connection.stub(:execute).
-        with("SELECT * FROM blogs WHERE ? = ? LIMIT 1", :id, 1).
-        and_return result_stub
-      connection.should_receive(:execute).
-        with(
-          "INSERT INTO blogs (?) VALUES (?)",
-          ['id', 'published', 'updated_at', 'created_at'],
-          [1, true, now, now]
-        )
-
-      Blog.find_or_create_by_id(1).id.should == 1
-    end
-
-    it 'should look up record from attributes' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1, :title => 'Cequel', :published => true)
-
-      Post.find_or_create_by_title_and_published(
-        :id => 2, :title => 'Cequel', :published => true
-      ).id.should == 1
-    end
-
-    it 'should create record from all attributes specified, including non-lookup ones' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub
-      connection.should_receive(:execute).
-        with(
-          "INSERT INTO posts (?) VALUES (?)",
-          ['id', 'title', 'published'],
-          [2, 'Cequel', true])
-
-      Post.find_or_create_by_title_and_published(
-        :id => 2, :title => 'Cequel', :published => true
-      ).id.should == 2
-    end
-
-    it 'should yield instance on create if block given' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub
-      connection.should_receive(:execute).
-        with(
-          "INSERT INTO posts (?) VALUES (?)",
-          ['id', 'title', 'published'],
-          [2, 'Cequel', true]
-        )
-
-      Post.find_or_create_by_title_and_published('Cequel', true) do |post|
-        post.id = 2
-      end.id.should == 2
-    end
-
-    it 'should work on scopes' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? = ? AND ? = ? LIMIT 1", [:id], :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1)
-
-      Post.select(:id).find_or_create_by_title_and_published('Cequel', true).id.
-        should == 1
-    end
-  end
-
-  describe '::find_or_initialize_by_*' do
-    it 'should return existing record from args' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1, :title => 'Cequel', :published => true)
-
-      Post.find_or_initialize_by_title_and_published('Cequel', true).id.should == 1
-    end
-
-    it 'should initialize new record from args' do
-      now = Time.now
-      Time.stub!(:now).and_return now
-      timestamp = (now.to_f * 1000).to_i
-      connection.stub(:execute).
-        with("SELECT * FROM blogs WHERE ? = ? LIMIT 1", :id, 1).
-        and_return result_stub
-
-      Blog.find_or_initialize_by_id(1).id.should == 1
-    end
-
-    it 'should look up record from attributes' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1, :title => 'Cequel', :published => true)
-
-      Post.find_or_initialize_by_title_and_published(
-        :id => 2, :title => 'Cequel', :published => true
-      ).id.should == 1
-    end
-
-    it 'should create record from all attributes specified, including non-lookup ones' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub
-
-      Post.find_or_initialize_by_title_and_published(
-        :id => 2, :title => 'Cequel', :published => true
-      ).id.should == 2
-    end
-
-    it 'should yield instance on initialize if block given' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ? AND ? = ? LIMIT 1", :title, 'Cequel', :published, true).
-        and_return result_stub
-
-      Post.find_or_initialize_by_title_and_published('Cequel', true) do |post|
-        post.id = 2
-      end.id.should == 2
-    end
-
-    it 'should work on scopes' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? = ? AND ? = ? LIMIT 1", [:id], :title, 'Cequel', :published, true).
-        and_return result_stub(:id => 1)
-
-      Post.select(:id).find_or_initialize_by_title_and_published('Cequel', true).id.
-        should == 1
-    end
-
-  end
-end

data/spec/examples/model/mass_assignment_security_spec.rb

@@ -1,13 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::MassAssignmentSecurity do
-  let(:post) { Post.new(:id => 1, :title => 'Cequel', :blog_id => 3) }
-
-  it 'should allow setting of unprotected attributes' do
-    post.title.should == 'Cequel'
-  end
-
-  it 'should not allow setting of protected attributes' do
-    post.blog_id.should be_nil
-  end
-end

data/spec/examples/model/observer_spec.rb

@@ -1,86 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::Observer do
-  before do
-    Cequel::Model.observers = [:post_observer, :asset_observer]
-    Cequel::Model.instantiate_observers
-  end
-
-  let(:post) do
-    connection.stub(:execute).
-      with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :id, 1).
-      and_return result_stub('id' => 1, 'title' => 'Hey')
-    Post.find(1)
-  end
-
-  shared_examples_for 'observing callbacks' do |*callbacks|
-
-    all_callbacks = [
-      :before_create, :after_create, :before_update, :after_update,
-      :before_save, :after_save, :before_destroy, :after_destroy,
-      :before_validation, :after_validation
-    ]
-
-    callbacks.each do |callback|
-      it "should observe #{callback}" do
-        post.should have_been_observed(callback)
-      end
-    end
-
-    (all_callbacks - callbacks).each do |callback|
-      it "should not observe #{callback}" do
-        post.should_not have_been_observed(callback)
-      end
-    end
-  end
-
-  context 'on create' do
-    let(:post) do
-      connection.stub(:execute).
-        with "INSERT INTO posts (?) VALUES (?)", ['id', 'title'], [1, 'Hey']
-      Post.new(:id => 1, :title => 'Hey')
-    end
-
-    before { post.save }
-
-    it_should_behave_like 'observing callbacks',
-      :before_create, :after_create, :before_save, :after_save, :before_validation, :after_validation
-  end
-
-  context 'on update' do
-
-    before { post.save }
-
-    it_should_behave_like 'observing callbacks',
-      :before_update, :after_update, :before_save, :after_save, :before_validation, :after_validation
-  end
-
-  context 'on destroy 'do
-
-    before do
-      connection.stub(:execute).
-        with "DELETE FROM posts WHERE ? = ?", :id, 1
-
-      post.destroy
-    end
-
-    it_should_behave_like 'observing callbacks', :before_destroy, :after_destroy
-  end
-
-  context 'on validation' do
-    before do
-      post.valid?
-    end
-
-    it_should_behave_like 'observing callbacks', :before_validation, :after_validation
-  end
-
-  context 'with inheritence' do
-    it 'should observe subclass' do
-      connection.stub(:execute).
-        with("INSERT INTO assets (?) VALUES (?)", ['id', 'label', 'class_name'], [1, 'Cequel', 'Photo'])
-      photo = Photo.create!(:id => 1, :label => 'Cequel')
-      photo.should have_observed(:before_save)
-    end
-  end
-end

data/spec/examples/model/scope_spec.rb

@@ -1,677 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe Cequel::Model::Scope do
-  describe '#each' do
-    it 'should provide enumerator for query results' do
-      connection.stub(:execute).with("SELECT * FROM posts").
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.all.map { |post| [post.id, post.title] }.
-        should == [[1, 'Cequel']]
-    end
-
-    it 'should enumerate results for just id if no key restriction' do
-      connection.stub(:execute).with("SELECT ? FROM posts", [:id]).
-        and_return result_stub(:id => 1)
-
-      Post.select(:id).to_a.map { |post| post.id }.should == [1]
-    end
-
-    it 'should not enumerate results for just id if key restriction' do
-      connection.stub(:execute).with("SELECT * FROM posts").
-        and_return result_stub(:id => 1)
-
-      Post.all.to_a.map { |post| post.id }.should == []
-    end
-
-    it 'should provide enumerator if no block given' do
-      enum = Post.all.each
-
-      connection.stub(:execute).with("SELECT * FROM posts").
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      enum.map { |post| post.title }.should == ['Cequel']
-    end
-
-    it 'should enumerate zero times if empty-collection key restriction given' do
-      Post.where(:id => []).to_a.should == []
-    end
-
-    it 'should enumerate zero times if empty-collection restriction given' do
-      Post.where(:title => []).to_a.should == []
-    end
-  end
-
-  describe '#first' do
-    it 'should query for a single post' do
-      connection.stub(:execute).with("SELECT * FROM posts LIMIT 1").
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.first.title.should == 'Cequel'
-    end
-
-    it 'should query for a single post within scope' do
-      connection.stub(:execute).with("SELECT ? FROM posts LIMIT 1", [:id, :title]).
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.select(:id, :title).first.title.should == 'Cequel'
-    end
-
-    it 'should query scopes successively when multi-valued non-key column selected' do
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :title, 'Cequel').
-        and_return result_stub
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :title, 'Cassandra').
-        and_return result_stub(:id => 1, :title => 'Cassandra')
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ? LIMIT 1", :title, 'CQL').
-        and_return result_stub(:id => 2, :title => 'CQL')
-
-      Post.where(:title => %w(Cequel Cassandra CQL)).first.title.
-        should == 'Cassandra'
-    end
-
-    it 'should apply index preference when specified' do
-      connection.should_receive(:execute).
-        with("SELECT * FROM assets WHERE ? = ? AND ? = ? LIMIT 1", :checksum, 'abcdef', :class_name, 'Photo').
-        and_return result_stub
-      Photo.where(:checksum => 'abcdef').first
-    end
-
-    it 'should return nil when empty key collection given' do
-      Post.where(:id => []).first.should be_nil
-    end
-
-    it 'should return nil when empty non-key collection given' do
-      Post.where(:title => []).first.should be_nil
-    end
-  end
-
-  describe '#count' do
-    it 'should count records' do
-      connection.stub(:execute).with("SELECT COUNT(*) FROM posts").
-        and_return result_stub('count' => 5)
-
-      Post.count.should == 5
-    end
-
-    it 'should count records in scope' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 5)
-
-      Post.where(:blog_id => 1).count.should == 5
-    end
-
-    it 'should raise error if attempting count with key restriction' do
-      expect { Post.where(:id => [1, 2, 3]).count }.
-        to raise_error(Cequel::Model::InvalidQuery)
-    end
-
-    it 'should perform multiple COUNT queries if non-key column selected for multiple values' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 3)
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 2).
-        and_return result_stub('count' => 2)
-
-      Post.where(:blog_id => [1, 2]).count.should == 5
-    end
-
-    it 'should return nil if empty non-key restriction given' do
-      Post.where(:title => []).count.should == 0
-    end
-
-    it 'should apply index preference when specified' do
-      connection.should_receive(:execute).
-        with("SELECT COUNT(*) FROM assets WHERE ? = ? AND ? = ?", :checksum, 'abcdef', :class_name, 'Photo').
-        and_return result_stub('count' => 0)
-      Photo.where(:checksum => 'abcdef').count
-    end
-  end
-
-  describe '#find' do
-    it 'should send scoped query when no block is passed' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? = ? LIMIT 1", [:id, :title], :id, 1).
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.select(:id, :title).find(1).title.should == 'Cequel'
-    end
-
-    it 'should send scoped query with multiple keys when no block is passed' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? IN (?)", [:id, :title], :id, [1, 2]).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel 2'}
-        )
-
-      Post.select(:id, :title).find(1, 2).
-        map { |post| post.title }.should == ['Cequel', 'Cequel 2']
-    end
-
-    it 'should delegate to enumerator when block is passed' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts", [:id, :title]).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel 2'}
-        )
-
-      Post.select(:id, :title).find { |post| post.id == 2 }.title.
-        should == 'Cequel 2'
-    end
-  end
-
-  describe '#any?' do
-    it 'if called without block, should return true if COUNT > 0' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 5)
-
-      Post.where(:blog_id => 1).any?.should be_true
-    end
-
-    it 'if called without block, should return false if COUNT == 0' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 0)
-
-      Post.where(:blog_id => 1).any?.should be_false
-    end
-
-    it 'if called with block should delegate to enumerator' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel 2'}
-        )
-
-      Post.where(:blog_id => 1).any? { |post| post.id == 1 }.should be_true
-      Post.where(:blog_id => 1).any? { |post| post.id == 8 }.should be_false
-    end
-  end
-
-  describe '#none?' do
-    it 'if called without block, should return false if COUNT > 0' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 5)
-
-      Post.where(:blog_id => 1).none?.should be_false
-    end
-
-    it 'if called without block, should return true if COUNT == 0' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 0)
-
-      Post.where(:blog_id => 1).none?.should be_true
-    end
-
-    it 'if called with block should delegate to enumerator' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel 2'}
-        )
-
-      Post.where(:blog_id => 1).none? { |post| post.id == 1 }.should be_false
-      Post.where(:blog_id => 1).none? { |post| post.id == 8 }.should be_true
-    end
-  end
-
-  describe '#one?' do
-    it 'if called without block, should return false if COUNT == 0' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 0)
-
-      Post.where(:blog_id => 1).one?.should be_false
-    end
-
-    it 'if called without block, should return true if COUNT == 1' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 1)
-
-      Post.where(:blog_id => 1).one?.should be_true
-    end
-
-    it 'if called without block, should return false if COUNT > 1' do
-      connection.stub(:execute).
-        with("SELECT COUNT(*) FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub('count' => 12)
-
-      Post.where(:blog_id => 1).one?.should be_false
-    end
-
-    it 'if called with block should delegate to enumerator' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel 2'}
-        )
-
-      Post.where(:blog_id => 1).none? { |post| post.id == 1 }.should be_false
-      Post.where(:blog_id => 1).none? { |post| post.id == 8 }.should be_true
-    end
-  end
-
-  describe '#find_in_batches' do
-    it 'should select in batches of given size' do
-      connection.stub(:execute).with("SELECT * FROM posts LIMIT 2").
-        and_return result_stub(
-          {:id => 1, :title => 'Post 1'},
-          {:id => 2, :title => 'Post 2'}
-        )
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? > ? LIMIT 2", :id, 2).
-        and_return result_stub(:id => 3, :title => 'Post 3')
-      batches = []
-      Post.find_in_batches(:batch_size => 2) do |batch|
-        batches << batch
-      end
-      batches.map { |batch| batch.map(&:title) }.should ==
-        [['Post 1', 'Post 2'], ['Post 3']]
-    end
-
-    it 'should not duplicate last key if given back first in next batch' do
-      connection.stub(:execute).with("SELECT * FROM posts LIMIT 2").
-        and_return result_stub(
-          {:id => 1, :title => 'Post 1'},
-          {:id => 2, :title => 'Post 2'}
-        )
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? > ? LIMIT 2", :id, 2).
-        and_return result_stub(
-          {:id => 2, :title => 'Post 2'},
-          {:id => 3, :title => 'Post 3'}
-        )
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? > ? LIMIT 2", :id, 3).
-        and_return result_stub()
-      batches = []
-      Post.find_in_batches(:batch_size => 2) do |batch|
-        batches << batch
-      end
-      batches.map { |batch| batch.map(&:title) }.should ==
-        [['Post 1', 'Post 2'], ['Post 3']]
-    end
-
-    it 'should iterate over batches of keys' do
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? IN (?)", :id, [1, 2]).
-        and_return result_stub(
-          {:id => 1, :title => 'Post 1'},
-          {:id => 2, :title => 'Post 2'}
-        )
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ?", :id, 3).
-        and_return result_stub(:id => 3, :title => 'Post 3')
-      batches = []
-      Post.where(:id => [1, 2, 3]).find_in_batches(:batch_size => 2) do |batch|
-        batches << batch
-      end
-      batches.map { |batch| batch.map(&:title) }.should ==
-        [['Post 1', 'Post 2'], ['Post 3']]
-    end
-
-    it 'should respect scope' do
-      connection.stub(:execute).with("SELECT ? FROM posts LIMIT 2", [:id, :title]).
-        and_return result_stub(
-          {:id => 1, :title => 'Post 1'},
-          {:id => 2, :title => 'Post 2'}
-        )
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? > ? LIMIT 2", [:id, :title], :id, 2).
-        and_return result_stub(:id => 3, :title => 'Post 3')
-      batches = []
-      Post.select(:id, :title).find_in_batches(:batch_size => 2) do |batch|
-        batches << batch
-      end
-      batches.map { |batch| batch.map(&:title) }.should ==
-        [['Post 1', 'Post 2'], ['Post 3']]
-    end
-
-    it 'should add key column to SELECT if omitted' do
-      connection.stub(:execute).with("SELECT ? FROM posts LIMIT 2", [:title, :id]).
-        and_return result_stub(
-          {:id => 1, :title => 'Post 1'},
-          {:id => 2, :title => 'Post 2'}
-        )
-      connection.stub(:execute).
-        with("SELECT ? FROM posts WHERE ? > ? LIMIT 2", [:title, :id], :id, 2).
-        and_return result_stub(:id => 3, :title => 'Post 3')
-      batches = []
-      Post.select(:title).find_in_batches(:batch_size => 2) do |batch|
-        batches << batch
-      end
-      batches.map { |batch| batch.map(&:title) }.should ==
-        [['Post 1', 'Post 2'], ['Post 3']]
-    end
-  end
-
-  describe '#find_each' do
-    it 'should iterate over batches and yield results one by one' do
-      connection.stub(:execute).with("SELECT * FROM posts LIMIT 2").
-        and_return result_stub(
-          {:id => 1, :title => 'Post 1'},
-          {:id => 2, :title => 'Post 2'}
-        )
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? > ? LIMIT 2", :id, 2).
-        and_return result_stub(:id => 3, :title => 'Post 3')
-      Post.find_each(:batch_size => 2).map { |post| post.title }.
-        should == ['Post 1', 'Post 2', 'Post 3']
-    end
-  end
-
-  describe '#select' do
-    it 'should scope columns in data set' do
-      connection.stub(:execute).with("SELECT ? FROM posts", [:id, :title]).
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.select(:id, :title).map { |post| post.title }.should == ['Cequel']
-    end
-
-    it 'should fail fast if attempting to select only key column with restrictions on key column' do
-      expect { Post.where(:id => 1).select(:id) }.
-        to raise_error(Cequel::Model::InvalidQuery)
-    end
-
-    it 'should delegate to enumerator if block given' do
-      connection.stub(:execute).
-        with("SELECT * FROM posts WHERE ? = ?", :blog_id, 1).
-        and_return result_stub(
-          {:id => 1, :title => 'Cequel'},
-          {:id => 2, :title => 'Cequel 2'},
-          {:id => 3, :title => 'Cequel 3'}
-        )
-
-      Post.where(:blog_id => 1).select { |post| post.id < 3 }.
-        map { |post| post.title }.should == ['Cequel', 'Cequel 2']
-    end
-  end
-
-  describe '#select!' do
-    it 'should override previous columns in data set' do
-      connection.stub(:execute).with("SELECT ? FROM posts", [:id, :published]).
-        and_return result_stub(:id => 1, :published => true)
-
-      Post.select(:id, :title).select!(:id, :published).
-        map { |post| post.published }.should == [true]
-    end
-  end
-
-  describe '#consistency' do
-    it 'should scope consistency in data set' do
-      connection.stub(:execute).with("SELECT * FROM posts USING CONSISTENCY QUORUM").
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.consistency(:quorum).map { |post| post.title }.should == ['Cequel']
-    end
-  end
-
-  describe '#where' do
-    it 'should scope to row specifications in data set' do
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ?", :id, 1).
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.where(:id => 1).map { |post| post.title }.should == ['Cequel']
-    end
-
-    it 'should perform multiple queries if IN query performed on non-key column' do
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ?", :title, 'Cequel').
-        and_return result_stub(:id => 1, :title => 'Cequel')
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ?", :title, 'Fun').
-        and_return result_stub(
-          {:id => 2, :title => 'Fun'},
-          {:id => 3, :title => 'Fun'}
-        )
-      Post.where(:title => %w(Cequel Fun)).map(&:id).
-        should == [1, 2, 3]
-    end
-
-    it 'should fail fast if attempting to select only key column with restrictions on key column' do
-      expect { Post.select(:id).where(:id => 1) }.
-        to raise_error(Cequel::Model::InvalidQuery)
-    end
-
-    it 'should fail fast if attempting to mix key and non-key columns' do
-      expect { Post.where(:id => 1).where(:title => 'Cequel') }.
-        to raise_error(Cequel::Model::InvalidQuery)
-    end
-
-    it 'should use index preference if given' do
-      connection.should_receive(:execute).
-        with("SELECT * FROM assets WHERE ? = ? AND ? = ?", :checksum, 'abcdef', :class_name, 'Photo').
-        and_return result_stub
-      Photo.where(:checksum => 'abcdef').to_a
-    end
-  end
-
-  describe '#where!' do
-    it 'should override previously chained row specifications' do
-      connection.stub(:execute).with("SELECT * FROM posts WHERE ? = ?", :title, 'Cequel').
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.where(:id => 1).where!(:title => 'Cequel').
-        map { |post| post.title }.should == ['Cequel']
-    end
-  end
-
-  describe '#limit' do
-    it 'should limit results in data set' do
-      connection.stub(:execute).with("SELECT * FROM posts LIMIT 5").
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.limit(5).map { |post| post.title }.should == ['Cequel']
-    end
-  end
-
-  describe 'chaining' do
-    it 'should aggregate scopes' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts USING CONSISTENCY QUORUM WHERE ? = ? LIMIT 5", [:id, :title], :blog_id, 1).
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.select(:id, :title).
-        consistency(:quorum).
-        where(:blog_id => 1).
-        limit(5).
-        map { |post| post.title }.should == ['Cequel']
-    end
-
-    it 'should delegate unknown methods to the underlying class with self as current scope' do
-      connection.stub(:execute).
-        with("SELECT ? FROM posts USING CONSISTENCY QUORUM WHERE ? = ? LIMIT 5", [:id, :title], :blog_id, 1).
-        and_return result_stub(:id => 1, :title => 'Cequel')
-
-      Post.select(:id, :title).
-        consistency(:quorum).
-        for_blog(1).
-        limit(5).
-        map { |post| post.title }.should == ['Cequel']
-    end
-
-  end
-
-  describe '#update_all' do
-    context 'with no scope restrictions' do
-      let(:scope) { Post }
-
-      it 'should get all keys and then update htem' do
-        connection.should_receive(:execute).
-          with("SELECT ? FROM posts", [:id]).
-          and_return result_stub(
-            {:id => 1},
-            {:id => 2}
-          )
-        connection.should_receive(:execute).
-          with "UPDATE posts SET ? = ? WHERE ? IN (?)", :title, 'Cequel', :id, [1, 2]
-        scope.update_all(:title => 'Cequel')
-      end
-    end
-
-    context 'with scope selecting on ids' do
-      let(:scope) { Post.where(:id => [1, 2]) }
-
-      it 'should issue scoped update request' do
-        connection.should_receive(:execute).
-          with "UPDATE posts SET ? = ? WHERE ? IN (?)", :title, 'Cequel', :id, [1, 2]
-        scope.update_all(:title => 'Cequel')
-      end
-
-    end
-
-    context 'with scope selecting on non-IDs' do
-      let(:scope) { Post.where(:published => false) }
-
-      it 'should perform "subquery" and issue update' do
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ?", [:id], :published, false).
-          and_return result_stub({:id => 1}, {:id => 2})
-
-        connection.should_receive(:execute).
-          with "UPDATE posts SET ? = ? WHERE ? IN (?)", :title, 'Cequel', :id, [1, 2]
-
-        scope.update_all(:title => 'Cequel')
-      end
-    end
-
-    context 'with scope selecting multiple values on non-key column' do
-      let(:scope) { Post.where(:title => %w(Cequel Cassandra)) }
-
-      it 'should perform multiple subqueries and execute single update on returned keys' do
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ?", [:id], :title, 'Cequel').
-          and_return result_stub({:id => 1}, {:id => 2})
-
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ?", [:id], :title, 'Cassandra').
-          and_return result_stub({:id => 3}, {:id => 4})
-
-        connection.should_receive(:execute).
-          with "UPDATE posts SET ? = ? WHERE ? IN (?)", :published, true, :id, [1, 2, 3, 4]
-
-        scope.update_all(:published => true)
-      end
-    end
-  end
-
-  describe '#destroy_all' do
-    context 'with no scope restrictions' do
-      let(:scope) { Post }
-
-      it 'should destroy all instances' do
-        connection.should_receive(:execute).
-          with('SELECT * FROM posts').
-          and_return result_stub(
-            {'id' => 1, 'title' => 'Cequel'},
-            {'id' => 2, 'title' => 'Cassandra'}
-          )
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? = ?", :id, 1
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? = ?", :id, 2
-        scope.destroy_all
-      end
-    end
-
-    context 'with column restrictions' do
-      let(:scope) { Post.where(:id => [1, 2]) }
-
-      it 'should issue scoped update request' do
-        connection.should_receive(:execute).
-          with("SELECT * FROM posts WHERE ? IN (?)", :id, [1, 2]).
-          and_return result_stub(
-            {'id' => 1, 'title' => 'Cequel'},
-            {'id' => 2, 'title' => 'Cassandra'}
-          )
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? = ?", :id, 1
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? = ?", :id, 2
-        scope.destroy_all
-      end
-
-    end
-  end
-
-  describe '#delete_all' do
-    context 'with no scope restrictions' do
-      let(:scope) { Post }
-
-      it 'should truncate keyspace' do
-        connection.should_receive(:execute).
-          with "TRUNCATE posts"
-        Post.delete_all
-      end
-    end
-
-    context 'with scope selecting on ids' do
-      let(:scope) { Post.where(:id => [1, 2]) }
-
-      it 'should issue scoped delete request' do
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? IN (?)", :id, [1, 2]
-        scope.delete_all
-      end
-
-    end
-
-    context 'with scope selecting on non-IDs' do
-      let(:scope) { Post.where(:published => false) }
-
-      it 'should perform "subquery" and issue update' do
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ?", [:id], :published, false).
-          and_return result_stub({:id => 1}, {:id => 2})
-
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? IN (?)", :id, [1, 2]
-
-        scope.delete_all
-      end
-    end
-
-    context 'with scope selecting multiple values on non-key column' do
-      let(:scope) { Post.where(:title => %w(Cequel Cassandra)) }
-
-      it 'should perform multiple subqueries and execute single update on returned keys' do
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ?", [:id], :title, 'Cequel').
-          and_return result_stub({:id => 1}, {:id => 2})
-
-        connection.stub(:execute).
-          with("SELECT ? FROM posts WHERE ? = ?", [:id], :title, 'Cassandra').
-          and_return result_stub({:id => 3}, {:id => 4})
-
-        connection.should_receive(:execute).
-          with "DELETE FROM posts WHERE ? IN (?)", :id, [1, 2, 3, 4]
-
-        scope.delete_all
-      end
-    end
-  end
-
-  describe '::default_scope' do
-    it 'should include in scope by default' do
-      connection.should_receive(:execute).
-        with("SELECT * FROM blogs LIMIT 100").and_return result_stub
-
-      Blog.all.to_a
-    end
-
-    it 'should override as with normal scope' do
-      connection.should_receive(:execute).
-        with("SELECT * FROM blogs LIMIT 1000").and_return result_stub
-
-      Blog.limit(1000).to_a
-    end
-  end
-
-end