cequel 1.4.2 → 1.4.3

data/spec/examples/record/schema_spec.rb

@@ -31,7 +31,7 @@ describe Cequel::Record::Schema do
       its(:data_columns) { should include(Cequel::Schema::List.new(:categories, :text)) }
       its(:data_columns) { should include(Cequel::Schema::Set.new(:tags, :text)) }
       its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
-      specify { subject.property(:comment).should == 'Blog Posts' }
+      specify { expect(subject.property(:comment)).to eq('Blog Posts') }
     end
 
     context 'existing model with additional attribute' do
@@ -69,7 +69,7 @@ describe Cequel::Record::Schema do
     subject { cequel.schema.read_table(table_name) }
 
     it 'should order clustering column descending' do
-      subject.clustering_columns.first.clustering_order.should == :desc
+      expect(subject.clustering_columns.first.clustering_order).to eq(:desc)
     end
   end
 
@@ -97,7 +97,7 @@ describe Cequel::Record::Schema do
 
       its(:partition_key_columns) { should == [Cequel::Schema::Column.new(:blog_subdomain, :text)] }
       its(:clustering_columns) { should == [Cequel::Schema::Column.new(:id, :uuid)] }
-      it { should be_compact_storage }
+      it { is_expected.to be_compact_storage }
       its(:data_columns) { should == [Cequel::Schema::Column.new(:data, :text)] }
     end
 
@@ -110,10 +110,10 @@ describe Cequel::Record::Schema do
         legacy_model.synchronize_schema
       end
 
-      its(:partition_key_columns) { should == [Cequel::Schema::Column.new(:blog_subdomain, :text)] }
-      its(:clustering_columns) { should == [Cequel::Schema::Column.new(:id, :uuid)] }
-      it { should be_compact_storage }
-      its(:data_columns) { should == [Cequel::Schema::Column.new(:data, :text)] }
+      its(:partition_key_columns) { is_expected.to eq([Cequel::Schema::Column.new(:blog_subdomain, :text)]) }
+      its(:clustering_columns) { is_expected.to eq([Cequel::Schema::Column.new(:id, :uuid)]) }
+      it { is_expected.to be_compact_storage }
+      its(:data_columns) { is_expected.to eq([Cequel::Schema::Column.new(:data, :text)]) }
 
       it 'should be able to synchronize schema again' do
         expect { legacy_model.synchronize_schema }.to_not raise_error

data/spec/examples/record/scoped_spec.rb

@@ -9,13 +9,13 @@ describe Cequel::Record::Scoped do
   end
 
   it 'should use current scoped key values to populate new record' do
-    Post['bigdata'].new.blog_subdomain.should == 'bigdata'
+    expect(Post['bigdata'].new.blog_subdomain).to eq('bigdata')
   end
 
   it "should not mess up class' #puts" do
     StringIO.new.tap do |out|
       out.puts Post
-      out.string.should == "Post\n"
+      expect(out.string).to eq("Post\n")
     end
 
   end

data/spec/examples/record/serialization_spec.rb

@@ -21,7 +21,7 @@ describe 'serialization' do
 
   it 'should provide JSON serialization' do
     Post.include_root_in_json = false
-    Post.new(attributes).as_json.symbolize_keys.
-      should == attributes.merge(body: nil)
+    expect(Post.new(attributes).as_json.symbolize_keys).
+      to eq(attributes.merge(body: nil))
   end
 end

data/spec/examples/record/set_spec.rb

@@ -24,7 +24,7 @@ describe Cequel::Record::Set do
 
   context 'new record' do
     it 'should save set as-is' do
-      subject[:tags].should == Set['one', 'two']
+      expect(subject[:tags]).to eq(Set['one', 'two'])
     end
   end
 
@@ -32,13 +32,13 @@ describe Cequel::Record::Set do
     it 'should overwrite value' do
       post.tags = Set['three', 'four']
       post.save!
-      subject[:tags].should == Set['three', 'four']
+      expect(subject[:tags]).to eq(Set['three', 'four'])
     end
 
     it 'should cast collection before overwriting' do
       post.tags = %w(three four)
       post.save!
