cequel 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72e24f9cd8e2717c595a60f3826bf274f50241cb
-  data.tar.gz: e1a9ea1d681b534945d96ab4f0d87af7b7a08ef0
+  metadata.gz: 972c48841d081a702bd2bb4dd97cc94a7da02f42
+  data.tar.gz: 0d75dca1e13d7bb1856e4f0ea6d7af3795a95959
 SHA512:
-  metadata.gz: 59a1423af086bf7f369f10efa5f37f0fb5c5c0d5c5235d1dfa7aeca84f60ae41712b89da735d5e59b3bdef4f200c8ea1658ba26b4d939dcd399370b4e7004f02
-  data.tar.gz: 8e5cf589b91e25dd6533c06241b862723a81b6a738d6f1df31d4a7fc0d71a9693ef995b08c1d5c27eb80c3b7d6b7c51398f59345286a6a03fb94ccc1140c9d3e
+  metadata.gz: c58f9ec3bb7cf8c308d38eb091d18535b5051c8301d7b84e33beb8e03abfc01f8ca8ea4711b894980fe6df760055e10b8fba78a9639fa0bdb7dba018cb31624a
+  data.tar.gz: e4b13cb2ee0ed6b1971fefbaa5609107289722bd788c0ae4088e663fe37b56d40d094673941ce49b82afdb2b3e40990a48749dba93640cdc3da81a3b71d4082e

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.4.3
+
+* Make Rake tasks work without Rails
+* `RecordSet#reverse` and `find_in_batches` respect clustering order defined in
+  schema
+
 ## 1.4.2
 
 * Allow setting a key attribute to what it already is

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cequel (1.4.2)
+    cequel (1.4.3)
       activemodel (>= 3.1, < 5.0)
       cql-rb (>= 1.2, < 3.0)
 
@@ -44,7 +44,7 @@ GEM
     json (1.8.1)
     json (1.8.1-java)
     method_source (0.8.2)
-    minitest (5.4.1)
+    minitest (5.4.2)
     parser (2.1.9)
       ast (>= 1.1, < 3.0)
       slop (~> 3.4, >= 3.4.5)
@@ -62,14 +62,21 @@ GEM
     racc (1.4.12)
     rainbow (2.0.0)
     rake (10.3.2)
-    rspec (2.99.0)
-      rspec-core (~> 2.99.0)
-      rspec-expectations (~> 2.99.0)
-      rspec-mocks (~> 2.99.0)
-    rspec-core (2.99.2)
-    rspec-expectations (2.99.2)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.99.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.5)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-its (1.0.1)
+      rspec-core (>= 2.99.0.beta1)
+      rspec-expectations (>= 2.99.0.beta1)
+    rspec-mocks (3.1.2)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.1)
     rubocop (0.19.1)
       json (>= 1.7.7, < 2)
       parser (~> 2.1.7)
@@ -284,7 +291,6 @@ GEM
       ffi
     thor (0.19.1)
     thread_safe (0.3.4)
-    thread_safe (0.3.4-java)
     timecop (0.7.1)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
@@ -304,7 +310,8 @@ DEPENDENCIES
   psych (~> 2.0)
   racc (~> 1.4)
   rake (~> 10.1)
-  rspec (~> 2.0)
+  rspec (~> 3.1)
+  rspec-its (~> 1.0)
   rubocop (~> 0.19.0)
   rubysl (~> 2.0)
   timecop (~> 0.7)

data/Rakefile

