datastax_rails 2.0.12 → 2.0.15

data/spec/datastax_rails/connection/statement_cache_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe DatastaxRails::Base do
-  it "clears the statement cache when a new connection is established" do
-    DatastaxRails::Base.statement_cache[:a] = 12345
+  it 'clears the statement cache when a new connection is established' do
+    DatastaxRails::Base.statement_cache[:a] = 12_345
     DatastaxRails::Base.establish_connection(DatastaxRails::Base.config)
     expect(DatastaxRails::Base.statement_cache).to be_empty
   end

data/spec/datastax_rails/cql/base_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe DatastaxRails::Cql::Base do
-  it "caches prepared statements" do
-    DatastaxRails::Base.connection.should_receive(:prepare).once.and_return(double("statement", :execute => true))
+  it 'caches prepared statements' do
+    expect(DatastaxRails::Base.connection).to receive(:prepare).once.and_return(double('statement', execute: true))
     cql = DatastaxRails::Cql::ColumnFamily.new(Person)
-    cql.select(['*']).conditions(:name => 'John').execute
-    cql.select(['*']).conditions(:name => 'John').execute
+    cql.select(['*']).conditions(name: 'John').execute
+    cql.select(['*']).conditions(name: 'John').execute
   end
 end

data/spec/datastax_rails/cql/delete_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe DatastaxRails::Cql::Delete do
+  context 'with single primary key' do
+    it 'should generate valid CQL' do
+      cql = DatastaxRails::Cql::Delete.new(Person, id: '12345')
+      expect(cql.to_cql).to match(/DELETE\s+FROM people WHERE "id" = \?/)
+      expect(cql.instance_variable_get(:@values)).to eq(['12345'])
+    end
+  end
+
+  context 'with compound primary key' do
+    it 'should generate valid CQL' do
+      cql = DatastaxRails::Cql::Delete.new(CoreMetadata, id: '12345', group: 'core')
+      expect(cql.to_cql).to match(/DELETE\s+FROM dynamic_model WHERE "id" = \? AND "group" = \?/)
+      expect(cql.instance_variable_get(:@values)).to eq(%w(12345 core))
+    end
+  end
+end

data/spec/datastax_rails/cql/select_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe DatastaxRails::Cql::Select do
-  let(:model_class) { double("Model Class", :column_family => 'users', :default_consistency => DatastaxRails::Cql::Consistency::QUORUM) }
-  
-  it "should generate valid CQL" do
-    cql = DatastaxRails::Cql::Select.new(model_class, ["*"])
-    cql.using(DatastaxRails::Cql::Consistency::QUORUM).conditions(:key => '12345').limit(1)
-    cql.to_cql.should == "SELECT * FROM users WHERE \"key\" = ? LIMIT 1 "
+  let(:model_class) { double('Model Class', column_family: 'users', default_consistency: DatastaxRails::Cql::Consistency::QUORUM) }
+
+  it 'should generate valid CQL' do
+    cql = DatastaxRails::Cql::Select.new(model_class, ['*'])
+    cql.using(DatastaxRails::Cql::Consistency::QUORUM).conditions(key: '12345').limit(1)
+    expect(cql.to_cql).to eq("SELECT * FROM users WHERE \"key\" = ? LIMIT 1 ")
   end
-  
-  it_has_behavior "default_consistency"
+
+  it_has_behavior 'default_consistency'
 end

data/spec/datastax_rails/cql/update_spec.rb

@@ -1,15 +1,13 @@
 require 'spec_helper'
 
 describe DatastaxRails::Cql::Update do
-  before(:each) do
-    @model_class = double("Model Class", :column_family => 'users', :default_consistency => DatastaxRails::Cql::Consistency::QUORUM, :primary_key => 'id')
-  end
-  
-  it "should generate valid CQL" do
-    cql = DatastaxRails::Cql::Update.new(@model_class, 'id' => "12345")
-    cql.using(DatastaxRails::Cql::Consistency::QUORUM).columns(:name => 'John', :age => '23')
-    cql.to_cql.should match(/update users SET ("name" = \?, "age" = \?|"age" = \?, "name" = \?) WHERE "id" = \?/)
+  let(:model_class) { double('Model Class', column_family: 'users', default_consistency: DatastaxRails::Cql::Consistency::QUORUM, primary_key: 'id') }
+
+  it 'should generate valid CQL' do
+    cql = DatastaxRails::Cql::Update.new(model_class, 'id' => '12345')
+    cql.using(DatastaxRails::Cql::Consistency::QUORUM).columns(name: 'John', age: '23')
+    expect(cql.to_cql).to match(/update users SET ("name" = \?, "age" = \?|"age" = \?, "name" = \?) WHERE "id" = \?/)
   end
