datastax_rails 2.0.12 → 2.0.15

data/lib/schema_migration.rb

@@ -4,13 +4,13 @@ class SchemaMigration
   def self.default_consistency
     DatastaxRails::Base.default_consistency
   end
-  
+
   # Returns the name of the column family
   def self.column_family
     'schema_migrations'
   end
-  
+
   def self.primary_key
     'cf'
   end
-end
+end

data/spec/datastax_rails/associations/belongs_to_association_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe DatastaxRails::Base do
-  describe "BelongsTo Association" do
-    
+  describe 'BelongsTo Association' do
+
   end
 end

data/spec/datastax_rails/associations/collection_association_spec.rb

@@ -3,35 +3,35 @@ require 'spec_helper'
 describe DatastaxRails::Base do
   context 'associations' do
     context 'collection' do
-      subject {Person.new(name: 'Matthew')}
-      
-      describe "#size" do
-        it "reports the total of persisted and non-persisted" do
+      subject { Person.new(name: 'Matthew') }
+
+      describe '#size' do
+        it 'reports the total of persisted and non-persisted' do
           subject.save
-          car1 = Car.create(:person_id => subject.id)
+          Car.create(person_id: subject.id)
           car2 = Car.new
           subject.cars << car2
           Car.commit_solr
           expect(subject.cars.size).to be(2)
         end
       end
-      
-      describe "#empty?" do
-        it "returns false if a new record exists" do
+
+      describe '#empty?' do
+        it 'returns false if a new record exists' do
           subject.cars << Car.new
           expect(subject.cars).not_to be_empty
         end
       end
-      
-      describe "#any?" do
-        it "returns true if a new record exists" do
+
+      describe '#any?' do
+        it 'returns true if a new record exists' do
           subject.cars << Car.new
           expect(subject.cars).to be_any
         end
       end
-      
-      describe "#many?" do
-        it "returns false if more than one new record exists" do
+
+      describe '#many?' do
+        it 'returns false if more than one new record exists' do
           subject.cars << Car.new
           subject.cars << Car.new
           expect(subject.cars).to be_many

data/spec/datastax_rails/associations/has_many_association_spec.rb

@@ -1,38 +1,38 @@
 require 'spec_helper'
 
 describe DatastaxRails::Base do
-  describe "HasMany Associations" do
-    it "should destroy all objects with :dependent => :destroy" do
-      p = Person.create(:name => "jason")
-      Car.create(:name => "Jeep", :person_id => p.id)
+  describe 'HasMany Associations' do
+    it 'should destroy all objects with :dependent => :destroy' do
+      p = Person.create(name: 'jason')
+      Car.create(name: 'Jeep', person_id: p.id)
       Car.commit_solr
       p.destroy
       Car.commit_solr
       Person.commit_solr
-      Car.count.should == 0
+      expect(Car.count).to eq(0)
     end
-    
-    it "should retrieve child records" do
-      p = Person.create(:name => 'jason')
-      c = Car.create(:name => 'Jeep', :person_id => p.id)
+
+    it 'should retrieve child records' do
+      p = Person.create(name: 'jason')
+      c = Car.create(name: 'Jeep', person_id: p.id)
       Car.commit_solr
-      p.cars.should include(c)
+      expect(p.cars).to include(c)
     end
-    
-    it "should retrieve only child records" do
-      p = Person.create(:name => 'jason')
-      c = Car.create(:name => 'Jeep', :person_id => '12345')
+
+    it 'should retrieve only child records' do
+      p = Person.create(name: 'jason')
+      c = Car.create(name: 'Jeep', person_id: '12345')
       Car.commit_solr
-      p.cars.should_not include(c)
+      expect(p.cars).not_to include(c)
     end
-    
-    it "should create records with the proper foreign key" do
+
+    it 'should create records with the proper foreign key' do
       Person.commit_solr
-      p = Person.create(:name => 'jason')
-      p.cars.create(:name => 'Jeep')
+      p = Person.create(name: 'jason')
+      p.cars.create(name: 'Jeep')
       Car.commit_solr
       Person.commit_solr
-      Car.first.person.should == p
+      expect(Car.first.person).to eq(p)
     end
   end
 end