@@ -11,7 +11,7 @@ task :default => :release
 task :release => [
   :verify_changelog,
   :rubocop,
-  :wwtd,
+  :"test:all",
   :build,
   :tag,
   :update_stable,
@@ -67,6 +67,10 @@ namespace :test do
     t.rspec_opts = '--fail-fast --format=progress'
     t.fail_on_error = true
   end
+
+  task :all do
+    system('bundle', 'exec', 'wwtd', '--parallel')
+  end
 end
 
 desc 'Update changelog'

data/lib/cequel/record/data_set_builder.rb

@@ -51,7 +51,7 @@ module Cequel
                      :scoped_key_names, :scoped_key_values,
                      :scoped_indexed_column, :lower_bound,
                      :upper_bound, :reversed?, :order_by_column,
-                     :query_consistency
+                     :query_consistency, :ascends_by?
 
       private
 
@@ -85,7 +85,10 @@ module Cequel
       end
 
       def add_order
-        self.data_set = data_set.order(order_by_column => :desc) if reversed?
+        column = order_by_column
+        if column.present? && reversed?
+          self.data_set = data_set.order(column.name => sort_direction)
+        end
       end
 
       def set_consistency
@@ -93,6 +96,10 @@ module Cequel
           self.data_set = data_set.consistency(query_consistency)
         end
       end
+
+      def sort_direction
+        ascends_by?(order_by_column) ? :asc : :desc
+      end
     end
   end
 end

data/lib/cequel/record/record_set.rb

@@ -656,7 +656,21 @@ module Cequel
       protected :reversed?
 
       def next_batch_from(row)
-        reversed? ? before(row[range_key_name]) : after(row[range_key_name])
+        range_key_value = row[range_key_name]
+        if ascends_by?(range_key_column)
+          after(range_key_value)
+        else
+          before(range_key_value)
+        end
+      end
+
+      def ascends_by?(column)
+        !descends_by?(column)
+      end
+
+      def descends_by?(column)
+        column.clustering_column? &&
+          (reversed? ^ (column.clustering_order == :desc))
       end
 
       def find_nested_batches_from(row, options, &block)
@@ -837,7 +851,7 @@ module Cequel
 
       def order_by_column
         if target_class.clustering_columns.any?
-          target_class.clustering_columns.first.name
+          target_class.clustering_columns.first
         end
       end
 

data/lib/cequel/record/tasks.rb

@@ -1,4 +1,7 @@
 # -*- encoding : utf-8 -*-
+task :environment do
+end
+
 namespace :cequel do
   namespace :keyspace do
     desc 'Initialize Cassandra keyspace'
@@ -20,8 +23,9 @@ namespace :cequel do
     watch_stack = ActiveSupport::Dependencies::WatchStack.new
 
     migration_table_names = Set[]
-    models_dir_path = "#{Rails.root.join('app', 'models')}/"
-    model_files = Dir.glob(Rails.root.join('app', 'models', '**', '*.rb'))
+    project_root = defined?(Rails) ? Rails.root : Dir.pwd
+    models_dir_path = "#{File.expand_path('app/models', project_root)}/"
+    model_files = Dir.glob(File.join(models_dir_path, '**', '*.rb'))
     model_files.sort.each do |file|
       watch_namespaces = ["Object"]
       model_file_name = file.sub(/^#{Regexp.escape(models_dir_path)}/, "")

data/lib/cequel/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 module Cequel
   # The current version of the library
-  VERSION = '1.4.2'
+  VERSION = '1.4.3'
 end

data/spec/examples/metal/data_set_spec.rb

@@ -49,39 +49,39 @@ describe Cequel::Metal::DataSet do
 
     it 'should insert a row' do
       cequel[:posts].insert(row)
-      cequel[:posts].where(row_keys).first[:title].should == 'Fun times'
+      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Fun times')
     end
 
     it 'should correctly insert a list' do
       cequel[:posts].insert(row)
-      cequel[:posts].where(row_keys).first[:categories].
-        should == ['Fun', 'Profit']
+      expect(cequel[:posts].where(row_keys).first[:categories]).
+        to eq(['Fun', 'Profit'])
     end
 
     it 'should correctly insert a set' do
       cequel[:posts].insert(row)
-      cequel[:posts].where(row_keys).first[:tags].
-        should == Set['cassandra', 'big-data']
+      expect(cequel[:posts].where(row_keys).first[:tags]).
+        to eq(Set['cassandra', 'big-data'])
     end
 
     it 'should correctly insert a map' do
       cequel[:posts].insert(row)
-      cequel[:posts].where(row_keys).first[:trackbacks].
-        should == row[:trackbacks]
+      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+        to eq(row[:trackbacks])
     end
 
     it 'should include ttl argument' do
       cequel[:posts].insert(row, :ttl => 10.minutes)
-      cequel[:posts].select_ttl(:title).where(row_keys).first.ttl(:title).
-        should be_within(5).of(10.minutes)
+      expect(cequel[:posts].select_ttl(:title).where(row_keys).first.ttl(:title)).
+        to be_within(5).of(10.minutes)
     end
 
     it 'should include timestamp argument' do
       cequel.schema.truncate_table(:posts)
       time = 1.day.ago
       cequel[:posts].insert(row, :timestamp => time)
-      cequel[:posts].select_writetime(:title).where(row_keys).
-        first.writetime(:title).should == (time.to_f * 1_000_000).to_i
+      expect(cequel[:posts].select_writetime(:title).where(row_keys).
+        first.writetime(:title)).to eq((time.to_f * 1_000_000).to_i)
     end
 
     it 'should insert row with given consistency' do
@@ -96,8 +96,8 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].insert(row, :ttl => 600, :timestamp => time)
       result = cequel[:posts].select_ttl(:title).select_writetime(:title).
         where(row_keys).first
-      result.writetime(:title).should == (time.to_f * 1_000_000).to_i
-      result.ttl(:title).should be_within(5).of(10.minutes)
+      expect(result.writetime(:title)).to eq((time.to_f * 1_000_000).to_i)
+      expect(result.ttl(:title)).to be_within(5).of(10.minutes)
     end
   end
 
@@ -105,8 +105,8 @@ describe Cequel::Metal::DataSet do
     it 'should send basic update statement' do
       cequel[:posts].where(row_keys).
         update(:title => 'Fun times', :body => 'Fun')
-      cequel[:posts].where(row_keys).
-        first[:title].should == 'Fun times'
+      expect(cequel[:posts].where(row_keys).
+        first[:title]).to eq('Fun times')
     end
 
     it 'should send update statement with options' do
@@ -120,8 +120,8 @@ describe Cequel::Metal::DataSet do
         select_ttl(:title).select_writetime(:title).
         where(row_keys).first
 
-      row.ttl(:title).should be_within(5).of(10.minutes)
-      row.writetime(:title).should == (time.to_f * 1_000_000).to_i
+      expect(row.ttl(:title)).to be_within(5).of(10.minutes)
+      expect(row.writetime(:title)).to eq((time.to_f * 1_000_000).to_i)
     end
 
     it 'should send update statement with given consistency' do
@@ -134,14 +134,14 @@ describe Cequel::Metal::DataSet do
     it 'should overwrite list column' do
       cequel[:posts].where(row_keys).
         update(categories: ['Big Data', 'Cassandra'])
-      cequel[:posts].where(row_keys).first[:categories].
-        should == ['Big Data', 'Cassandra']
+      expect(cequel[:posts].where(row_keys).first[:categories]).
+        to eq(['Big Data', 'Cassandra'])
     end
 
     it 'should overwrite set column' do
       cequel[:posts].where(row_keys).update(tags: Set['big-data', 'nosql'])
-      cequel[:posts].where(row_keys).first[:tags].
-        should == Set['big-data', 'nosql']
+      expect(cequel[:posts].where(row_keys).first[:tags]).
+        to eq(Set['big-data', 'nosql'])
     end
 
     it 'should overwrite map column' do
@@ -149,8 +149,8 @@ describe Cequel::Metal::DataSet do
       time2 = Time.at(10.minutes.ago.to_i)
       cequel[:posts].where(row_keys).update(
         trackbacks: {time1 => 'foo', time2 => 'bar'})
-      cequel[:posts].where(row_keys).first[:trackbacks].
-        should == {time1 => 'foo', time2 => 'bar'}
+      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+        to eq({time1 => 'foo', time2 => 'bar'})
     end
 
     it 'should perform various types of update in one go' do
@@ -162,9 +162,9 @@ describe Cequel::Metal::DataSet do
         set(title: 'Bigger Data')
         list_append(:categories, 'Fault-Tolerance')
       end
-      cequel[:posts].where(row_keys).first[:title].should == 'Bigger Data'
-      cequel[:posts].where(row_keys).first[:categories].
-        should == %w(Scalability Fault-Tolerance)
+      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Bigger Data')
+      expect(cequel[:posts].where(row_keys).first[:categories]).
+        to eq(%w(Scalability Fault-Tolerance))
     end
 
     it 'should use the last value set for a given column' do
@@ -176,7 +176,7 @@ describe Cequel::Metal::DataSet do
         set(title: 'Bigger Data')
         set(title: 'Even Bigger Data')
       end
-      cequel[:posts].where(row_keys).first[:title].should == 'Even Bigger Data'
+      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Even Bigger Data')
     end
   end
 
@@ -186,8 +186,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
       cequel[:posts].where(row_keys).
         list_prepend(:categories, 'Scalability')
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Scalability', 'Big Data', 'Cassandra']
+      )
     end
 
     it 'should prepend multiple elements to list column' do
