cequel 1.4.2 → 1.4.3

data/spec/examples/schema/table_synchronizer_spec.rb

@@ -21,7 +21,7 @@ describe Cequel::Schema::TableSynchronizer do
     after { cequel.schema.drop_table(:posts) }
 
     it 'should create table' do
-      table.column(:title).type.should == Cequel::Type[:text] #etc.
+      expect(table.column(:title).type).to eq(Cequel::Type[:text]) #etc.
     end
   end
 
@@ -58,35 +58,35 @@ describe Cequel::Schema::TableSynchronizer do
       end
 
       it 'should rename keys' do
-        table.clustering_columns.first.name.should == :post_permalink
+        expect(table.clustering_columns.first.name).to eq(:post_permalink)
       end
 
       it 'should add new columns' do
-        table.column(:published_at).type.should == Cequel::Type[:timestamp]
+        expect(table.column(:published_at).type).to eq(Cequel::Type[:timestamp])
       end
 
       it 'should add new collections' do
-        table.column(:categories).should be_a(Cequel::Schema::List)
+        expect(table.column(:categories)).to be_a(Cequel::Schema::List)
       end
 
       it 'should add new column with index' do
-        table.column(:primary_author_id).should be_indexed
+        expect(table.column(:primary_author_id)).to be_indexed
       end
 
       it 'should add index to existing columns' do
-        table.column(:created_at).should be_indexed
+        expect(table.column(:created_at)).to be_indexed
       end
 
       it 'should drop index from existing columns' do
-        table.column(:title).should_not be_indexed
+        expect(table.column(:title)).not_to be_indexed
       end
 
       it 'should change column type' do
-        table.column(:body).type.should == Cequel::Type[:text]
+        expect(table.column(:body).type).to eq(Cequel::Type[:text])
       end
 
       it 'should change properties' do
-        table.property(:comment).should == 'Test Table 2.0'
+        expect(table.property(:comment)).to eq('Test Table 2.0')
       end
 
     end

data/spec/examples/schema/table_updater_spec.rb

@@ -23,7 +23,7 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should add the column with the given type' do
-      table.data_column(:published_at).type.should == Cequel::Type[:timestamp]
+      expect(table.data_column(:published_at).type).to eq(Cequel::Type[:timestamp])
     end
   end
 
@@ -35,11 +35,11 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should add the list' do
-      table.data_column(:author_names).should be_a(Cequel::Schema::List)
+      expect(table.data_column(:author_names)).to be_a(Cequel::Schema::List)
     end
 
     it 'should set the given type' do
-      table.data_column(:author_names).type.should == Cequel::Type[:text]
+      expect(table.data_column(:author_names).type).to eq(Cequel::Type[:text])
     end
   end
 
@@ -51,11 +51,11 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should add the list' do
-      table.data_column(:author_names).should be_a(Cequel::Schema::Set)
+      expect(table.data_column(:author_names)).to be_a(Cequel::Schema::Set)
     end
 
     it 'should set the given type' do
-      table.data_column(:author_names).type.should == Cequel::Type[:text]
+      expect(table.data_column(:author_names).type).to eq(Cequel::Type[:text])
     end
   end
 
@@ -67,17 +67,17 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should add the list' do
-      table.data_column(:trackbacks).should be_a(Cequel::Schema::Map)
+      expect(table.data_column(:trackbacks)).to be_a(Cequel::Schema::Map)
     end
 
     it 'should set the key type' do
-      table.data_column(:trackbacks).key_type.
-        should == Cequel::Type[:timestamp]
+      expect(table.data_column(:trackbacks).key_type).
+        to eq(Cequel::Type[:timestamp])
     end
 
     it 'should set the value type' do
-      table.data_column(:trackbacks).value_type.
-        should == Cequel::Type[:ascii]
+      expect(table.data_column(:trackbacks).value_type).
+        to eq(Cequel::Type[:ascii])
     end
   end
 
@@ -89,7 +89,7 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should change the type' do
-      table.data_column(:title).type.should == Cequel::Type[:text]
+      expect(table.data_column(:title).type).to eq(Cequel::Type[:text])
     end
   end
 
