datastax_rails 2.0.12 → 2.0.15

data/spec/datastax_rails/relation/spawn_methods_spec.rb

@@ -2,27 +2,27 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
   end
-  
-  describe "#merge" do
-    it "should merge two relations" do
-      r1 = @relation.where("name" => "biking")
-      r2 = @relation.order("name" => :desc)
-      r1.merge(r2).should == @relation.where("name" => "biking").order("name" => :desc)
+
+  describe '#merge' do
+    it 'should merge two relations' do
+      r1 = @relation.where('name' => 'biking')
+      r2 = @relation.order('name' => :desc)
+      expect(r1.merge(r2)).to eq(@relation.where('name' => 'biking').order('name' => :desc))
     end
-    
-    it "should merge where conditions into a single hash" do
-      r1 = @relation.where("name" => "biking")
-      r2 = @relation.where("complexity" => 1.0)
-      r1.merge(r2).where_values.should == [{"name" => "biking", "complexity" => 1.0}]
+
+    it 'should merge where conditions into a single hash' do
+      r1 = @relation.where('name' => 'biking')
+      r2 = @relation.where('complexity' => 1.0)
+      expect(r1.merge(r2).where_values).to eq([{ 'name' => 'biking', 'complexity' => 1.0 }])
     end
-    
-    it "should overwrite conditions on the same attribute" do
-      r1 = @relation.where("name" => "biking")
-      r2 = @relation.where("name" => "swimming")
-      r1.merge(r2).where_values.should == [{"name" => "swimming"}]
-      r2.merge(r1).where_values.should == [{"name" => "biking"}]
+
+    it 'should overwrite conditions on the same attribute' do
+      r1 = @relation.where('name' => 'biking')
+      r2 = @relation.where('name' => 'swimming')
+      expect(r1.merge(r2).where_values).to eq([{ 'name' => 'swimming' }])
+      expect(r2.merge(r1).where_values).to eq([{ 'name' => 'biking' }])
     end
   end
 end

data/spec/datastax_rails/relation_spec.rb

@@ -2,175 +2,178 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
     @relation.default_scoped = true
     @relation.commit_solr
   end
-  
-  describe "#==" do
-    it "should count two relations with the same parameters as equal" do
-      @relation.where("name" => "jason").should == @relation.where("name" => "jason")
+
+  describe '#==' do
+    it 'should count two relations with the same parameters as equal' do
+      expect(@relation.where('name' => 'jason')).to eq(@relation.where('name' => 'jason'))
     end
   end
-  
-  describe "#any?" do
-    it "should return true if there are records" do
-      Hobby.create(:name => "fishing")
+
+  describe '#any?' do
+    it 'should return true if there are records' do
+      Hobby.create(name: 'fishing')
       @relation.commit_solr
-      @relation.any?.should be_true
+      expect(@relation.any?).to be_truthy
     end
-    
-    it "should return false if there are no records" do
-      @relation.any?.should be_false
+
+    it 'should return false if there are no records' do
+      expect(@relation.any?).to be_falsey
     end
   end
-  
-  describe "#count" do
-    it "should use the cached count if it is available" do
+
+  describe '#count' do
+    it 'should use the cached count if it is available' do
       @relation.instance_variable_set(:@count, 42)
-      @relation.count.should == 42
+      expect(@relation.count).to eq(42)
     end
-    
-    it "should cache the total count on any solr query" do
+
+    it 'should cache the total count on any solr query' do
       @relation = @relation.with_solr
-      @relation.should_receive(:query_via_solr).and_return(double("ResultSet", :total_entries => 42))
+      expect(@relation).to receive(:query_via_solr).and_return(double('ResultSet', total_entries: 42))
       @relation.all
-      @relation.count.should == 42
+      expect(@relation.count).to eq(42)
     end
-    
-    it "should execute a fast search to determine the count" do
+
+    it 'should execute a fast search to determine the count' do
       mock_relation = double(DatastaxRails::Relation)
-      mock_relation.stub_chain(:select, :to_a, :total_entries).and_return(37)
+      allow(mock_relation).to receive_message_chain(:select, :to_a, :total_entries).and_return(37)
       @relation = @relation.with_solr