@@ -195,8 +196,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
       cequel[:posts].where(row_keys).
         list_prepend(:categories, ['Scalability', 'Partition Tolerance'])
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Partition Tolerance', 'Scalability', 'Big Data', 'Cassandra']
+      )
     end
   end
 
@@ -206,8 +208,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
       cequel[:posts].where(row_keys).
         list_append(:categories, 'Scalability')
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'Cassandra', 'Scalability']
+      )
     end
 
     it 'should append multiple elements to list column' do
@@ -215,8 +218,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
       cequel[:posts].where(row_keys).
         list_append(:categories, ['Scalability', 'Partition Tolerance'])
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'Cassandra', 'Scalability', 'Partition Tolerance']
+      )
     end
   end
 
@@ -226,8 +230,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra', 'Scalability']))
       cequel[:posts].where(row_keys).
         list_replace(:categories, 1, 'C*')
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'C*', 'Scalability']
+      )
     end
   end
 
@@ -237,8 +242,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra', 'Scalability']))
       cequel[:posts].where(row_keys).
         list_remove(:categories, 'Cassandra')
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'Scalability']
+      )
     end
 
     it 'should remove from list by multiple values' do
@@ -246,8 +252,9 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(categories: ['Big Data', 'Cassandra', 'Scalability']))
       cequel[:posts].where(row_keys).
         list_remove(:categories, ['Big Data', 'Cassandra'])