-      subject[:tags].should == Set['three', 'four']
+      expect(subject[:tags]).to eq(Set['three', 'four'])
     end
   end
 
@@ -49,7 +49,7 @@ describe Cequel::Record::Set do
       it 'should add atomically' do
         post.tags.add('four')
         post.save
-        subject[:tags].should == Set['one', 'two', 'three', 'four']
+        expect(subject[:tags]).to eq(Set['one', 'two', 'three', 'four'])
         expect(post.tags).to eq(Set['one', 'two', 'four'])
       end
 
@@ -59,10 +59,11 @@ describe Cequel::Record::Set do
       end
 
       it 'should add without reading' do
-        max_statements! 2
-        unloaded_post.tags.add('four')
-        unloaded_post.save
-        subject[:tags].should == Set['one', 'two', 'three', 'four']
+        expect_statement_count 1 do
+          unloaded_post.tags.add('four')
+          unloaded_post.save
+        end
+        expect(subject[:tags]).to eq(Set['one', 'two', 'three', 'four'])
       end
 
       it 'should apply add post-hoc' do
@@ -75,15 +76,16 @@ describe Cequel::Record::Set do
       it 'should clear atomically' do
         post.tags.clear
         post.save
-        subject[:tags].should be_blank
+        expect(subject[:tags]).to be_blank
         expect(post.tags).to eq(Set[])
       end
 
       it 'should clear without reading' do
-        max_statements! 2
-        unloaded_post.tags.clear
-        unloaded_post.save
-        subject[:tags].should be_blank
+        expect_statement_count 1 do
+          unloaded_post.tags.clear
+          unloaded_post.save
+        end
+        expect(subject[:tags]).to be_blank
       end
 
       it 'should apply clear post-hoc' do
@@ -96,7 +98,7 @@ describe Cequel::Record::Set do
       it 'should delete atomically' do
         post.tags.delete('two')
         post.save
-        subject[:tags].should == Set['one', 'three']
+        expect(subject[:tags]).to eq(Set['one', 'three'])
         expect(post.tags).to eq(Set['one'])
       end
 
@@ -106,10 +108,11 @@ describe Cequel::Record::Set do
       end
 
       it 'should delete without reading' do
-        max_statements! 2
-        unloaded_post.tags.delete('two')
-        unloaded_post.save
-        subject[:tags].should == Set['one', 'three']
+        expect_statement_count 1 do
+          unloaded_post.tags.delete('two')
+          unloaded_post.save
+        end
+        expect(subject[:tags]).to eq(Set['one', 'three'])
       end
 
       it 'should apply delete post-hoc' do
@@ -122,7 +125,7 @@ describe Cequel::Record::Set do
       it 'should replace atomically' do
         post.tags.replace(Set['a', 'b'])
         post.save
-        subject[:tags].should == Set['a', 'b']
+        expect(subject[:tags]).to eq(Set['a', 'b'])
         expect(post.tags).to eq(Set['a', 'b'])
       end
 
@@ -132,10 +135,11 @@ describe Cequel::Record::Set do
       end
 
       it 'should replace without reading' do
-        max_statements! 2
-        unloaded_post.tags.replace(Set['a', 'b'])
-        unloaded_post.save
-        subject[:tags].should == Set['a', 'b']
+        expect_statement_count 1 do
+          unloaded_post.tags.replace(Set['a', 'b'])
+          unloaded_post.save
+        end
+        expect(subject[:tags]).to eq(Set['a', 'b'])
       end
 
       it 'should apply delete post-hoc' do

data/spec/examples/record/validations_spec.rb

@@ -29,37 +29,37 @@ describe Cequel::Record::Validations do
 
   describe '#valid?' do
     it 'should be false if model is not valid' do
-      invalid_post.should_not be_valid
+      expect(invalid_post).not_to be_valid
     end
 
     it 'should be true if model is valid' do
-      valid_post.should be_valid
+      expect(valid_post).to be_valid
     end
   end
 
   describe '#invalid?' do
     it 'should be true if model is not valid' do