-      @relation.should_receive(:limit).with(1).and_return(mock_relation)
-      @relation.count.should == 37
-    end
-    
-    it "should return the count regardless of limit" do
-      Hobby.create(:name => "hiking")
-      Hobby.create(:name => "boxing")
-      Hobby.create(:name => "fishing")
-      Hobby.create(:name => "running")
+      expect(@relation).to receive(:limit).with(1).and_return(mock_relation)
+      expect(@relation.count).to eq(37)
+    end
+
+    it 'should return the count regardless of limit' do
+      Hobby.create(name: 'hiking')
+      Hobby.create(name: 'boxing')
+      Hobby.create(name: 'fishing')
+      Hobby.create(name: 'running')
       @relation.commit_solr
-      @relation.count.should == 4
-      
-      @relation.limit(2).count.should == 4
+      expect(@relation.count).to eq(4)
+
+      expect(@relation.limit(2).count).to eq(4)
     end
   end
-  
-  describe "#default_scope" do
-    it "should return a relation that has no scope set" do
-      Hobby.create(:name => "fishing")
+
+  describe '#default_scope' do
+    it 'should return a relation that has no scope set' do
+      Hobby.create(name: 'fishing')
       @relation.commit_solr
-      relation = @relation.where("name" => "hiking")
-      relation.count.should == 0
-      relation.default_scope.count.should == 1
+      relation = @relation.where('name' => 'hiking')
+      expect(relation.count).to eq(0)
+      expect(relation.default_scope.count).to eq(1)
     end
-    
-    it "should return a relation that has a default scope set" do
-      relation = DatastaxRails::Relation.new(Boat, "boats")
+
+    it 'should return a relation that has a default scope set' do
+      relation = DatastaxRails::Relation.new(Boat, 'boats')
       relation.default_scoped = true
-      relation.default_scope.order_values.should_not be_empty
+      expect(relation.default_scope.order_values).not_to be_empty
     end
   end
-  
-  describe "#empty?" do
-    it "should use the loaded result set to determine emptiness" do
-      a_record = mock_model(Hobby)
-      @relation.stub(:loaded? => true)
+
+  describe '#empty?' do
+    it 'should use the loaded result set to determine emptiness' do
+      a_record = build_stubbed(:hobby)
+      allow(@relation).to receive(:loaded?).and_return(true)
       @relation.instance_variable_set(:@results, [])
-      @relation.should be_empty
+      expect(@relation).to be_empty
       @relation.instance_variable_set(:@results, [a_record])
-      @relation.should_not be_empty
+      expect(@relation).not_to be_empty
     end
   end
-  
-  describe "#many?" do
-    it "should return true if there are multiple records matching" do
-      Hobby.create(:name => "hiking")
-      Hobby.create(:name => "swimming")
+
+  describe '#many?' do
+    it 'should return true if there are multiple records matching' do
+      Hobby.create(name: 'hiking')
+      Hobby.create(name: 'swimming')
       @relation.commit_solr
-      @relation.should be_many
+      expect(@relation).to be_many
     end
-    
-    it "should return false if there are zero or one records matching" do
-      @relation.should_not be_many
-      Hobby.create(:name => "hiking")
-      @relation.should_not be_many
+
+    it 'should return false if there are zero or one records matching' do
+      expect(@relation).not_to be_many
+      Hobby.create(name: 'hiking')
+      expect(@relation).not_to be_many
     end
   end
-  
-  describe "#new" do
-    it "should instantiate a new instance of the class" do
-      hiking = @relation.new(:name => "hiking")
-      hiking.should be_a_kind_of(Hobby)
-      hiking.name.should == "hiking"
+
+  describe '#new' do
+    it 'should instantiate a new instance of the class' do
+      hiking = @relation.new(name: 'hiking')
+      expect(hiking).to be_a_kind_of(Hobby)
+      expect(hiking.name).to eq('hiking')
     end
   end
-  
-  describe "#reload" do
-    it "should reload the results" do
-      @relation.all.should be_empty
-      Hobby.create(:name => "hiking")
+
+  describe '#reload' do
+    it 'should reload the results' do
+      expect(@relation.all).to be_empty
+      Hobby.create(name: 'hiking')
       @relation.commit_solr