data/spec/datastax_rails/associations_spec.rb

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 describe DatastaxRails::Base do
-  describe "Associations" do
-    describe "belongs_to" do
-      it "should set the id when setting the object" do
-        person = Person.create(:name => "Jason")
-        job = Job.create(:title => "Developer")
+  describe 'Associations' do
+    describe 'belongs_to' do
+      it 'should set the id when setting the object' do
+        person = Person.create(name: 'Jason')
+        job = Job.create(title: 'Developer')
         Person.commit_solr
         job.person = person
-        job.person_id.should == person.id
+        expect(job.person_id).to eq(person.id)
       end
-      
-      it "should look up the owning model by id" do
+
+      it 'should look up the owning model by id' do
         Job.truncate
         Job.commit_solr
-        person = Person.create!(:name => "John")
-        job = Job.create!(:title => "Developer", :person_id => person.id)
+        person = Person.create!(name: 'John')
+        Job.create!(title: 'Developer', person_id: person.id)
         Person.commit_solr
         Job.commit_solr
-        Job.first.person.should == person
+        expect(Job.first.person).to eq(person)
       end
     end
   end

data/spec/datastax_rails/attribute_methods_spec.rb

@@ -2,48 +2,48 @@ require 'spec_helper'
 
 class AttributeMethodsTester < DatastaxRails::Base
   string :test_string
-  string :non_search_string, :solr_index => false
-end 
+  string :non_search_string, solr_index: false
+end
 
 class CassandraOnlyTester < DatastaxRails::Base
   include DatastaxRails::CassandraOnlyModel
   string :test_string
-  string :test_string2, :cql_index => true
+  string :test_string2, cql_index: true
 end
 
 describe DatastaxRails::Base do
   def tester
     @tester ||= AttributeMethodsTester.new
   end
-  
-  describe "attribute methods" do
-    it "should create attribute setter methods" do
-      tester.should respond_to(:test_string=)
+
+  describe 'attribute methods' do
+    it 'should create attribute setter methods' do
+      expect(tester).to respond_to(:test_string=)
     end
-    
-    it "Should create attribute getter methods" do
-      tester.should respond_to(:test_string)
+
+    it 'Should create attribute getter methods' do
+      expect(tester).to respond_to(:test_string)
     end
   end
-  
-  describe "#attribute" do
-    context "Cassandra-only models" do
-      it "does not index columns by default" do
-        expect(CassandraOnlyTester.attribute_definitions[:test_string].options[:solr_index]).to be_false
-        expect(CassandraOnlyTester.attribute_definitions[:test_string].options[:cql_index]).to be_false
+
+  describe '#attribute' do
+    context 'Cassandra-only models' do
+      it 'does not index columns by default' do
+        expect(CassandraOnlyTester.attribute_definitions[:test_string].options[:solr_index]).to be_falsey
+        expect(CassandraOnlyTester.attribute_definitions[:test_string].options[:cql_index]).to be_falsey
       end
-      
-      it "does not index into solr" do
-        expect(CassandraOnlyTester.attribute_definitions[:test_string2].options[:solr_index]).to be_false
-        expect(CassandraOnlyTester.attribute_definitions[:test_string2].options[:cql_index]).to be_true
+
+      it 'does not index into solr' do
+        expect(CassandraOnlyTester.attribute_definitions[:test_string2].options[:solr_index]).to be_falsey
+        expect(CassandraOnlyTester.attribute_definitions[:test_string2].options[:cql_index]).to be_truthy
       end
     end
-    
-    context "Normal models" do
-      it "indexes data into solr by default" do
-        expect(AttributeMethodsTester.attribute_definitions[:test_string].options[:solr_index]).to be_true
+
+    context 'Normal models' do
+      it 'indexes data into solr by default' do
+        expect(AttributeMethodsTester.attribute_definitions[:test_string].options[:solr_index]).to be_truthy
       end
     end
   end
-  
+
 end

data/spec/datastax_rails/base_spec.rb

@@ -1,43 +1,43 @@
 require 'spec_helper'
 
 describe DatastaxRails::Base do
-  it "should raise RecordNotFound when finding a bogus ID" do
-    lambda { Person.find("xyzzy") }.should raise_exception(DatastaxRails::RecordNotFound)
+  it 'should raise RecordNotFound when finding a bogus ID' do
+    expect { Person.find('xyzzy') }.to raise_exception(DatastaxRails::RecordNotFound)
   end