-      invalid_post.should be_invalid
+      expect(invalid_post).to be_invalid
     end
 
     it 'should be false if model is valid' do
-      valid_post.should_not be_invalid
+      expect(valid_post).not_to be_invalid
     end
   end
 
   describe '#save' do
     it 'should return false and not persist model if invalid' do
-      invalid_post.save.should be_false
+      expect(invalid_post.save).to eq(false)
     end
 
     it 'should return true and persist model if valid' do
-      valid_post.save.should be_true
-      Post.find('valid').title.should == 'Valid Post'
+      expect(valid_post.save).to eq(true)
+      expect(Post.find('valid').title).to eq('Valid Post')
     end
 
     it 'should bypass validations if :validate => false is passed' do
-      invalid_post.save(:validate => false).should be_true
-      Post.find('invalid').body.should == 'This is an invalid post.'
+      expect(invalid_post.save(:validate => false)).to eq(true)
+      expect(Post.find('invalid').body).to eq('This is an invalid post.')
     end
   end
 
@@ -71,7 +71,7 @@ describe Cequel::Record::Validations do
 
     it 'should persist model and return self if valid' do
       expect { valid_post.save! }.to_not raise_error
-      Post.find(valid_post.permalink).title.should == 'Valid Post'
+      expect(Post.find(valid_post.permalink).title).to eq('Valid Post')
     end
   end
 
@@ -83,7 +83,7 @@ describe Cequel::Record::Validations do
 
     it 'should return successfully and update data in the database if valid' do
       invalid_post.update_attributes!(:title => 'My Post')
-      Post.find(invalid_post.permalink).title.should == 'My Post'
+      expect(Post.find(invalid_post.permalink).title).to eq('My Post')
     end
   end
 
@@ -96,7 +96,7 @@ describe Cequel::Record::Validations do
 
     it 'should persist record to database if valid' do
       Post.create!(:permalink => 'cequel', :title => 'Cequel')
-      Post.find('cequel').title.should == 'Cequel'
+      expect(Post.find('cequel').title).to eq('Cequel')
     end
   end
 
@@ -104,7 +104,7 @@ describe Cequel::Record::Validations do
     it 'should call validation callbacks' do
       post = Post.new(:title => 'cequel')
       post.valid?
-      post.called_validate_callback.should be_true
+      expect(post.called_validate_callback).to eq(true)
     end
   end
 end

data/spec/examples/schema/table_reader_spec.rb

@@ -15,15 +15,15 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read name correctly' do
-      table.partition_key_columns.first.name.should == :permalink
+      expect(table.partition_key_columns.first.name).to eq(:permalink)
     end
 
     it 'should read type correctly' do
-      table.partition_key_columns.first.type.should be_a(Cequel::Type::Text)
+      expect(table.partition_key_columns.first.type).to be_a(Cequel::Type::Text)
     end
 
     it 'should have no nonpartition keys' do
-      table.clustering_columns.should be_empty
+      expect(table.clustering_columns).to be_empty
     end
   end # describe 'reading simple key'
 
@@ -39,24 +39,24 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read partition key name' do
-      table.partition_key_columns.map(&:name).should == [:blog_subdomain]
+      expect(table.partition_key_columns.map(&:name)).to eq([:blog_subdomain])
     end
 
     it 'should read partition key type' do
-      table.partition_key_columns.map(&:type).should == [Cequel::Type::Text.instance]
+      expect(table.partition_key_columns.map(&:type)).to eq([Cequel::Type::Text.instance])
     end
 
     it 'should read non-partition key name' do
-      table.clustering_columns.map(&:name).should == [:permalink]
+      expect(table.clustering_columns.map(&:name)).to eq([:permalink])
     end
 
     it 'should read non-partition key type' do
-      table.clustering_columns.map(&:type).
-        should == [Cequel::Type::Ascii.instance]
+      expect(table.clustering_columns.map(&:type)).
+        to eq([Cequel::Type::Ascii.instance])
     end
 
     it 'should default clustering order to asc' do