-  
-  it_has_behavior "default_consistency"
+
+  it_has_behavior 'default_consistency'
 end

data/spec/datastax_rails/dynamic_model_spec.rb

@@ -8,43 +8,57 @@ end
 
 class DynamicTestModel2 < DatastaxRails::DynamicModel
   self.grouping = 'test2'
+  integer :age
 end
 
 describe DatastaxRails::DynamicModel do
-  let(:one) {DynamicTestModel1.new}
-  let(:two) {DynamicTestModel2.new}
-  
-  it {expect(one).to respond_to(:created_at)}
-  it {expect(one).to respond_to(:created_at=)}
-  it {expect(two).not_to respond_to(:created_at)}
-  it {expect(two).not_to respond_to(:created_at=)}
-  
-  it "sets the attribute in the dynamic collection" do
+  let(:one) { DynamicTestModel1.new }
+  let(:two) { DynamicTestModel2.new }
+
+  it { expect(one).to respond_to(:created_at) }
+  it { expect(one).to respond_to(:created_at=) }
+  it { expect(two).not_to respond_to(:created_at) }
+  it { expect(two).not_to respond_to(:created_at=) }
+
+  it 'sets the attribute in the dynamic collection' do
     one.name = 'John'
     expect(one.s_).to eq('s_name' => 'John')
   end
-  
-  it "retrieves the attribute from the dynamic collection" do
+
+  it 'deletes a dynamic record' do
+    one.name = 'John'
+    one.save
+    two.age = 27
+    two.id = one.id # Make sure they're in the same C* row
+    two.save
+    one.destroy
+    DynamicTestModel1.commit_solr
+    expect(DynamicTestModel1.count).to be(0)
+    DynamicTestModel2.commit_solr
+    expect(DynamicTestModel2.count).to be(1)
+  end
+
+  it 'retrieves the attribute from the dynamic collection' do
     one.strings[:name] = 'John'
     expect(one.name).to eq('John')
   end
-  
-  it "updates an existing attribute" do
+
+  it 'updates an existing attribute' do
     one.save
     one.name = 'Jim'
-    expect(one.save).to be_true
+    expect(one.save).to be_truthy
   end
-  
-  describe "#solr_field_name" do
-    it "maps a attribute name to the underlying storage key" do
+
+  describe '#solr_field_name' do
+    it 'maps a attribute name to the underlying storage key' do
       expect(one.solr_field_name(:name)).to eq('s_name')
     end
-    
-    it "raises DatastaxRails::UnknownAttributeError if an unknown attribute is mapped without a type" do
-      expect{two.solr_field_name(:name)}.to raise_exception(DatastaxRails::UnknownAttributeError)
+
+    it 'raises DatastaxRails::UnknownAttributeError if an unknown attribute is mapped without a type' do
+      expect { two.solr_field_name(:name) }.to raise_exception(DatastaxRails::UnknownAttributeError)
     end
-    
-    it "maps an undeclared attribute if a type is given" do
+
+    it 'maps an undeclared attribute if a type is given' do
       expect(one.solr_field_name(:birthdate, :date)).to eq('d_birthdate')
     end
   end

data/spec/datastax_rails/inheritance_spec.rb

@@ -5,36 +5,33 @@ class InheritanceTesterBase < DatastaxRails::Base
 end
 
 class InheritanceTesterChild < InheritanceTesterBase
-  
 end
 
 class InheritanceTesterGrandChild < InheritanceTesterChild
-  
 end
 
 class InheritanceTesterNonAbstract < DatastaxRails::Base
-  
 end
 
 describe DatastaxRails::Base do
-  context "Inheritance" do
-    it "raises NotImplementedError if DatastaxRails::Base is instantiated" do
+  context 'Inheritance' do
+    it 'raises NotImplementedError if DatastaxRails::Base is instantiated' do
       expect { DatastaxRails::Base.new }.to raise_error(NotImplementedError)
     end
-    
-    it "raises NotImplementedError if an abstract class is instantiated" do
+
+    it 'raises NotImplementedError if an abstract class is instantiated' do
       expect { InheritanceTesterBase.new }.to raise_error(NotImplementedError)
     end
-    
-    it "identifies the abstract class as base for direct decendants" do
+
+    it 'identifies the abstract class as base for direct decendants' do
       expect(InheritanceTesterChild.base_class).to eq(InheritanceTesterBase)
     end
-  
-    it "identifies the abstract class as base for its indirect decendants" do
+
+    it 'identifies the abstract class as base for its indirect decendants' do
       expect(InheritanceTesterGrandChild.base_class).to eq(InheritanceTesterBase)
