whi-cassie 1.1.1 → 1.2.0

data/spec/cassie/subscribers_spec.rb

@@ -1,38 +1,37 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Cassie::Subscribers do
-  
   it "should be able to add and remove a subscriber" do
     subscribers = Cassie::Subscribers.new
     expect(subscribers.empty?).to eq true
     data_1 = []
     data_2 = []
-    subscriber_1 = lambda{|info| data_1 << info}
-    subscriber_2 = lambda{|info| data_2 << info}
+    subscriber_1 = lambda { |info| data_1 << info }
+    subscriber_2 = lambda { |info| data_2 << info }
     subscribers.add(subscriber_1)
     subscribers << subscriber_2
     expect(subscribers.empty?).to eq false
     expect(subscribers.size).to eq 2
     expect(subscribers.include?(subscriber_1)).to eq true
     expect(subscribers.include?(subscriber_2)).to eq true
-    
-    subscribers.each{|s| s.call(:payload)}
+
+    subscribers.each { |s| s.call(:payload) }
     expect(data_1).to eq [:payload]
     expect(data_2).to eq [:payload]
-    
+
     subscribers.remove(subscriber_2)
     expect(subscribers.size).to eq 1
     expect(subscribers.include?(subscriber_1)).to eq true
     expect(subscribers.include?(subscriber_2)).to eq false
-    
-    subscribers.each{|s| s.call(:more)}
+
+    subscribers.each { |s| s.call(:more) }
     expect(data_1).to eq [:payload, :more]
     expect(data_2).to eq [:payload]
-    
+
     subscribers.delete(subscriber_1)
     expect(subscribers.size).to eq 0
   end
-  
+
   it "should have a hierarchy of subscribers" do
     subscribers_1 = Cassie::Subscribers.new
     subscribers_2 = Cassie::Subscribers.new(subscribers_1)
@@ -40,24 +39,23 @@ describe Cassie::Subscribers do
     data_1 = []
     data_2 = []
     data_3 = []
-    subscribers_1 << lambda{|info| data_1 << info}
-    subscribers_2 << lambda{|info| data_2 << info}
-    
+    subscribers_1 << lambda { |info| data_1 << info }
+    subscribers_2 << lambda { |info| data_2 << info }
+
     expect(subscribers_1.size).to eq 1
     expect(subscribers_2.size).to eq 2
     expect(subscribers_3.size).to eq 1
-    
-    subscribers_1.each{|subscriber| subscriber.call(:payload_1)}
-    subscribers_2.each{|subscriber| subscriber.call(:payload_2)}
-    subscribers_3.each{|subscriber| subscriber.call(:payload_3)}
-    
+
+    subscribers_1.each { |subscriber| subscriber.call(:payload_1) }
+    subscribers_2.each { |subscriber| subscriber.call(:payload_2) }
+    subscribers_3.each { |subscriber| subscriber.call(:payload_3) }
+
     expect(data_1).to eq [:payload_1, :payload_2, :payload_3]
     expect(data_2).to eq [:payload_2]
-    
+
     subscribers_2.clear
     expect(subscribers_2.size).to eq 1
     subscribers_1.clear
     expect(subscribers_2.size).to eq 0
   end
-  
 end

data/spec/cassie_spec.rb

@@ -1,208 +1,207 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Cassie do
-  
-  let(:instance){ Cassie.instance }
-  let(:table){ "cassie_specs.things" }
-  
+  let(:instance) { Cassie.instance }
+  let(:table) { "cassie_specs.things" }
+
   describe "prepare" do
     it "should keep a cache of prepared statements" do
       statement_1 = instance.prepare("SELECT * FROM #{table} LIMIT ?")
       statement_2 = instance.prepare("SELECT * FROM #{table} LIMIT ?")
-      statement_1.object_id.should == statement_2.object_id
+      expect(statement_1.object_id).to eq(statement_2.object_id)
     end