-      table.clustering_columns.map(&:clustering_order).should == [:asc]
+      expect(table.clustering_columns.map(&:clustering_order)).to eq([:asc])
     end
   end # describe 'reading single non-partition key'
 
@@ -73,16 +73,16 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read non-partition key name' do
-      table.clustering_columns.map(&:name).should == [:permalink]
+      expect(table.clustering_columns.map(&:name)).to eq([:permalink])
     end
 
     it 'should read non-partition key type' do
-      table.clustering_columns.map(&:type).
-        should == [Cequel::Type::Ascii.instance]
+      expect(table.clustering_columns.map(&:type)).
+        to eq([Cequel::Type::Ascii.instance])
     end
 
     it 'should recognize reversed clustering order' do
-      table.clustering_columns.map(&:clustering_order).should == [:desc]
+      expect(table.clustering_columns.map(&:clustering_order)).to eq([:desc])
     end
   end # describe 'reading reverse-ordered non-partition key'
 
@@ -100,16 +100,16 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read non-partition key names' do
-      table.clustering_columns.map(&:name).should == [:permalink, :author_id]
+      expect(table.clustering_columns.map(&:name)).to eq([:permalink, :author_id])
     end
 
     it 'should read non-partition key types' do
-      table.clustering_columns.map(&:type).
-        should == [Cequel::Type::Ascii.instance, Cequel::Type::Uuid.instance]
+      expect(table.clustering_columns.map(&:type)).
+        to eq([Cequel::Type::Ascii.instance, Cequel::Type::Uuid.instance])
     end
 
     it 'should read heterogeneous clustering orders' do
-      table.clustering_columns.map(&:clustering_order).should == [:desc, :asc]
+      expect(table.clustering_columns.map(&:clustering_order)).to eq([:desc, :asc])
     end
   end # describe 'reading compound non-partition key'
 
@@ -125,16 +125,16 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read partition key names' do
-      table.partition_key_columns.map(&:name).should == [:blog_subdomain, :permalink]
+      expect(table.partition_key_columns.map(&:name)).to eq([:blog_subdomain, :permalink])
     end
 
     it 'should read partition key types' do
-      table.partition_key_columns.map(&:type).
-        should == [Cequel::Type::Text.instance, Cequel::Type::Ascii.instance]
+      expect(table.partition_key_columns.map(&:type)).
+        to eq([Cequel::Type::Text.instance, Cequel::Type::Ascii.instance])
     end
 
     it 'should have empty nonpartition keys' do
-      table.clustering_columns.should be_empty
+      expect(table.clustering_columns).to be_empty
     end
 
   end # describe 'reading compound partition key'
@@ -154,26 +154,27 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read partition key names' do
-      table.partition_key_columns.map(&:name).should == [:blog_subdomain, :permalink]
+      expect(table.partition_key_columns.map(&:name)).to eq([:blog_subdomain, :permalink])
     end
 
     it 'should read partition key types' do
-      table.partition_key_columns.map(&:type).
-        should == [Cequel::Type::Text.instance, Cequel::Type::Ascii.instance]
+      expect(table.partition_key_columns.map(&:type)).
+        to eq([Cequel::Type::Text.instance, Cequel::Type::Ascii.instance])
     end
 
     it 'should read non-partition key names' do
-      table.clustering_columns.map(&:name).
-        should == [:author_id, :published_at]
+      expect(table.clustering_columns.map(&:name)).
+        to eq([:author_id, :published_at])
     end
 
     it 'should read non-partition key types' do
-      table.clustering_columns.map(&:type).should ==
+      expect(table.clustering_columns.map(&:type)).to eq(
         [Cequel::Type::Uuid.instance, Cequel::Type::Timestamp.instance]
+      )
     end
 
     it 'should read clustering order' do
-      table.clustering_columns.map(&:clustering_order).should == [:asc, :desc]
+      expect(table.clustering_columns.map(&:clustering_order)).to eq([:asc, :desc])
     end
 
   end # describe 'reading compound partition and non-partition keys'