@@ -101,8 +101,8 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should change the name' do
-      table.clustering_column(:slug).should be
-      table.clustering_column(:permalink).should be_nil
+      expect(table.clustering_column(:slug)).to be
+      expect(table.clustering_column(:permalink)).to be_nil
     end
   end
 
@@ -114,7 +114,7 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should change properties' do
-      table.properties[:comment].value.should == 'Test Comment'
+      expect(table.properties[:comment].value).to eq('Test Comment')
     end
   end
 
@@ -126,7 +126,7 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should add the index' do
-      table.data_column(:title).should be_indexed
+      expect(table.data_column(:title)).to be_indexed
     end
   end
 
@@ -139,7 +139,7 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should drop the index' do
-      table.data_column(:title).should_not be_indexed
+      expect(table.data_column(:title)).not_to be_indexed
     end
   end
 
@@ -152,7 +152,7 @@ describe Cequel::Schema::TableUpdater do
     end
 
     it 'should remove the column' do
-      table.data_column(:body).should be_nil
+      expect(table.data_column(:body)).to be_nil
     end
   end
 end

data/spec/examples/schema/table_writer_spec.rb

@@ -20,16 +20,16 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should create key alias' do
-        table.partition_key_columns.map(&:name).should == [:permalink]
+        expect(table.partition_key_columns.map(&:name)).to eq([:permalink])
       end
 
       it 'should set key validator' do
-        table.partition_key_columns.map(&:type).should == [Cequel::Type[:ascii]]
+        expect(table.partition_key_columns.map(&:type)).to eq([Cequel::Type[:ascii]])
       end
 
       it 'should set non-key columns' do
-        table.columns.find { |column| column.name == :title }.type.
-          should == Cequel::Type[:text]
+        expect(table.columns.find { |column| column.name == :title }.type).
+          to eq(Cequel::Type[:text])
       end
     end
 
@@ -43,19 +43,19 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should create key alias' do
-        table.partition_key_columns.map(&:name).should == [:blog_subdomain]
+        expect(table.partition_key_columns.map(&:name)).to eq([:blog_subdomain])
       end
 
       it 'should set key validator' do
-        table.partition_key_columns.map(&:type).should == [Cequel::Type[:ascii]]
+        expect(table.partition_key_columns.map(&:type)).to eq([Cequel::Type[:ascii]])
       end
 
       it 'should create non-partition key components' do
-        table.clustering_columns.map(&:name).should == [:permalink]
+        expect(table.clustering_columns.map(&:name)).to eq([:permalink])
       end
 
       it 'should set type for non-partition key components' do
-        table.clustering_columns.map(&:type).should == [Cequel::Type[:ascii]]
+        expect(table.clustering_columns.map(&:type)).to eq([Cequel::Type[:ascii]])
       end
     end
 
@@ -69,12 +69,12 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should create all partition key components' 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 set key validators' do
-        table.partition_key_columns.map(&:type).
-          should == [Cequel::Type[:ascii], Cequel::Type[:ascii]]
+        expect(table.partition_key_columns.map(&:type)).
+          to eq([Cequel::Type[:ascii], Cequel::Type[:ascii]])
       end
     end
 
@@ -89,21 +89,21 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should create all partition key components' 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 set key validators' do
-        table.partition_key_columns.map(&:type).
-          should == [Cequel::Type[:ascii], Cequel::Type[:ascii]]
+        expect(table.partition_key_columns.map(&:type)).
+          to eq([Cequel::Type[:ascii], Cequel::Type[:ascii]])
       end
 
       it 'should create non-partition key components' do
-        table.clustering_columns.map(&:name).should == [:month]
+        expect(table.clustering_columns.map(&:name)).to eq([:month])
       end
 
       it 'should set type for non-partition key components' do
-        table.clustering_columns.map(&:type).should == [Cequel::Type[:timestamp]]
+        expect(table.clustering_columns.map(&:type)).to eq([Cequel::Type[:timestamp]])
       end
     end
 
@@ -119,33 +119,33 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should create list' do
-        table.data_column(:authors).should be_a(Cequel::Schema::List)
+        expect(table.data_column(:authors)).to be_a(Cequel::Schema::List)
       end
 
       it 'should set correct type for list' do