-    end  
-    
-    it "identifies a child of DatastaxRails::Base as base" do
+    end
+
+    it 'identifies a child of DatastaxRails::Base as base' do
       expect(InheritanceTesterNonAbstract.base_class).to eq(InheritanceTesterNonAbstract)
     end
   end

data/spec/datastax_rails/persistence_spec.rb

@@ -1,110 +1,109 @@
 require 'spec_helper'
 
-describe "DatastaxRails::Base" do
-  describe "persistence" do
-    describe "#update_attributes" do
-      it "only overwrites attributes that are passed in as part of the hash" do
-        person = Person.create(:name => 'Jason', :birthdate => Date.parse("Oct 19, 1981"), :nickname => 'Jas')
-        person.birthdate = Date.parse("Oct 19, 1980")
-        person.update_attributes(:nickname => 'Jace')
-        person.birthdate.should eql(Date.parse("Oct 19, 1980"))
-        person.nickname.should eql('Jace')
+describe 'DatastaxRails::Base' do
+  describe 'persistence' do
+    describe '#update_attributes' do
+      it 'only overwrites attributes that are passed in as part of the hash' do
+        person = Person.create(name: 'Jason', birthdate: Date.parse('Oct 19, 1981'), nickname: 'Jas')
+        person.birthdate = Date.parse('Oct 19, 1980')
+        person.update_attributes(nickname: 'Jace')
+        expect(person.birthdate).to eql(Date.parse('Oct 19, 1980'))
+        expect(person.nickname).to eql('Jace')
       end
     end
-    
-    describe "with cql" do
+
+    describe 'with cql' do
       before(:each) do
         Person.storage_method = :cql
-        @statement = double("prepared statement")
-        DatastaxRails::Base.connection.stub(:prepare).and_return(@statement)
+        @statement = double('prepared statement')
+        allow(DatastaxRails::Base.connection).to receive(:prepare).and_return(@statement)
       end
-      
-      describe "#create" do
-        it "should persist at the given consistency level" do
-          @statement.should_receive(:execute) do |*args|
-            expect(args.last).to include(:consistency => :local_quorum)
+
+      describe '#create' do
+        it 'should persist at the given consistency level' do
+          expect(@statement).to receive(:execute) do |*args|
+            expect(args.last).to include(consistency: :local_quorum)
           end
-          Person.create({:name => 'Steven'},{:consistency => 'LOCAL_QUORUM'})
+          Person.create({ name: 'Steven' }, { consistency: 'LOCAL_QUORUM' })
         end
       end
-    
-      describe "#save" do
-        it "should persist at the given consistency level" do
-          @statement.should_receive(:execute) do |*args|
-            expect(args.last).to include(:consistency => :local_quorum)
+
+      describe '#save' do
+        it 'should persist at the given consistency level' do
+          expect(@statement).to receive(:execute) do |*args|
+            expect(args.last).to include(consistency: :local_quorum)
           end
-          p=Person.new(:name => 'Steven')
-          p.save(:consistency => 'LOCAL_QUORUM')
+          p = Person.new(name: 'Steven')
+          p.save(consistency: 'LOCAL_QUORUM')
         end
       end
-      
-      describe "#remove" do
-        it "should remove at the given consistency level" do
-          @statement.stub(:execute)
-          p=Person.create(:name => 'Steven')
-          @statement.should_receive(:execute) do |*args|
-            expect(args.last).to include(:consistency => :local_quorum)
+
+      describe '#remove' do
+        it 'should remove at the given consistency level' do
+          allow(@statement).to receive(:execute)
+          p = Person.create(name: 'Steven')
+          expect(@statement).to receive(:execute) do |*args|
+            expect(args.last).to include(consistency: :local_quorum)
           end
-          p.destroy(:consistency => :local_quorum)
+          p.destroy(consistency: :local_quorum)
         end
       end
     end
 
-    describe "with solr" do
+    describe 'with solr' do
       around(:each) do |example|
         Person.storage_method = :solr
         example.run
         Person.storage_method = :cql
       end
-      
-      describe "#create" do
-        it "should persist at the given consistency level" do
-          Person.solr_connection.should_receive(:update).with(hash_including(:params => hash_including({:cl => 'LOCAL_QUORUM'}))).and_return(true)
-          Person.create({:name => 'Steven'},{:consistency => 'LOCAL_QUORUM'})
+
+      describe '#create' do
+        it 'should persist at the given consistency level' do
+          expect(Person.solr_connection).to receive(:update).with(hash_including(params: hash_including(cl: 'LOCAL_QUORUM'))).and_return(true)
+          Person.create({ name: 'Steven' }, { consistency: 'LOCAL_QUORUM' })
         end
       end