-      cequel[:posts].where(row_keys).first[:categories].should ==
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
         ['Scalability']
+      )
     end
   end
 
@@ -256,16 +263,16 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].insert(
         row_keys.merge(tags: Set['big-data', 'nosql']))
       cequel[:posts].where(row_keys).set_add(:tags, 'cassandra')
-      cequel[:posts].where(row_keys).first[:tags].
-        should == Set['big-data', 'nosql', 'cassandra']
+      expect(cequel[:posts].where(row_keys).first[:tags]).
+        to eq(Set['big-data', 'nosql', 'cassandra'])
     end
 
     it 'should add multiple elements to set' do
       cequel[:posts].insert(
         row_keys.merge(tags: Set['big-data', 'nosql']))
       cequel[:posts].where(row_keys).set_add(:tags, 'cassandra')
-      cequel[:posts].where(row_keys).first[:tags].
-        should == Set['big-data', 'nosql', 'cassandra']
+      expect(cequel[:posts].where(row_keys).first[:tags]).
+        to eq(Set['big-data', 'nosql', 'cassandra'])
     end
   end
 
@@ -274,8 +281,8 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].insert(
         row_keys.merge(tags: Set['big-data', 'nosql', 'cassandra']))
       cequel[:posts].where(row_keys).set_remove(:tags, 'cassandra')
-      cequel[:posts].where(row_keys).first[:tags].
-        should == Set['big-data', 'nosql']
+      expect(cequel[:posts].where(row_keys).first[:tags]).
+        to eq(Set['big-data', 'nosql'])
     end
 
     it 'should remove multiple elements from set' do
@@ -283,8 +290,8 @@ describe Cequel::Metal::DataSet do
         row_keys.merge(tags: Set['big-data', 'nosql', 'cassandra']))
       cequel[:posts].where(row_keys).
         set_remove(:tags, Set['nosql', 'cassandra'])
-      cequel[:posts].where(row_keys).first[:tags].
-        should == Set['big-data']
+      expect(cequel[:posts].where(row_keys).first[:tags]).
+        to eq(Set['big-data'])
     end
   end
 