-      @relation.all.should be_empty
-      @relation.reload.all.should_not be_empty
+      expect(@relation.all).to be_empty
+      expect(@relation.reload.all).not_to be_empty
     end
   end
-  
-  describe "#size" do
-    it "should return the size of the current result set (including limit setting)" do
-      Hobby.create(:name => "hiking")
-      Hobby.create(:name => "boxing")
-      Hobby.create(:name => "fishing")
-      Hobby.create(:name => "running")
+
+  describe '#size' do
+    it 'should return the size of the current result set (including limit setting)' do
+      Hobby.create(name: 'hiking')
+      Hobby.create(name: 'boxing')
+      Hobby.create(name: 'fishing')
+      Hobby.create(name: 'running')
       @relation.commit_solr
-      @relation.size.should == 4
-      @relation.limit(2).size.should == 2
+      expect(@relation.size).to eq(4)
+      expect(@relation.limit(2).size).to eq(2)
     end
   end
-  
-  describe "#total_pages" do
-    it "should calculate the total number of pages for will_paginate" do
+
+  describe '#total_pages' do
+    it 'should calculate the total number of pages for will_paginate' do
       relation = @relation.per_page(30)
-      relation.stub(:count => 100)
-      relation.total_pages.should == 4
+      allow(relation).to receive(:count).and_return(100)
+      expect(relation.total_pages).to eq(4)
     end
   end
-  
-  describe "grouped queries" do
+
+  describe 'grouped queries' do
     before(:each) do
       Person.commit_solr
-      Person.create(:name => 'John', :nickname => 'J')
-      Person.create(:name => 'Jason', :nickname => 'J')
-      Person.create(:name => 'James', :nickname => 'J')
-      Person.create(:name => 'Kathrine', :nickname => 'Kat')
-      Person.create(:name => 'Kathy', :nickname => 'Kat')
-      Person.create(:name => 'Steven', :nickname => 'Steve')
+      Person.create(name: 'John', nickname: 'J')
+      Person.create(name: 'Jason', nickname: 'J')
+      Person.create(name: 'James', nickname: 'J')
+      Person.create(name: 'Kathrine', nickname: 'Kat')
+      Person.create(name: 'Kathy', nickname: 'Kat')
+      Person.create(name: 'Steven', nickname: 'Steve')
       Person.commit_solr
     end
-    
-    it "should return matching documents grouped by an attribute" do
+
+    it 'should return matching documents grouped by an attribute' do
       results = Person.group(:nickname).all
-      results['j'].should have(3).items
-      results['kat'].should have(2).items
-      results['steve'].should have(1).item
+      expect(results['j'].size).to eq(3)
+      expect(results['kat'].size).to eq(2)
+      expect(results['steve'].size).to eq(1)
     end
-    
-    it "should return total_entries as the highest value of any group" do
+
+    it 'should return total_entries as the highest value of any group' do
       results = Person.group(:nickname).all
-      results.total_entries.should eq(3)
+      expect(results.total_entries).to eq(3)
     end
-    
-    it "should still return a total count when using the count method" do
-      results = Person.group(:nickname).count.should eq(6)
+
+    it 'should still return a total count when using the count method' do
+      expect(Person.group(:nickname).count).to eq(6)
     end
   end
-  
-  describe "#downcase_query" do
-    it "downcases a solr query while leaving operators untouched" do
-      solr_query = "This Query needs to be DOWNCASED AND it also searches DATES [2010-09-09T10:42:12Z TO 2011-08-08T09:23:34Z] OR maybe it just breaks"
-      expect(@relation.downcase_query(solr_query)).to eq("this query needs to be downcased AND it also searches dates [2010-09-09T10:42:12Z TO 2011-08-08T09:23:34Z] OR maybe it just breaks")
+
+  describe '#downcase_query' do
+    it 'downcases a solr query while leaving operators untouched' do
+      solr_query = 'This Query needs to be DOWNCASED AND it also searches DATES ' \
+                   '[2010-09-09T10:42:12Z TO 2011-08-08T09:23:34Z] OR maybe it just breaks'
+      expect(@relation.downcase_query(solr_query)).to eq('this query needs to be downcased AND it also searches ' \
+                                                         'dates [2010-09-09T10:42:12Z TO 2011-08-08T09:23:34Z] ' \
+                                                         'OR maybe it just breaks')
     end
   end
 end