-    
-      describe "#save" do
-        it "should persist at the given consistency level" do
-          Person.solr_connection.should_receive(:update).with(hash_including(:params => hash_including({:cl => 'LOCAL_QUORUM'}))).and_return(true)
-          p=Person.new(:name => 'Steven')
-          p.save(:consistency => 'LOCAL_QUORUM')
+
+      describe '#save' do
+        it 'should persist at the given consistency level' do
+          expect(Person.solr_connection).to receive(:update).with(hash_including(params: hash_including(cl: 'LOCAL_QUORUM'))).and_return(true)
+          p = Person.new(name: 'Steven')
+          p.save(consistency: 'LOCAL_QUORUM')
         end
-        
-        it "should successfully remove columns that are set to nil" do
-          pending do 
-            p = Person.create!(:name => 'Steven', :birthdate => Date.today)
-            Person.commit_solr
-            p = Person.find_by_name('Steven')
-            p.birthdate = nil
-            p.save
-            Person.commit_solr
-            Person.find by_name('Steven').birthdate.should be_nil
-          end
+
+        it 'should successfully remove columns that are set to nil' do
+          skip
+          Person.create!(name: 'Steven', birthdate: Date.today)
+          Person.commit_solr
+          p = Person.find_by_name('Steven')
+          p.birthdate = nil
+          p.save
+          Person.commit_solr
+          Person.find by_name('Steven').birthdate.should be_nil
         end
       end
     end
-    
-    describe "#store_file" do
-      it "should store a file", :slow => true do
-        file = "abcd"*1.megabyte
-        CarPayload.create(:digest => 'limo', :payload => file)
-        CarPayload.find('limo').payload.should == file
+
+    describe '#store_file' do
+      it 'should store a file', slow: true do
+        file = 'abcd' * 1.megabyte
+        CarPayload.create(digest: 'limo', payload: file)
+        expect(CarPayload.find('limo').payload).to eq(file)
       end
-      
-      it "should store really large files", :slow => true do
-        file = IO.read("/dev/zero", 25.megabyte)
-        CarPayload.create(:digest => 'limo', :payload => file)
-        CarPayload.find('limo').payload.should == file
+
+      it 'should store really large files', slow: true do
+        file = IO.read('/dev/zero', 25.megabyte)
+        CarPayload.create(digest: 'limo', payload: file)
+        expect(CarPayload.find('limo').payload).to eq(file)
       end
-      
-      it "should successfully overwrite a larger file with a smaller one", :slow => true do
-        file = "abcd"*1.megabyte
-        car = CarPayload.create(:digest => 'limo', :payload => file)
-        smallfile = "e"*1.kilobyte
+
+      it 'should successfully overwrite a larger file with a smaller one', slow: true do
+        file = 'abcd' * 1.megabyte
+        car = CarPayload.create(digest: 'limo', payload: file)
+        smallfile = 'e' * 1.kilobyte
         car.payload = smallfile
         car.save
-        CarPayload.find('limo').payload.should == smallfile
+        expect(CarPayload.find('limo').payload).to eq(smallfile)
       end
     end
   end

data/spec/datastax_rails/relation/batches_spec.rb

@@ -2,34 +2,34 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
     ('a'..'l').each_with_index do |letter, idx|
-      Hobby.create(:name => letter)
+      Hobby.create(name: letter)
       sleep(1) if idx % 5 == 4 # Performance hack
     end
     Hobby.commit_solr
   end
-  
-  ['cassandra', 'solr'].each do |access_method|
-    describe "#find_each" do
+
+  %w(cassandra solr).each do |access_method|
+    describe '#find_each' do
       it "returns each record one at a time with #{access_method}" do
         sleep(1)
         missed_hobbies = ('a'..'l').to_a
-        @relation.send('with_'+access_method).find_each(:batch_size => 5) do |hobby|
-          missed_hobbies.delete_if {|h| h == hobby.name}
+        @relation.send('with_' + access_method).find_each(batch_size: 5) do |hobby|
+          missed_hobbies.delete_if { |h| h == hobby.name }
         end
-        missed_hobbies.should be_empty
+        expect(missed_hobbies).to be_empty
       end
     end
-    
-    describe "#find_in_batches" do
+
+    describe '#find_in_batches' do
       it "returns records in batches of the given size with #{access_method}" do
         count = 12
-        @relation.send('with_'+access_method).find_in_batches(:batch_size => 5) do |batch|
-          batch.size.should <= 5
+        @relation.send('with_' + access_method).find_in_batches(batch_size: 5) do |batch|
+          expect(batch.size).to be <= 5
           count -= batch.size
         end
-        count.should == 0
+        expect(count).to eq(0)
       end
     end
   end