-    
+
     it "should clear the prepared statement cache when reconnecting" do
       statement_1 = instance.prepare("SELECT * FROM #{table} LIMIT ?")
       instance.disconnect
       instance.connect
       statement_2 = instance.prepare("SELECT * FROM #{table} LIMIT ?")
-      statement_1.object_id.should_not == statement_2.object_id
+      expect(statement_1.object_id).not_to eq(statement_2.object_id)
     end
   end
-  
+
   describe "find" do
     before :each do
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
-      instance.insert(table, :owner => 10, :id => 2, :val => 'bar')
+      instance.insert(table, owner: 1, id: 2, val: "foo")
+      instance.insert(table, owner: 10, id: 2, val: "bar")
     end
-    
+
     it "should construct a CQL query from the options" do
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = 1")
-      results.rows.collect{|r| r["val"]}.should == ['foo']
+      expect(results.rows.collect { |r| r["val"] }).to eq(["foo"])
     end
-    
+
     it "should construct a CQL query from a statement with variables" do
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ? LIMIT ?", [10, 1])
-      results.rows.collect{|r| r["val"]}.should == ['bar']
+      expect(results.rows.collect { |r| r["val"] }).to eq(["bar"])
     end
-    
+
     it "should not batch find statements" do
       instance.batch do
         results = instance.find("SELECT  owner, id, val FROM #{table} WHERE owner = ? LIMIT ?", [10, 1])
-        results.rows.collect{|r| r["val"]}.should == ['bar']
+        expect(results.rows.collect { |r| r["val"] }).to eq(["bar"])
       end
     end
   end
-  
+
   describe "insert" do
     it "should insert a row from a hash of values" do
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-      results.size.should == 0
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
+      expect(results.size).to eq(0)
+      instance.insert(table, owner: 1, id: 2, val: "foo")
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-      results.rows.collect{|r| r['val']}.should == ['foo']
+      expect(results.rows.collect { |r| r["val"] }).to eq(["foo"])
     end
-    
+
     it "should add statements to the current batch" do
       instance.batch do
-        instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
+        instance.insert(table, owner: 1, id: 2, val: "foo")
         results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-        results.size.should == 0
+        expect(results.size).to eq(0)
       end
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-      results.size.should == 1
+      expect(results.size).to eq(1)
     end
   end
-  
+
   describe "update" do
     it "should update a row from a hash of values and a primary key" do
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
-      instance.update(table, {:val => 'bar'}, :owner => 1, :id => 2)
+      instance.insert(table, owner: 1, id: 2, val: "foo")
+      instance.update(table, {val: "bar"}, owner: 1, id: 2)
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-      results.rows.collect{|r| r["val"]}.should == ['bar']
+      expect(results.rows.collect { |r| r["val"] }).to eq(["bar"])
     end
 
     it "should add statements to the current batch" do
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
+      instance.insert(table, owner: 1, id: 2, val: "foo")
       instance.batch do
-        instance.update(table, {:val => 'bar'}, :owner => 1, :id => 2)
+        instance.update(table, {val: "bar"}, owner: 1, id: 2)
         results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-        results.rows.collect{|r| r['val']}.should == ['foo']
+        expect(results.rows.collect { |r| r["val"] }).to eq(["foo"])
       end
       results = instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1)
-      results.rows.collect{|r| r['val']}.should == ['bar']
+      expect(results.rows.collect { |r| r["val"] }).to eq(["bar"])
     end
   end
-  
+
   describe "delete" do
     it "should update a row from a primary key hash" do
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
-      instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size.should == 1
-      instance.delete(table, :owner => 1)
-      instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size.should == 0
+      instance.insert(table, owner: 1, id: 2, val: "foo")
+      expect(instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size).to eq(1)
+      instance.delete(table, owner: 1)
+      expect(instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size).to eq(0)
     end
 
     it "should add statements to the current batch" do
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
+      instance.insert(table, owner: 1, id: 2, val: "foo")
       instance.batch do