-        table.data_column(:authors).type.should == Cequel::Type[:blob]
+        expect(table.data_column(:authors).type).to eq(Cequel::Type[:blob])
       end
 
       it 'should create set' do
-        table.data_column(:tags).should be_a(Cequel::Schema::Set)
+        expect(table.data_column(:tags)).to be_a(Cequel::Schema::Set)
       end
 
       it 'should set correct type for set' do
-        table.data_column(:tags).type.should == Cequel::Type[:text]
+        expect(table.data_column(:tags).type).to eq(Cequel::Type[:text])
       end
 
       it 'should create map' do
-        table.data_column(:trackbacks).should be_a(Cequel::Schema::Map)
+        expect(table.data_column(:trackbacks)).to be_a(Cequel::Schema::Map)
       end
 
       it 'should set correct key type' do
-        table.data_column(:trackbacks).key_type.
-          should == Cequel::Type[:timestamp]
+        expect(table.data_column(:trackbacks).key_type).
+          to eq(Cequel::Type[:timestamp])
       end
 
       it 'should set correct value type' do
-        table.data_column(:trackbacks).value_type.
-          should == Cequel::Type[:ascii]
+        expect(table.data_column(:trackbacks).value_type).
+          to eq(Cequel::Type[:ascii])
       end
     end
 
@@ -162,14 +162,14 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should set simple properties' do
-        table.property(:comment).should == 'Blog posts'
+        expect(table.property(:comment)).to eq('Blog posts')
       end
 
       it 'should set map collection properties' do
-        table.property(:compression).should == {
+        expect(table.property(:compression)).to eq({
           :sstable_compression => 'DeflateCompressor',
           :chunk_length_kb => 64
-        }
+        })
       end
     end
 
@@ -183,7 +183,7 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should have compact storage' do
-        table.should be_compact_storage
+        expect(table).to be_compact_storage
       end
     end
 
@@ -197,7 +197,7 @@ describe Cequel::Schema::TableWriter do
       end
 
       it 'should set clustering order' do
-        table.clustering_columns.map(&:clustering_order).should == [:desc]
+        expect(table.clustering_columns.map(&:clustering_order)).to eq([:desc])
       end
     end
 
@@ -208,7 +208,7 @@ describe Cequel::Schema::TableWriter do
           key :id, :uuid, :desc
           column :title, :text, :index => true
         end
-        table.data_column(:title).should be_indexed
+        expect(table.data_column(:title)).to be_indexed
       end
 
       it 'should create indices with specified name' do
@@ -217,7 +217,7 @@ describe Cequel::Schema::TableWriter do
           key :id, :uuid, :desc
           column :title, :text, :index => :silly_idx
         end
-        table.data_column(:title).index_name.should == :silly_idx
+        expect(table.data_column(:title).index_name).to eq(:silly_idx)
       end
     end
 

data/spec/examples/type_spec.rb

@@ -10,8 +10,8 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.AsciiType' }
 
     describe '#cast' do
-      specify { subject.cast('hey'.encode('UTF-8')).encoding.name.
-        should == 'US-ASCII' }
+      specify { expect(subject.cast('hey'.encode('UTF-8')).encoding.name).
+        to eq('US-ASCII') }
     end
   end
 
@@ -22,9 +22,9 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.BytesType' }
 
     describe '#cast' do
-      specify { subject.cast(123).should == 123.to_s(16) }
-      specify { subject.cast(123).encoding.name.should == 'ASCII-8BIT' }
-      specify { subject.cast('2345').encoding.name.should == 'ASCII-8BIT' }
+      specify { expect(subject.cast(123)).to eq(123.to_s(16)) }
+      specify { expect(subject.cast(123).encoding.name).to eq('ASCII-8BIT') }
+      specify { expect(subject.cast('2345').encoding.name).to eq('ASCII-8BIT') }
     end
   end
 
@@ -35,9 +35,9 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.BooleanType' }
 
     describe '#cast' do
