whi-cassie 1.0.5 → 1.2.0

data/spec/cassie/subscribers_spec.rb

@@ -0,0 +1,61 @@
+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 }
+    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) }
+    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) }
+    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)
+    subscribers_3 = Cassie::Subscribers.new(subscribers_1)
+    data_1 = []
+    data_2 = []
+    data_3 = []
+    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) }
+
+    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,173 +1,218 @@
-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
+        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")
+        expect(messages.size).to eq(1)
         message = messages.shift
-        message.statement.should be_a(Cassandra::Statement)
-        message.options.should == {:arguments => [1]}
-        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 == nil
-        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("SELECT * FROM dual", {})
+      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("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})
+      Cassie.consistency(:one) do
+        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("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")
+      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})
+      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
+        instance.execute("SELECT COUNT(*) FROM dual", nil)
+        Cassie.consistency(:one) do
+          instance.execute("SELECT * FROM dual", nil)
+          expect(instance.current_consistency).to eq :one
+        end
+        expect(instance.current_consistency).to eq :local_quorum
+      ensure
+        instance.consistency = :local_one
       end
     end
   end

data/spec/models/thing.rb

@@ -1,34 +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

data/spec/spec_helper.rb

@@ -1,6 +1,11 @@
-require 'whi-cassie'
-require File.expand_path('../models/thing', __FILE__)
-require File.expand_path('../models/type_tester', __FILE__)
+require "rubygems"
+
+require "active_model"
+
+require_relative "../lib/whi-cassie"
+
+require_relative "models/thing"
+require_relative "models/type_tester"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
@@ -10,21 +15,41 @@ RSpec.configure do |config|
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
-  config.order = 'random'
-  
+  config.order = "random"
+
   config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
-  
+
+  cassandra_host, cassandra_port = ENV.fetch("CASSANDRA_HOST", "localhost").split(":", 2)
+  cassandra_port ||= 9042
   config.before(:suite) do
     schema_dir = File.expand_path("../schema", __FILE__)
-    Cassie.configure!(:cluster => {:host => 'localhost'}, :keyspaces => {"test" => "cassie_specs"}, :schema_directory => schema_dir, :max_prepared_statements => 3)
-    Cassie::Schema.load_all!
+    protocol_version = (ENV["protocol_version"] ? ENV["protocol_version"].to_i : 3)
+    Cassie.configure!(
+      cluster: {host: cassandra_host, port: cassandra_port.to_i, protocol_version: protocol_version},
+      keyspaces: {"test" => "cassie_specs"},
+      schema_directory: schema_dir,
+      max_prepared_statements: 3
+    )
+
+    attempts = 0
+    loop do
+      begin
+        Cassie::Schema.load_all!
+        break
+      rescue Cassandra::Errors::NoHostsAvailable => e
+        attempts += 1
+        raise e if attempts > 30
+        sleep(1)
+      end
+    end
+
     Cassie::Testing.prepare!
   end
-  
+
   config.after(:suite) do
     Cassie::Schema.drop_all!
   end
-  
+
   config.around(:each) do |example|
     Cassie::Testing.cleanup! do
       example.run