-        instance.delete(table, :owner => 1)
-        instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size.should == 1
+        instance.delete(table, owner: 1)
+        expect(instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size).to eq(1)
       end
-      instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size.should == 0
+      expect(instance.find("SELECT owner, id, val FROM #{table} WHERE owner = ?", 1).size).to eq(0)
     end
   end
-  
+
   describe "execute" do
     before :each do
-      instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
+      instance.insert(table, owner: 1, id: 2, val: "foo")
     end
-    
+
     it "should execute a plain CQL statement" do
-      instance.execute("SELECT owner, id, val FROM #{table} WHERE owner = 1").size.should == 1
+      expect(instance.execute("SELECT owner, id, val FROM #{table} WHERE owner = 1").size).to eq(1)
     end
-    
+
     it "should execute a prepared statement" do
       statement = instance.prepare("SELECT owner, id, val FROM #{table} WHERE owner = 1")
-      instance.execute(statement).size.should == 1
+      expect(instance.execute(statement).size).to eq(1)
     end
-    
+
     it "should prepare and execute a CQL statement when values are provided" do
-      instance.execute("SELECT owner, id, val FROM #{table} WHERE owner = ?", [1]).size.should == 1
+      expect(instance.execute("SELECT owner, id, val FROM #{table} WHERE owner = ?", [1]).size).to eq(1)
     end
-    
+
     it "should call subscribers with details about the call" do
       instance.subscribers.clear
       begin
         messages = []
-        instance.subscribers << lambda{|details| messages << details}
+        instance.subscribers << lambda { |details| messages << details }
 
         instance.execute("SELECT owner, id, val FROM #{table} WHERE owner = ?", [1])
-        messages.size.should == 1
+        expect(messages.size).to eq(1)
         message = messages.shift
-        message.statement.should be_a(Cassandra::Statement)
-        message.options.should == {:arguments => [1], :consistency => :local_one}
-        message.elapsed_time.should be_a(Float)
+        expect(message.statement).to be_a(Cassandra::Statement)
+        expect(message.options).to eq({arguments: [1], consistency: :local_one})
+        expect(message.elapsed_time).to be_a(Float)
 
         instance.execute("SELECT owner, id, val FROM #{table} WHERE owner = 1")
-        messages.size.should == 1
+        expect(messages.size).to eq(1)
         message = messages.shift
-        message.statement.should be_a(Cassandra::Statement)
-        message.options.should == {:consistency => :local_one}
-        message.elapsed_time.should be_a(Float)
+        expect(message.statement).to be_a(Cassandra::Statement)
+        expect(message.options).to eq({consistency: :local_one})
+        expect(message.elapsed_time).to be_a(Float)
 
         instance.batch do
-          instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
-          instance.delete(table, :owner => 1)
+          instance.insert(table, owner: 1, id: 2, val: "foo")
+          instance.delete(table, owner: 1)
         end
-        messages.size.should == 1
+        expect(messages.size).to eq(1)
         message = messages.shift
-        message.statement.should be_a(Cassandra::Statements::Batch)
-        message.options.should == {:consistency => :local_one}
-        message.elapsed_time.should be_a(Float)
+        expect(message.statement).to be_a(Cassandra::Statements::Batch)
+        expect(message.options).to eq({consistency: :local_one})
+        expect(message.elapsed_time).to be_a(Float)
       ensure
         instance.subscribers.clear
       end
     end
   end
-  
+
   describe "consistency" do
-    let(:session){ instance.send(:session) }
-    
+    let(:session) { instance.send(:session) }
+
     it "should not specify query consistency by default" do
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {:consistency => :local_one})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {consistency: :local_one})
       instance.execute("SELECT * FROM dual")
       expect(instance.current_consistency).to eq :local_one
     end
-    
+
     it "should allow specifying the consistency in a block" do
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {:consistency => :one})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {consistency: :one})
       Cassie.consistency(:one) do
         instance.execute("SELECT * FROM dual")
         expect(instance.current_consistency).to eq :one
       end
     end