@@ -296,8 +303,8 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar'}))
       cequel[:posts].where(row_keys).map_update(:trackbacks, time3 => 'baz')
-      cequel[:posts].where(row_keys).first[:trackbacks].
-        should == {time1 => 'foo', time2 => 'bar', time3 => 'baz'}
+      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+        to eq({time1 => 'foo', time2 => 'bar', time3 => 'baz'})
     end
 
     it 'should update specified map key with multiple values' do
@@ -308,8 +315,8 @@ describe Cequel::Metal::DataSet do
         trackbacks: {time1 => 'foo', time2 => 'bar'}))
       cequel[:posts].where(row_keys).
         map_update(:trackbacks, time1 => 'FOO', time3 => 'baz')
-      cequel[:posts].where(row_keys).first[:trackbacks].
-        should == {time1 => 'FOO', time2 => 'bar', time3 => 'baz'}
+      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+        to eq({time1 => 'FOO', time2 => 'bar', time3 => 'baz'})
     end
   end
 
@@ -323,8 +330,8 @@ describe Cequel::Metal::DataSet do
 
       row = cequel[:post_activity].where(row_keys).first
 
-      row[:visits].should == 1
-      row[:tweets].should == 2
+      expect(row[:visits]).to eq(1)
+      expect(row[:tweets]).to eq(2)
     end
   end
 
@@ -336,8 +343,8 @@ describe Cequel::Metal::DataSet do
         decrement(visits: 1, tweets: 2)
 
       row = cequel[:post_activity].where(row_keys).first
-      row[:visits].should == -1
-      row[:tweets].should == -2
+      expect(row[:visits]).to eq(-1)
+      expect(row[:tweets]).to eq(-2)
     end
   end
 
@@ -349,14 +356,14 @@ describe Cequel::Metal::DataSet do
 
     it 'should send basic delete statement' do
       cequel[:posts].where(row_keys).delete
-      cequel[:posts].where(row_keys).first.should be_nil
+      expect(cequel[:posts].where(row_keys).first).to be_nil
     end
 
     it 'should send delete statement for specified columns' do
       cequel[:posts].where(row_keys).delete(:body)
       row = cequel[:posts].where(row_keys).first
-      row[:body].should be_nil
-      row[:title].should == 'Big Data'
+      expect(row[:body]).to be_nil
+      expect(row[:title]).to eq('Big Data')
     end
 
     it 'should send delete statement with writetime option' do
@@ -366,7 +373,7 @@ describe Cequel::Metal::DataSet do
         :body, :timestamp => time
       )
       row = cequel[:posts].select(:body).where(row_keys).first
-      row[:body].should == 'It\'s big.'
+      expect(row[:body]).to eq('It\'s big.')
       # This means timestamp is working, since the earlier timestamp would cause
       # Cassandra to ignore the deletion
     end
@@ -383,16 +390,16 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].
         insert(row_keys.merge(categories: ['Big Data', 'NoSQL', 'Cassandra']))
       cequel[:posts].where(row_keys).list_remove_at(:categories, 1)
-      cequel[:posts].where(row_keys).first[:categories].
-        should == ['Big Data', 'Cassandra']
+      expect(cequel[:posts].where(row_keys).first[:categories]).
+        to eq(['Big Data', 'Cassandra'])
     end
 
     it 'should remove element at specified positions from list' do
       cequel[:posts].
         insert(row_keys.merge(categories: ['Big Data', 'NoSQL', 'Cassandra']))
       cequel[:posts].where(row_keys).list_remove_at(:categories, 0, 2)
-      cequel[:posts].where(row_keys).first[:categories].
-        should == ['NoSQL']
+      expect(cequel[:posts].where(row_keys).first[:categories]).
+        to eq(['NoSQL'])
     end
   end
 
@@ -404,8 +411,8 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar', time3 => 'baz'}))
       cequel[:posts].where(row_keys).map_remove(:trackbacks, time2)
-      cequel[:posts].where(row_keys).first[:trackbacks].
-        should == {time1 => 'foo', time3 => 'baz'}
+      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+        to eq({time1 => 'foo', time3 => 'baz'})
     end
 
     it 'should remove multiple elements from a map' do