-  
-  describe "equality" do
-    it "considers new objects to be unequal" do
-      p1=Person.new(:name => 'John')
-      p2=Person.new(:name => 'John')
+
+  describe 'equality' do
+    it 'considers new objects to be unequal' do
+      p1 = Person.new(name: 'John')
+      p2 = Person.new(name: 'John')
       expect(p1).not_to eq(p2)
     end
-    
-    it "considers a new object to be unequal to a saved object" do
-      p1=Person.create!(:name => 'Mike')
-      p2=Person.new(:name => 'Mike')
+
+    it 'considers a new object to be unequal to a saved object' do
+      p1 = Person.create!(name: 'Mike')
+      p2 = Person.new(name: 'Mike')
       expect(p1).not_to eq(p2)
     end
-    
-    it "considers two new objects to be unequal" do
+
+    it 'considers two new objects to be unequal' do
       expect(Person.new).not_to eq(Person.new)
     end
-    
-    it "considers the same object equal to itself" do
-      p=Person.new
+
+    it 'considers the same object equal to itself' do
+      p = Person.new
       expect(p).to eq(p)
     end
-    
-    it "considers two persisted objects to be equal if their primary keys are equal" do
+
+    it 'considers two persisted objects to be equal if their primary keys are equal' do
       Person.commit_solr
-      p1=Person.create!(:name => 'Jim')
-      p2=Person.find(p1.id)
+      p1 = Person.create!(name: 'Jim')
+      p2 = Person.find(p1.id)
       expect(p1).to eq(p2)
     end
-    
-    it "considers two persisted objects to be unequal if they have different primary keys" do
+
+    it 'considers two persisted objects to be unequal if they have different primary keys' do
       Person.commit_solr
-      p1=Person.create!(:name => 'Kirk')
-      p2=Person.create!(:name => 'Tiberious')
+      p1 = Person.create!(name: 'Kirk')
+      p2 = Person.create!(name: 'Tiberious')
       expect(p1).not_to eq(p2)
     end
   end

data/spec/datastax_rails/callbacks_spec.rb

@@ -1,48 +1,48 @@
 require 'spec_helper'
 
 class CallbackTester < Hobby
-  self.column_family = "hobbies"
+  self.column_family = 'hobbies'
   attr_accessor :after_find_called, :after_initialize_called
-  
+
   after_find { self.after_find_called = true }
   after_initialize { self.after_initialize_called = true }
-  
-  %w[before_save before_create after_save after_create before_validation after_validation
-     after_touch before_destroy after_destroy].each do |callback|
-       self.send(callback, callback + "_callback")   # after_save 'after_save_callback'
-       define_method(callback+"_callback") do
+
+  %w(before_save before_create after_save after_create before_validation after_validation
+     after_touch before_destroy after_destroy).each do |callback|
+       send(callback, callback + '_callback')   # after_save 'after_save_callback'
+       define_method(callback + '_callback') do
          true
        end
      end
 end
 
 describe DatastaxRails::Base do
-  describe "callbacks" do
+  describe 'callbacks' do
     subject { CallbackTester.new }
-    
-    %w[before_save before_create after_save after_create before_validation after_validation].each do |callback|
+
+    %w(before_save before_create after_save after_create before_validation after_validation).each do |callback|
       it "runs #{callback}" do
-        expect(subject).to receive(callback+"_callback")
+        expect(subject).to receive(callback + '_callback')
         subject.save
       end
     end
-    
-    %w[after_destroy before_destroy].each do |callback|
+
+    %w(after_destroy before_destroy).each do |callback|
       it "runs #{callback}" do
         subject.save
-        expect(subject).to receive(callback+"_callback")
+        expect(subject).to receive(callback + '_callback')
         subject.destroy
       end
     end
-    
-    it "runs after_find" do
+
+    it 'runs after_find' do
       subject.save
-      ct=CallbackTester.find(subject.id)
-      expect(ct.after_find_called).to be_true
+      ct = CallbackTester.find(subject.id)
+      expect(ct.after_find_called).to be_truthy
     end
-    
-    it "runs after_initialize" do
-      expect(subject.after_initialize_called).to be_true
+
+    it 'runs after_initialize' do
+      expect(subject.after_initialize_called).to be_truthy
     end
   end
 end