-    
+
     it "should allow specifying the consistency in a block if statement consistency is explicitly nil" do
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {:consistency => :one})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {consistency: :one})
       Cassie.consistency(:one) do
-        instance.execute("SELECT * FROM dual", nil, :consistency => nil)
+        instance.execute("SELECT * FROM dual", nil, consistency: nil)
         expect(instance.current_consistency).to eq :one
       end
     end
-    
+
     it "should use the consistency specified to execute if provided" do
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {:consistency => :two})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {consistency: :two})
       Cassie.consistency(:one) do
-        instance.execute("SELECT * FROM dual", nil, :consistency => :two)
+        instance.execute("SELECT * FROM dual", nil, consistency: :two)
         expect(instance.current_consistency).to eq :one
       end
     end
-    
+
     it "should use the consistency passed in the batch for all statements in the batch" do
-      expect(session).to receive(:execute).with(an_instance_of(Cassandra::Statements::Batch::Logged), {:consistency => :two})
-      Cassie.instance.batch(:consistency => :two) do
-        instance.insert(table, :owner => 1, :id => 2, :val => 'foo')
+      expect(session).to receive(:execute).with(an_instance_of(Cassandra::Statements::Batch::Logged), {consistency: :two})
+      Cassie.instance.batch(consistency: :two) do
+        instance.insert(table, owner: 1, id: 2, val: "foo")
       end
     end
-    
+
     it "should be able to specify a global consistancy" do
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {:consistency => :one})
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT COUNT(*) FROM dual"), {:consistency => :local_quorum})
-      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT COUNT(1) FROM dual"), {:consistency => :local_one})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT * FROM dual"), {consistency: :one})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT COUNT(*) FROM dual"), {consistency: :local_quorum})
+      expect(session).to receive(:execute).with(Cassandra::Statements::Simple.new("SELECT COUNT(1) FROM dual"), {consistency: :local_one})
       instance.execute("SELECT COUNT(1) FROM dual", nil)
       expect(instance.current_consistency).to eq :local_one
-      
+
       begin
         instance.consistency = :local_quorum
         expect(instance.current_consistency).to eq :local_quorum

data/spec/models/thing.rb

@@ -1,36 +1,36 @@
 class Cassie::Thing
   include Cassie::Model
-  
+
   self.table_name = "things"
   self.keyspace = "test"
   self.primary_key = [:owner, :id]
   self.read_consistency = :one
   self.write_consistency = :quorum
-  
+
   column :owner, :int
-  column :id, :int, :as => :identifier
-  column :val, :varchar, :as => :value
-  
+  column :id, :int, as: :identifier
+  column :val, :varchar, as: :value
+
   ordering_key :id, :desc
-  
+
   validates_presence_of :owner, :id
-  
+
   before_save do
     callbacks << :save
   end
-  
+
   before_create do
     callbacks << :create
   end
-  
+
   before_update do
     callbacks << :update
   end
-  
+
   before_destroy do
     callbacks << :destroy
   end
-  
+
   def callbacks
     @callbacks ||= []
   end

data/spec/models/type_tester.rb

@@ -1,12 +1,12 @@
-require 'securerandom'
+require "securerandom"
 
 class Cassie::TypeTester
   include Cassie::Model
-  
+
   self.table_name = "type_testers"
   self.keyspace = "test"
   self.primary_key = [:id]
-  
+
   column :id, :varchar
   column :int_value, :int
   column :varint_value, :varint
@@ -26,17 +26,17 @@ class Cassie::TypeTester
   column :list_value, :list
   column :set_value, :set
   column :map_value, :map
-  
-  before_create{ self.id = SecureRandom.uuid }
+
+  before_create { self.id = SecureRandom.uuid }
 end
 
 class Cassie::TypeTesterCounter
   include Cassie::Model
-  
+
   self.table_name = "type_tester_counters"
   self.keyspace = "test"
   self.primary_key = [:id]
-  
+
   column :id, :varchar
   column :counter_value, :counter, as: :counter_column
 end