-      specify { subject.cast(true).should == true }
-      specify { subject.cast(false).should == false }
-      specify { subject.cast(1).should == true }
+      specify { expect(subject.cast(true)).to eq(true) }
+      specify { expect(subject.cast(false)).to eq(false) }
+      specify { expect(subject.cast(1)).to eq(true) }
     end
   end
 
@@ -48,8 +48,8 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.CounterColumnType' }
 
     describe '#cast' do
-      specify { subject.cast(1).should == 1 }
-      specify { subject.cast('1').should == 1 }
+      specify { expect(subject.cast(1)).to eq(1) }
+      specify { expect(subject.cast('1')).to eq(1) }
     end
   end
 
@@ -60,10 +60,10 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.DecimalType' }
 
     describe '#cast' do
-      specify { subject.cast(1).should eql(BigDecimal.new('1.0')) }
-      specify { subject.cast(1.0).should eql(BigDecimal.new('1.0')) }
-      specify { subject.cast(1.0.to_r).should eql(BigDecimal.new('1.0')) }
-      specify { subject.cast('1').should eql(BigDecimal.new('1.0')) }
+      specify { expect(subject.cast(1)).to eql(BigDecimal.new('1.0')) }
+      specify { expect(subject.cast(1.0)).to eql(BigDecimal.new('1.0')) }
+      specify { expect(subject.cast(1.0.to_r)).to eql(BigDecimal.new('1.0')) }
+      specify { expect(subject.cast('1')).to eql(BigDecimal.new('1.0')) }
     end
   end
 
@@ -74,11 +74,11 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.DoubleType' }
 
     describe '#cast' do
-      specify { subject.cast(1.0).should eql(1.0) }
-      specify { subject.cast(1).should eql(1.0) }
-      specify { subject.cast(1.0.to_r).should eql(1.0) }
-      specify { subject.cast('1.0').should eql(1.0) }
-      specify { subject.cast(BigDecimal.new('1.0')).should eql(1.0) }
+      specify { expect(subject.cast(1.0)).to eql(1.0) }
+      specify { expect(subject.cast(1)).to eql(1.0) }
+      specify { expect(subject.cast(1.0.to_r)).to eql(1.0) }
+      specify { expect(subject.cast('1.0')).to eql(1.0) }
+      specify { expect(subject.cast(BigDecimal.new('1.0'))).to eql(1.0) }
     end
   end
 
@@ -89,11 +89,11 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.FloatType' }
 
     describe '#cast' do
-      specify { subject.cast(1.0).should eql(1.0) }
-      specify { subject.cast(1).should eql(1.0) }
-      specify { subject.cast(1.0.to_r).should eql(1.0) }
-      specify { subject.cast('1.0').should eql(1.0) }
-      specify { subject.cast(BigDecimal.new('1.0')).should eql(1.0) }
+      specify { expect(subject.cast(1.0)).to eql(1.0) }
+      specify { expect(subject.cast(1)).to eql(1.0) }
+      specify { expect(subject.cast(1.0.to_r)).to eql(1.0) }
+      specify { expect(subject.cast('1.0')).to eql(1.0) }
+      specify { expect(subject.cast(BigDecimal.new('1.0'))).to eql(1.0) }
     end
   end
 
@@ -111,11 +111,11 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.Int32Type' }
 
     describe '#cast' do
-      specify { subject.cast(1).should eql(1) }
-      specify { subject.cast('1').should eql(1) }
-      specify { subject.cast(1.0).should eql(1) }
-      specify { subject.cast(1.0.to_r).should eql(1) }
-      specify { subject.cast(BigDecimal.new('1.0')).should eql(1) }
+      specify { expect(subject.cast(1)).to eql(1) }
+      specify { expect(subject.cast('1')).to eql(1) }
+      specify { expect(subject.cast(1.0)).to eql(1) }
+      specify { expect(subject.cast(1.0.to_r)).to eql(1) }
+      specify { expect(subject.cast(BigDecimal.new('1.0'))).to eql(1) }
     end
   end
 
@@ -126,11 +126,11 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.LongType' }
 
     describe '#cast' do