data/spec/datastax_rails/column_spec.rb

@@ -1,246 +1,247 @@
 require 'spec_helper'
 
 describe DatastaxRails::Column do
-  describe "type casting" do
-    let(:record) {double(Person, :changed_attributes => {}, :attributes => {})}
-    
-    describe "boolean" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "boolean")}
-      
-      describe "to ruby" do
-        it "casts '' to nil" do 
+  describe 'type casting' do
+    let(:record) { double(Person, changed_attributes: {}, attributes: {}) }
+
+    describe 'boolean' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'boolean') }
+
+      describe 'to ruby' do
+        it "casts '' to nil" do
           expect(c.type_cast('')).to be_nil
         end
-        
-        it "casts nil to nil" do
+
+        it 'casts nil to nil' do
           expect(c.type_cast(nil)).to be_nil
         end
-    
+
         [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].each do |val|
           it "casts #{val.inspect} to true" do
             expect(c.type_cast(val)).to eq(true)
           end
         end
-        
+
         [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF', ' ', "\u3000\r\n", "\u0000", 'SOMETHING RANDOM'].each do |val|
           it "casts #{val.inspect} to false" do
             expect(c.type_cast(val)).to eq(false)
           end
         end
       end
-      
-      describe "to cql3" do
-        it "casts false to false" do
-          expect(c.type_cast_for_cql3(false)).to be_false
+
+      describe 'to cql3' do
+        it 'casts false to false' do
+          expect(c.type_cast_for_cql3(false)).to be_falsey
         end
-        
-        it "casts true to true" do
-          expect(c.type_cast_for_cql3(true)).to be_true
+
+        it 'casts true to true' do
+          expect(c.type_cast_for_cql3(true)).to be_truthy
         end
       end
-      
-      describe "to solr" do
+
+      describe 'to solr' do
         it "casts false to 'false'" do
           expect(c.type_cast_for_solr(false)).to eq('false')
         end
-        
+
         it "casts true to 'true'" do
           expect(c.type_cast_for_solr(true)).to eq('true')
         end
       end
     end
-    
-    describe "integer" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "integer")}
-      
-      describe "to ruby" do
-        [1,'1','1ignore','1.7',true].each do |val|
+
+    describe 'integer' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'integer') }
+
+      describe 'to ruby' do
+        [1, '1', '1ignore', '1.7', true].each do |val|
           it "casts #{val.inspect} to true" do
             expect(c.type_cast(val)).to eq(1)
           end
         end
-        
-        ['bad1','bad',false].each do |val|
+
+        ['bad1', 'bad', false].each do |val|
           it "casts #{val.inspect} to 0" do
             expect(c.type_cast(val)).to eq(0)
           end
         end
-        
-        [nil,[1,2],{1 => 2},(1..2),Object.new,Float::NAN,(1.0/0.0)].each do |val|
+
+        [nil, [1, 2], { 1 => 2 }, (1..2), Object.new, Float::NAN, (1.0 / 0.0)].each do |val|
           it "casts #{val.inspect} to nil" do
             expect(c.type_cast(val)).to be_nil
           end
         end
-        
-        it "casts a duration to an integer" do
+
+        it 'casts a duration to an integer' do
           expect(c.type_cast(30.minutes)).to be(1800)
         end
       end
-      
-      describe "to cql3" do
-        it "casts 1 to 1" do
+
+      describe 'to cql3' do
+        it 'casts 1 to 1' do
           expect(c.type_cast_for_cql3(1)).to be(1)
         end
       end
-      
-      describe "to solr" do
-        it "casts 1 to 1" do
+
+      describe 'to solr' do
+        it 'casts 1 to 1' do
           expect(c.type_cast_for_solr(1)).to be(1)
         end
       end
     end
-    
-    describe "time" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "time")}
-      
-      describe "to ruby" do
-        [nil,'ABC',''].each do |val|
+
+    describe 'time' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'time') }
+
+      describe 'to ruby' do
+        [nil, 'ABC', ''].each do |val|
           it "casts #{val.inspect} to nil" do
             expect(c.type_cast(val)).to be_nil
           end
         end