@@ -415,14 +422,14 @@ describe Cequel::Metal::DataSet do
       cequel[:posts].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar', time3 => 'baz'}))
       cequel[:posts].where(row_keys).map_remove(:trackbacks, time1, time3)
-      cequel[:posts].where(row_keys).first[:trackbacks].
-        should == {time2 => 'bar'}
+      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+        to eq({time2 => 'bar'})
     end
   end
 
   describe '#cql' do
     it 'should generate select statement with all columns' do
-      cequel[:posts].cql.should == ['SELECT * FROM posts']
+      expect(cequel[:posts].cql).to eq(['SELECT * FROM posts'])
     end
   end
 
@@ -436,18 +443,18 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should generate select statement with given columns' do
-      cequel[:posts].select(:title, :body).where(row_keys).first.
-        keys.should == %w(title body)
+      expect(cequel[:posts].select(:title, :body).where(row_keys).first.
+        keys).to eq(%w(title body))
     end
 
     it 'should accept array argument' do
-      cequel[:posts].select([:title, :body]).where(row_keys).first.
-        keys.should == %w(title body)
+      expect(cequel[:posts].select([:title, :body]).where(row_keys).first.
+        keys).to eq(%w(title body))
     end
 
     it 'should combine multiple selects' do
-      cequel[:posts].select(:title).select(:body).where(row_keys).first.
-        keys.should == %w(title body)
+      expect(cequel[:posts].select(:title).select(:body).where(row_keys).first.
+        keys).to eq(%w(title body))
     end
   end
 
@@ -461,8 +468,8 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should override select statement with given columns' do
-      cequel[:posts].select(:title, :body).select!(:published_at).
-        where(row_keys).first.keys.should == %w(published_at)
+      expect(cequel[:posts].select(:title, :body).select!(:published_at).
+        where(row_keys).first.keys).to eq(%w(published_at))
     end
   end
 
@@ -476,15 +483,15 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should build WHERE statement from hash' do
-      cequel[:posts].where(blog_subdomain: row_keys[:blog_subdomain]).
-        first[:title].should == 'Big Data'
-      cequel[:posts].where(blog_subdomain: 'foo').first.should be_nil
+      expect(cequel[:posts].where(blog_subdomain: row_keys[:blog_subdomain]).
+        first[:title]).to eq('Big Data')
+      expect(cequel[:posts].where(blog_subdomain: 'foo').first).to be_nil
     end
 
     it 'should build WHERE statement from multi-element hash' do
-      cequel[:posts].where(row_keys).first[:title].should == 'Big Data'
-      cequel[:posts].where(row_keys.merge(:permalink => 'foo')).
-        first.should be_nil
+      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Big Data')
+      expect(cequel[:posts].where(row_keys.merge(:permalink => 'foo')).
+        first).to be_nil
     end
 
     it 'should build WHERE statement with IN' do
@@ -496,32 +503,32 @@ describe Cequel::Metal::DataSet do
         blog_subdomain: 'bogus-blog',
         title: 'Bogus Post',
       ))
-      cequel[:posts].where(
+      expect(cequel[:posts].where(
         :blog_subdomain => %w(cassandra big-data-weekly),
         :permalink => 'big-data'
-      ).map { |row| row[:title] }.should == ['Big Data', 'Cassandra']
+      ).map { |row| row[:title] }).to eq(['Big Data', 'Cassandra'])
     end
 
     it 'should use = if provided one-element array' do
-      cequel[:posts].
+      expect(cequel[:posts].
         where(row_keys.merge(blog_subdomain: [row_keys[:blog_subdomain]])).
-        first[:title].should == 'Big Data'
+        first[:title]).to eq('Big Data')
     end
 
     it 'should build WHERE statement from CQL string' do
-      cequel[:posts].where("blog_subdomain = '#{row_keys[:blog_subdomain]}'").
-        first[:title].should == 'Big Data'
+      expect(cequel[:posts].where("blog_subdomain = '#{row_keys[:blog_subdomain]}'").
+        first[:title]).to eq('Big Data')
     end
 
     it 'should build WHERE statement from CQL string with bind variables' do