-      specify { subject.cast(1).should eql(1) }
-      specify { subject.cast('1').should eql(1) }
-      specify { subject.cast(1.0).should eql(1) }
-      specify { subject.cast(1.0.to_r).should eql(1) }
-      specify { subject.cast(BigDecimal.new('1.0')).should eql(1) }
+      specify { expect(subject.cast(1)).to eql(1) }
+      specify { expect(subject.cast('1')).to eql(1) }
+      specify { expect(subject.cast(1.0)).to eql(1) }
+      specify { expect(subject.cast(1.0.to_r)).to eql(1) }
+      specify { expect(subject.cast(BigDecimal.new('1.0'))).to eql(1) }
     end
   end
 
@@ -138,14 +138,14 @@ describe Cequel::Type do
     subject { Cequel::Type[:text] }
     its(:cql_name) { should == :text }
     its(:internal_name) { should == 'org.apache.cassandra.db.marshal.UTF8Type' }
-    it { should == Cequel::Type[:varchar] }
+    it { is_expected.to eq(Cequel::Type[:varchar]) }
 
     describe '#cast' do
-      specify { subject.cast('cql').should == 'cql' }
-      specify { subject.cast(1).should == '1' }
-      specify { subject.cast('cql').encoding.name.should == 'UTF-8' }
-      specify { subject.cast('cql'.force_encoding('US-ASCII')).
-        encoding.name.should == 'UTF-8' }
+      specify { expect(subject.cast('cql')).to eq('cql') }
+      specify { expect(subject.cast(1)).to eq('1') }
+      specify { expect(subject.cast('cql').encoding.name).to eq('UTF-8') }
+      specify { expect(subject.cast('cql'.force_encoding('US-ASCII')).
+        encoding.name).to eq('UTF-8') }
     end
   end
 
@@ -156,11 +156,11 @@ describe Cequel::Type do
 
     describe '#cast' do
       let(:now) { Time.at(Time.now.to_i) }
-      specify { subject.cast(now).should == now }
-      specify { subject.cast(now.to_i).should == now }
-      specify { subject.cast(now.to_s).should == now }
-      specify { subject.cast(now.to_datetime).should == now }
-      specify { subject.cast(now.to_date).should == now.to_date.to_time }
+      specify { expect(subject.cast(now)).to eq(now) }
+      specify { expect(subject.cast(now.to_i)).to eq(now) }
+      specify { expect(subject.cast(now.to_s)).to eq(now) }
+      specify { expect(subject.cast(now.to_datetime)).to eq(now) }
+      specify { expect(subject.cast(now.to_date)).to eq(now.to_date.to_time) }
     end
   end
 
@@ -179,12 +179,12 @@ describe Cequel::Type do
 
     describe '#cast' do
       let(:uuid) { Cequel.uuid }
-      specify { subject.cast(uuid).should == uuid }
-      specify { subject.cast(uuid.to_s).should == uuid }
-      specify { subject.cast(uuid.value).should == uuid }
+      specify { expect(subject.cast(uuid)).to eq(uuid) }
+      specify { expect(subject.cast(uuid.to_s)).to eq(uuid) }
+      specify { expect(subject.cast(uuid.value)).to eq(uuid) }
       if defined? SimpleUUID::UUID
-        specify { subject.cast(SimpleUUID::UUID.new(uuid.value))
-                    .should == uuid }
+        specify { expect(subject.cast(SimpleUUID::UUID.new(uuid.value)))
+                    .to eq(uuid) }
       end
     end
   end
@@ -196,11 +196,11 @@ describe Cequel::Type do
       should == 'org.apache.cassandra.db.marshal.IntegerType' }
 
     describe '#cast' do
-      specify { subject.cast(1).should eql(1) }
-      specify { subject.cast('1').should eql(1) }
-      specify { subject.cast(1.0).should eql(1) }
-      specify { subject.cast(1.0.to_r).should eql(1) }
-      specify { subject.cast(BigDecimal.new('1.0')).should eql(1) }
+      specify { expect(subject.cast(1)).to eql(1) }
+      specify { expect(subject.cast('1')).to eql(1) }
+      specify { expect(subject.cast(1.0)).to eql(1) }
+      specify { expect(subject.cast(1.0.to_r)).to eql(1) }
+      specify { expect(subject.cast(BigDecimal.new('1.0'))).to eql(1) }
     end
   end