-        
-        it "casts a time string to Time" do
-          time_string = Time.now.utc.strftime("%T")
-          expect(c.type_cast(time_string).strftime("%T")).to eq(time_string)
+
+        it 'casts a time string to Time' do
+          time_string = Time.now.utc.strftime('%T')
+          expect(c.type_cast(time_string).strftime('%T')).to eq(time_string)
         end
       end
-      
-      describe "to cql3" do
-        it "casts a Time object to a Time object" do
+
+      describe 'to cql3' do
+        it 'casts a Time object to a Time object' do
           time = Time.parse('1980-10-19 17:55:00')
           expect(c.type_cast_for_cql3(time)).to eq(time)
         end
       end
-      
-      describe "to solr" do
-        it "casts a Time object to a solr formatted time string" do
+
+      describe 'to solr' do
+        it 'casts a Time object to a solr formatted time string' do
           time = Time.parse('1980-10-19 17:55:00')
           expect(c.type_cast_for_solr(time)).to eq('1980-10-19T17:55:00Z')
         end
       end
     end
-    
-    describe "timestamp" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "timestamp")}
-      
-      describe "to ruby" do
-        [nil,'',' ', 'ABC'].each do |val|
+
+    describe 'timestamp' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'timestamp') }
+
+      describe 'to ruby' do
+        [nil, '', ' ', 'ABC'].each do |val|
           it "casts #{val.inspect} to nil" do
             expect(c.type_cast(val)).to be_nil
           end
         end
-        
-        it "casts a datetime string to Time" do
-          datetime_string = Time.now.utc.strftime("%FT%T")
-          expect(c.type_cast(datetime_string).strftime("%FT%T")).to eq(datetime_string)
+
+        it 'casts a datetime string to Time' do
+          datetime_string = Time.now.utc.strftime('%FT%T')
+          expect(c.type_cast(datetime_string).strftime('%FT%T')).to eq(datetime_string)
         end
-        
-        it "casts a datetime string with timezone to Time" do
+
+        it 'casts a datetime string with timezone to Time' do
+          pending 'How do we handle other time zones?'
           begin
             old = DatastaxRails::Base.default_timezone
             [:utc, :local].each do |zone|
               DatastaxRails::Base.default_timezone = zone
-              datetime_string = "Wed, 04 Sep 2013 03:00:00 EAT"
-              expect(c.type_cast(val)).to eq(Time.utc(2013, 9, 4, 0, 0, 0))
+              datetime_string = 'Wed, 04 Sep 2013 03:00:00 EDT'
+              expect(c.type_cast(datetime_string)).to eq(Time.utc(2013, 9, 4, 0, 0, 0))
             end
           rescue
             DatastaxRails::Base.default_timezone = old
           end
         end
       end
-      
-      describe "to cql3" do
-        it "casts a Time object to a Time object" do
+
+      describe 'to cql3' do
+        it 'casts a Time object to a Time object' do
           time = Time.parse('1980-10-19 17:55:00')
           expect(c.type_cast_for_cql3(time)).to eq(time)
         end
       end
-      
-      describe "to solr" do
-        it "casts a Time object to a solr formatted time string" do
+
+      describe 'to solr' do
+        it 'casts a Time object to a solr formatted time string' do
           time = Time.parse('1980-10-19 17:55:00')
           expect(c.type_cast_for_solr(time)).to eq('1980-10-19T17:55:00Z')
         end
       end
     end
-    
-    describe "date" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "date")}
-      
-      [nil,'',' ', 'ABC'].each do |val|
+
+    describe 'date' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'date') }
+
+      [nil, '', ' ', 'ABC'].each do |val|
         it "casts #{val.inspect} to nil" do
           expect(c.type_cast(val)).to be_nil
         end
       end
-      
-      it "casts a date string to Date" do
-        date_string = Time.now.utc.strftime("%F")
-        expect(c.type_cast(date_string).strftime("%F")).to eq(date_string)
+
+      it 'casts a date string to Date' do
+        date_string = Time.now.utc.strftime('%F')
+        expect(c.type_cast(date_string).strftime('%F')).to eq(date_string)
       end
-      
-      describe "to cql3" do
-        it "casts a Date object to a Time object" do
+
+      describe 'to cql3' do
+        it 'casts a Date object to a Time object' do
           time = Time.parse('1980-10-19 00:00:00')
           date = Date.parse('1980-10-19')
           expect(c.type_cast_for_cql3(date)).to eq(time)
         end
       end