@@ -197,55 +198,55 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read types of scalar data columns' do
-      table.data_columns.find { |column| column.name == :title }.type.
-        should == Cequel::Type[:text]
-      table.data_columns.find { |column| column.name == :author_id }.type.
-        should == Cequel::Type[:uuid]
+      expect(table.data_columns.find { |column| column.name == :title }.type).
+        to eq(Cequel::Type[:text])
+      expect(table.data_columns.find { |column| column.name == :author_id }.type).
+        to eq(Cequel::Type[:uuid])
     end
 
     it 'should read index attributes' do
-      table.data_columns.find { |column| column.name == :author_id }.index_name.
-        should == :posts_author_id_idx
+      expect(table.data_columns.find { |column| column.name == :author_id }.index_name).
+        to eq(:posts_author_id_idx)
     end
 
     it 'should leave nil index for non-indexed columns' do
-      table.data_columns.find { |column| column.name == :title }.index_name.
-        should be_nil
+      expect(table.data_columns.find { |column| column.name == :title }.index_name).
+        to be_nil
     end
 
     it 'should read list columns' do
-      table.data_columns.find { |column| column.name == :categories }.
-        should be_a(Cequel::Schema::List)
+      expect(table.data_columns.find { |column| column.name == :categories }).
+        to be_a(Cequel::Schema::List)
     end
 
     it 'should read list column type' do
-      table.data_columns.find { |column| column.name == :categories }.type.
-        should == Cequel::Type[:text]
+      expect(table.data_columns.find { |column| column.name == :categories }.type).
+        to eq(Cequel::Type[:text])
     end
 
     it 'should read set columns' do
-      table.data_columns.find { |column| column.name == :tags }.
-        should be_a(Cequel::Schema::Set)
+      expect(table.data_columns.find { |column| column.name == :tags }).
+        to be_a(Cequel::Schema::Set)
     end
 
     it 'should read set column type' do
-      table.data_columns.find { |column| column.name == :tags }.type.
-        should == Cequel::Type[:text]
+      expect(table.data_columns.find { |column| column.name == :tags }.type).
+        to eq(Cequel::Type[:text])
     end
 
     it 'should read map columns' do
-      table.data_columns.find { |column| column.name == :trackbacks }.
-        should be_a(Cequel::Schema::Map)
+      expect(table.data_columns.find { |column| column.name == :trackbacks }).
+        to be_a(Cequel::Schema::Map)
     end
 
     it 'should read map column key type' do
-      table.data_columns.find { |column| column.name == :trackbacks }.key_type.
-        should == Cequel::Type[:timestamp]
+      expect(table.data_columns.find { |column| column.name == :trackbacks }.key_type).
+        to eq(Cequel::Type[:timestamp])
     end
 
     it 'should read map column value type' do
-      table.data_columns.find { |column| column.name == :trackbacks }.
-        value_type.should == Cequel::Type[:ascii]
+      expect(table.data_columns.find { |column| column.name == :trackbacks }.
+        value_type).to eq(Cequel::Type[:ascii])
     end
 
   end # describe 'reading data columns'
@@ -272,41 +273,41 @@ describe Cequel::Schema::TableReader do
     end
 
     it 'should read float properties' do
-      table.property(:bloom_filter_fp_chance).should == 0.02
+      expect(table.property(:bloom_filter_fp_chance)).to eq(0.02)
     end
 
     it 'should read string properties' do
-      table.property(:comment).should == 'Posts table'
+      expect(table.property(:comment)).to eq('Posts table')
     end
 
     it 'should read and simplify compaction class' do
-      table.property(:compaction)[:class].
-        should == 'SizeTieredCompactionStrategy'
+      expect(table.property(:compaction)[:class]).
+        to eq('SizeTieredCompactionStrategy')
     end
 
     it 'should read float properties from compaction hash' do
-      table.property(:compaction)[:bucket_high].should == 1.8
+      expect(table.property(:compaction)[:bucket_high]).to eq(1.8)
     end
 
     it 'should read integer properties from compaction hash' do