-      cequel[:posts].where("blog_subdomain = ?", row_keys[:blog_subdomain]).
-        first[:title].should == 'Big Data'
+      expect(cequel[:posts].where("blog_subdomain = ?", row_keys[:blog_subdomain]).
+        first[:title]).to eq('Big Data')
     end
 
     it 'should aggregate multiple WHERE statements' do
-      cequel[:posts].where(:blog_subdomain => row_keys[:blog_subdomain]).
+      expect(cequel[:posts].where(:blog_subdomain => row_keys[:blog_subdomain]).
         where('permalink = ?', row_keys[:permalink]).
-        first[:title].should == 'Big Data'
+        first[:title]).to eq('Big Data')
     end
 
   end
@@ -536,9 +543,9 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should override chained conditions' do
-      cequel[:posts].where(:permalink => 'bogus').
+      expect(cequel[:posts].where(:permalink => 'bogus').
         where!(:blog_subdomain => row_keys[:blog_subdomain]).
-        first[:title].should == 'Big Data'
+        first[:title]).to eq('Big Data')
     end
   end
 
@@ -552,8 +559,8 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should add LIMIT' do
-      cequel[:posts].where(row_keys.slice(:blog_subdomain)).limit(2).
-        map { |row| row[:title] }.should == ['Big Data', 'Marshmallows']
+      expect(cequel[:posts].where(row_keys.slice(:blog_subdomain)).limit(2).
+        map { |row| row[:title] }).to eq(['Big Data', 'Marshmallows'])
     end
   end
 
@@ -567,9 +574,9 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should add order' do
-      cequel[:posts].where(row_keys.slice(:blog_subdomain)).
-        order(permalink: 'desc').map { |row| row[:title] }.
-        should == ['ZZ Top', 'Marshmallows', 'Big Data']
+      expect(cequel[:posts].where(row_keys.slice(:blog_subdomain)).
+        order(permalink: 'desc').map { |row| row[:title] }).
+        to eq(['ZZ Top', 'Marshmallows', 'Big Data'])
     end
   end
 
@@ -655,13 +662,13 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should enumerate over results' do
-      cequel[:posts].to_a.map { |row| row.select { |k, v| v }}.
-        should == [row.stringify_keys]
+      expect(cequel[:posts].to_a.map { |row| row.select { |k, v| v }}).
+        to eq([row.stringify_keys])
     end
 
     it 'should provide results with indifferent access' do
-      cequel[:posts].to_a.first[:blog_permalink].
-        should == row_keys[:blog_permalink]
+      expect(cequel[:posts].to_a.first[:blog_permalink]).
+        to eq(row_keys[:blog_permalink])
     end
 
     it 'should not run query if no block given to #each' do
@@ -669,9 +676,9 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should return Enumerator if no block given to #each' do
-      cequel[:posts].each.each_with_index.
-        map { |row, i| [row[:blog_permalink], i] }.
-        should == [[row[:blog_permalink], 0]]
+      expect(cequel[:posts].each.each_with_index.
+        map { |row, i| [row[:blog_permalink], i] }).
+        to eq([[row[:blog_permalink], 0]])
     end
   end
 
@@ -685,7 +692,7 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should run a query with LIMIT 1 and return first row' do
-      cequel[:posts].first.select { |k, v| v }.should == row.stringify_keys
+      expect(cequel[:posts].first.select { |k, v| v }).to eq(row.stringify_keys)
     end
   end
 
@@ -698,16 +705,16 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should run a count query and return count' do
-      cequel[:posts].count.should == 4
+      expect(cequel[:posts].count).to eq(4)
     end
 
     it 'should use where clause if specified' do
-      cequel[:posts].where(row_keys.merge(permalink: 'post-1')).
-        count.should == 1
+      expect(cequel[:posts].where(row_keys.merge(permalink: 'post-1')).
+        count).to eq(1)
     end
 
     it 'should use limit if specified' do
-      cequel[:posts].limit(2).count.should == 2
+      expect(cequel[:posts].limit(2).count).to eq(2)
     end
   end