-      
-      describe "to solr" do
-        it "casts a Date object to a solr formatted time string" do
+
+      describe 'to solr' do
+        it 'casts a Date object to a solr formatted time string' do
           date = Date.parse('1980-10-19')
           expect(c.type_cast_for_solr(date)).to eq('1980-10-19T00:00:00Z')
         end
       end
     end
-    
-    describe "map" do
-      let(:c) {DatastaxRails::Column.new("field_", nil, "map", :holds => :integer)}
-      let(:dc) {DatastaxRails::Column.new("field_", nil, "map", :holds => :date)}
-      
-      it "casts map keys to strings" do
-        expect(c.type_cast({:field_key => 7}, record)).to eq({"field_key" => 7})
-      end
-      
-      it "casts map values to the type specified in the options" do
-        expect(c.type_cast({'field_key' => '7'}, record)).to eq({"field_key" => 7})
-      end
-      
-      it "wraps map values in a DynamicMap" do
-        expect(c.type_cast({'field_key' => '7'}, record)).to be_a(DatastaxRails::Types::DynamicMap)
-      end
-      
-      describe "to cql" do
-        it "casts map values to the appropriate type" do
-          date = Date.parse("1980-10-19")
-          time = Time.parse("1980-10-19 00:00:00 +0000")
-          expect(dc.type_cast_for_cql3({:field_key => date})).to eq(:field_key => time)
+
+    describe 'map' do
+      let(:c) { DatastaxRails::Column.new('field_', nil, 'map', holds: :integer) }
+      let(:dc) { DatastaxRails::Column.new('field_', nil, 'map', holds: :date) }
+
+      it 'casts map keys to strings' do
+        expect(c.type_cast({ field_key: 7 }, record)).to eq('field_key' => 7)
+      end
+
+      it 'casts map values to the type specified in the options' do
+        expect(c.type_cast({ 'field_key' => '7' }, record)).to eq('field_key' => 7)
+      end
+
+      it 'wraps map values in a DynamicMap' do
+        expect(c.type_cast({ 'field_key' => '7' }, record)).to be_a(DatastaxRails::Types::DynamicMap)
+      end
+
+      describe 'to cql' do
+        it 'casts map values to the appropriate type' do
+          date = Date.parse('1980-10-19')
+          time = Time.parse('1980-10-19 00:00:00 +0000')
+          expect(dc.type_cast_for_cql3(field_key: date)).to eq(field_key: time)
         end
       end
     end
-    
-    describe "list" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "list", :holds => :integer)}
-      
-      it "casts list values to the type specified in the options" do
-        expect(c.type_cast([1,"2",6.minutes], record)).to eq([1,2,360])
+
+    describe 'list' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'list', holds: :integer) }
+
+      it 'casts list values to the type specified in the options' do
+        expect(c.type_cast([1, '2', 6.minutes], record)).to eq([1, 2, 360])
       end
-      
-      it "wraps list values in a DynamicList" do
-        expect(c.type_cast([1,"2",6.minutes], record)).to be_a(DatastaxRails::Types::DynamicList)
+
+      it 'wraps list values in a DynamicList' do
+        expect(c.type_cast([1, '2', 6.minutes], record)).to be_a(DatastaxRails::Types::DynamicList)
       end
     end
-    
-    describe "set" do
-      let(:c) {DatastaxRails::Column.new("field", nil, "set", :holds => :integer)}
-      
-      it "casts list values to the type specified in the options" do
-        expect(c.type_cast([1,"2",6.minutes, 2], record)).to eq(Set.new([1,2,360]))
-      end
-      
-      it "wraps list values in a DynamicSet" do
-        expect(c.type_cast([1,"2",6.minutes, 2], record)).to be_a(DatastaxRails::Types::DynamicSet)
+
+    describe 'set' do
+      let(:c) { DatastaxRails::Column.new('field', nil, 'set', holds: :integer) }
+
+      it 'casts list values to the type specified in the options' do
+        expect(c.type_cast([1, '2', 6.minutes, 2], record)).to eq(Set.new([1, 2, 360]))
+      end
+
+      it 'wraps list values in a DynamicSet' do
+        expect(c.type_cast([1, '2', 6.minutes, 2], record)).to be_a(DatastaxRails::Types::DynamicSet)
       end
     end
   end