-      table.property(:compaction)[:max_threshold].should == 64
+      expect(table.property(:compaction)[:max_threshold]).to eq(64)
     end
 
     it 'should read and simplify compression class' do
-      table.property(:compression)[:sstable_compression].
-        should == 'DeflateCompressor'
+      expect(table.property(:compression)[:sstable_compression]).
+        to eq('DeflateCompressor')
     end
 
     it 'should read integer properties from compression class' do
-      table.property(:compression)[:chunk_length_kb].should == 128
+      expect(table.property(:compression)[:chunk_length_kb]).to eq(128)
     end
 
     it 'should read float properties from compression class' do
-      table.property(:compression)[:crc_check_chance].should == 0.5
+      expect(table.property(:compression)[:crc_check_chance]).to eq(0.5)
     end
 
     it 'should recognize no compact storage' do
-      table.should_not be_compact_storage
+      expect(table).not_to be_compact_storage
     end
 
   end # describe 'reading storage properties'
@@ -320,13 +321,13 @@ describe Cequel::Schema::TableReader do
     end
     subject { table }
 
-    it { should be_compact_storage }
+    it { is_expected.to be_compact_storage }
     its(:partition_key_columns) { should ==
       [Cequel::Schema::PartitionKey.new(:permalink, :text)] }
     its(:clustering_columns) { should be_empty }
-    its(:data_columns) { should =~
-      [Cequel::Schema::DataColumn.new(:title, :text),
-        Cequel::Schema::DataColumn.new(:body, :text)] }
+    specify { expect(table.data_columns).to contain_exactly(
+      Cequel::Schema::DataColumn.new(:title, :text),
+      Cequel::Schema::DataColumn.new(:body, :text)) }
   end
 
   describe 'wide-row compact storage' do
@@ -343,7 +344,7 @@ describe Cequel::Schema::TableReader do
     end
     subject { table }
 
-    it { should be_compact_storage }
+    it { is_expected.to be_compact_storage }
     its(:partition_key_columns) { should ==
       [Cequel::Schema::PartitionKey.new(:blog_subdomain, :text)] }
     its(:clustering_columns) { should ==
@@ -360,13 +361,15 @@ describe Cequel::Schema::TableReader do
     end
     subject { table }
 
-    it { should be_compact_storage }
-    its(:partition_key_columns) { should ==
-      [Cequel::Schema::PartitionKey.new(:permalink, :text)] }
-    its(:clustering_columns) { should be_empty }
-    its(:data_columns) { should =~
+    it { is_expected.to be_compact_storage }
+    its(:partition_key_columns) { is_expected.to eq(
+      [Cequel::Schema::PartitionKey.new(:permalink, :text)]
+    ) }
+    its(:clustering_columns) { is_expected.to be_empty }
+    its(:data_columns) { is_expected.to match_array(
       [Cequel::Schema::DataColumn.new(:title, :text),
-        Cequel::Schema::DataColumn.new(:body, :text)] }
+        Cequel::Schema::DataColumn.new(:body, :text)]
+    ) }
   end
 
   describe 'wide-row legacy table', thrift: true do
@@ -378,12 +381,15 @@ describe Cequel::Schema::TableReader do
     end
     subject { table }
 
-    it { should be_compact_storage }
-    its(:partition_key_columns) { should ==
-      [Cequel::Schema::PartitionKey.new(:blog_subdomain, :text)] }
-    its(:clustering_columns) { should ==
-      [Cequel::Schema::ClusteringColumn.new(:column1, :uuid)] }
-    its(:data_columns) { should ==
-      [Cequel::Schema::DataColumn.new(:value, :text)] }
+    it { is_expected.to be_compact_storage }
+    its(:partition_key_columns) { is_expected.to eq(
+      [Cequel::Schema::PartitionKey.new(:blog_subdomain, :text)]
+    ) }
+    its(:clustering_columns) { is_expected.to eq(
+      [Cequel::Schema::ClusteringColumn.new(:column1, :uuid)]
+    ) }
+    its(:data_columns) { is_expected.to eq(
+      [Cequel::Schema::DataColumn.new(:value, :text)]
+    ) }
   end
 end