data/spec/datastax_rails/schema/migrator_spec.rb

@@ -2,83 +2,83 @@ require 'spec_helper'
 
 describe DatastaxRails::Schema::Migrator do
   subject do
-    DatastaxRails::Schema::Migrator.new('datastax_rails_test').tap{|m| m.verbose = false}
+    DatastaxRails::Schema::Migrator.new('datastax_rails_test').tap { |m| m.verbose = false }
   end
 
   describe 'payload models' do
     context 'when column family exists' do
       before(:each) do
-        subject.stub(:column_family_exists?).and_return(false)
+        allow(subject).to receive(:column_family_exists?).and_return(false)
       end
-      
-      it "calls #create_payload_column_family" do
+
+      it 'calls #create_payload_column_family' do
         expect(subject).to receive(:create_cql3_column_family).with(CarPayload)
         subject.migrate_one(CarPayload)
       end
     end
-    
+
     context 'when column family exists' do
       before(:each) do
-        subject.stub(:column_family_exists?).and_return(true)
+        allow(subject).to receive(:column_family_exists?).and_return(true)
       end
-      
-      it "does not call #create_payload_column_family" do
+
+      it 'does not call #create_payload_column_family' do
         expect(subject).not_to receive(:create_cql2_column_family).with(CarPayload)
         subject.migrate_one(CarPayload)
       end
     end
   end
-  
+
   describe 'wide storage models' do
     context 'when column family does not exist' do
       before(:each) do
-        subject.stub(:column_family_exists?).and_return(false)
-        subject.stub(:create_cql3_column_family)
+        allow(subject).to receive(:column_family_exists?).and_return(false)
+        allow(subject).to receive(:create_cql3_column_family)
       end
-      
-      it "calls #create_wide_storage_column_family" do
+
+      it 'calls #create_wide_storage_column_family' do
         expect(subject).to receive(:create_cql3_column_family).with(AuditLog)
         subject.migrate_one(AuditLog)
       end
-      
-      it "calls #check_missing_schema" do
+
+      it 'calls #check_missing_schema' do
         expect(subject).to receive(:check_missing_schema).with(AuditLog).and_return(0)
         subject.migrate_one(AuditLog)
       end
     end
-    
+
     context 'when column family exists' do
       before(:each) do
-        subject.stub(:column_family_exists?).and_return(true)
+        allow(subject).to receive(:column_family_exists?).and_return(true)
       end
-      
-      it "does not call #create_wide_storage_column_family" do
+
+      it 'does not call #create_wide_storage_column_family' do
         expect(subject).not_to receive(:create_cql3_column_family).with(AuditLog)
         subject.migrate_one(AuditLog)
       end
-      
-      it "calls #check_missing_schema" do
+
+      it 'calls #check_missing_schema' do
         expect(subject).to receive(:check_missing_schema).with(AuditLog).and_return(0)
         subject.migrate_one(AuditLog)
       end
     end
   end
-  
-  describe 'normal models' do 
-    it "calls #check_missing_schema" do
+
+  describe 'normal models' do
+    it 'calls #check_missing_schema' do
       expect(subject).to receive(:check_missing_schema).with(Person).and_return(0)
       subject.migrate_one(Person)
     end
-    
-    context "force mode on" do
-      it "calls #upload_solr_configuation with force true" do
+
+    context 'force mode on' do
+      it 'calls #upload_solr_configuation with force true' do
         expect(subject).to receive(:upload_solr_configuration).with(Person, true).and_return(0)
         subject.migrate_one(Person, true)
       end
     end
-    
-    context "force mode off" do
-      it "calls #upload_solr_configuation with force false" do
+
+    context 'force mode off' do
+      it 'calls #upload_solr_configuation with force false' do
         expect(subject).to receive(:upload_solr_configuration).with(Person, false).and_return(0)
         subject.migrate_one(Person, false)
       end