whi-cassie 1.0.5 → 1.2.0

data/lib/cassie/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Initialize Cassie instance with default behaviors for a Rails environment.
 #
 # Configuration will be gotten from config/cassie.yml.
@@ -6,13 +8,13 @@
 class Cassie::Railtie < Rails::Railtie
   initializer "cassie.initialization" do
     Cassie.logger = Rails.logger
-    
-    config_file = Rails.root + 'config' + 'cassie.yml'
+
+    config_file = Rails.root + "config" + "cassie.yml"
     if config_file.exist?
-      options = YAML::load(ERB.new(config_file.read).result)[Rails.env]
+      options = YAML.load(ERB.new(config_file.read).result)[Rails.env] # rubocop:disable Security/YAMLLoad
       if Rails.env.development? || Rails.env.test?
-        schema_dir = Rails.root + 'db' + 'cassandra'
-        options['schema_directory'] = schema_dir.to_s if schema_dir.exist?
+        schema_dir = Rails.root + "db" + "cassandra"
+        options["schema_directory"] = schema_dir.to_s if schema_dir.exist?
       end
       Cassie.configure!(options)
     end

data/lib/cassie/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class can be used to create, drop, or get information about the cassandra schemas. This class
 # is intended only to provide support for creating schemas in development and test environments. You
 # should not use this class with your production environment since some of the methods can be destructive.
@@ -8,39 +10,42 @@
 # definition files live. The files should be named "#{abstract_keyspace}.cql". The actual keyspace name will
 # be looked from the keyspace mapping in the configuration.
 class Cassie::Schema
-  TABLES_CQL = "SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?".freeze
-  
+  TABLES_CQL = "SELECT table_name FROM system_schema.tables WHERE keyspace_name = ?"
+  VERSION_2_TABLES_CQL = "SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?"
+
+  # rubocop:disable Lint/MixedRegexpCaptureTypes
   CREATE_MATCHER = /\A(?<create>CREATE (TABLE|((CUSTOM )?INDEX)|TYPE|TRIGGER))(?<exist>( IF NOT EXISTS)?) (?<object>[a-z0-9_.]+)/i.freeze
   DROP_MATCHER = /\A(?<drop>DROP (TABLE|INDEX|TYPE|TRIGGER))(?<exist>( IF EXISTS)?) (?<object>[a-z0-9_.]+)/i.freeze
-  
+  # rubocop:enable Lint/MixedRegexpCaptureTypes
+
   attr_reader :keyspace
-  
+
   class << self
     # Get all the defined schemas.
     def all
       schemas.values
     end
-    
+
     # Find the schema for a keyspace using the abstract name.
     def find(keyspace)
       schemas[keyspace]
     end
-    
+
     # Throw out the cached schemas so they can be reloaded from the configuration.
     def reset!
       @schemas = nil
     end
-    
+
     # Drop a specified keyspace by abstract name. The actual keyspace name will be looked up
     # from the keyspaces in the configuration.
     def drop!(keyspace_name)
       keyspace = Cassie.instance.config.keyspace(keyspace_name)
       raise ArgumentError.new("#{keyspace_name} is not defined as keyspace in the configuration") unless keyspace
-      
+
       drop_keyspace_cql = "DROP KEYSPACE IF EXISTS #{keyspace}"
       Cassie.instance.execute(drop_keyspace_cql)
     end
-    
+
     # Load a specified keyspace by abstract name. The actual keyspace name will be looked up
     # from the keyspaces in the configuration.
     def load!(keyspace_name)
@@ -49,24 +54,24 @@ class Cassie::Schema
 
       schema_file = File.join(Cassie.instance.config.schema_directory, "#{keyspace_name}.cql")
       raise ArgumentError.new("#{keyspace_name} schema file does not exist at #{schema_file}") unless File.exist?(schema_file)
-      schema_statements = File.read(schema_file).split(';').collect{|s| s.strip.chomp(';')}
-      
+      schema_statements = File.read(schema_file).split(";").collect { |s| s.strip.chomp(";") }
+
       create_keyspace_cql = "CREATE KEYSPACE IF NOT EXISTS #{keyspace} WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1}"
       Cassie.instance.execute(create_keyspace_cql)
-      
+
       schema_statements.each do |statement|
-        statement = statement.gsub(/#(.*)$/, '').gsub(/\s+/, ' ').strip
+        statement = statement.gsub(/#(.*)$/, "").gsub(/\s+/, " ").strip
         create_match = statement.match(CREATE_MATCHER)
         if create_match
           object = create_match["object"]
-          object = "#{keyspace}.#{object}" unless object.include?('.')
-          statement = statement.sub(create_match.to_s, "#{create_match['create']} IF NOT EXISTS #{object}")
+          object = "#{keyspace}.#{object}" unless object.include?(".")
+          statement = statement.sub(create_match.to_s, "#{create_match["create"]} IF NOT EXISTS #{object}")
         else
           drop_match = statement.match(DROP_MATCHER)
           if drop_match
             object = drop_match["object"]
-            object = "#{keyspace}.#{object}" unless object.include?('.')
-            statement = statement.sub(drop_match.to_s, "#{drop_match['drop']} IF EXISTS #{object}")
+            object = "#{keyspace}.#{object}" unless object.include?(".")
+            statement = statement.sub(drop_match.to_s, "#{drop_match["drop"]} IF EXISTS #{object}")
           end
         end
         unless statement.blank?
@@ -75,23 +80,23 @@ class Cassie::Schema
       end
       nil
     end
-    
+
     # Drop all keyspaces defined in the configuration.
     def drop_all!
       Cassie.instance.config.keyspace_names.each do |keyspace|
         drop!(keyspace)
       end
     end
-    
+
     # Drop all keyspaces defined in the configuration.
     def load_all!
       Cassie.instance.config.keyspace_names.each do |keyspace|
         load!(keyspace)
       end
     end
-    
+
     private
-    
+
     def schemas
       unless defined?(@schemas) && @schemas
         schemas = {}
@@ -103,24 +108,26 @@ class Cassie::Schema
       @schemas
     end
   end
-  
+
   def initialize(keyspace)
     @keyspace = keyspace
   end
-  
+
   # Returns a list of tables defined for the schema.
   def tables
     unless defined?(@tables) && @tables
-      tables = []
-      results = Cassie.instance.execute(TABLES_CQL, keyspace)
-      results.each do |row|
-        tables << row['columnfamily_name']
+      results = nil
+      begin
+        results = Cassie.instance.execute(TABLES_CQL, keyspace)
+      rescue Cassandra::Errors::InvalidError
+        results = Cassie.instance.execute(VERSION_2_TABLES_CQL, keyspace)
       end
+      tables = results.collect { |row| row.values.first }
       @tables = tables
     end
     @tables
   end
-  
+
   # Truncate the data from a table.
   def truncate!(table)
     statement = Cassie.instance.prepare("TRUNCATE #{keyspace}.#{table}")

data/lib/cassie/subscribers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Thread safe list of subscribers. Each subscriber must respond to the :call method.
+class Cassie::Subscribers
+  def initialize(parent_subscribers = nil)
+    @array = [].freeze
+    @lock = Mutex.new
+    @parent_subscribers = parent_subscribers
+  end
+
+  def add(subscriber)
+    @lock.synchronize do
+      new_array = @array.dup
+      new_array << subscriber
+      @array = new_array
+    end
+  end
+  alias_method :<<, :add
+
+  def remove(subscriber)
+    removed = nil
+    @lock.synchronize do
+      new_array = @array.dup
+      removed = new_array.delete(subscriber)
+      @array = new_array
+    end
+    removed
+  end
+  alias_method :delete, :remove
+
+  def clear
+    @array = []
+  end
+
+  def size
+    @array.size + (@parent_subscribers ? @parent_subscribers.size : 0)
+  end
+
+  def empty?
+    size == 0
+  end
+
+  def each(&block)
+    @array.each(&block)
+    @parent_subscribers&.each(&block)
+  end
+
+  def include?(subscriber)
+    @array.include?(subscriber)
+  end
+end

data/lib/cassie/testing.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 # This class provides helper methods for testing.
 module Cassie::Testing
   extend ActiveSupport::Concern
-  
+
   included do
-    alias_method_chain :insert, :testing
+    prepend OverrideMethods
   end
-  
+
   class << self
     # Prepare the test environment. This method must be called before running the test suite.
     def prepare!
@@ -16,31 +18,31 @@ module Cassie::Testing
         end
       end
     end
-    
+
     # Wrap test cases as a block in this method. After the test case finishes, all tables
     # that had data inserted into them will be truncated so that the data state will be clean
     # for the next test case.
     def cleanup!
-      begin
-        yield
-      ensure
-        if Thread.current[:cassie_inserted].present?
-          Cassie.instance.batch do
-            Thread.current[:cassie_inserted].each do |table|
-              keyspace, table = table.split('.', 2)
-              schema = Cassie::Schema.find(keyspace)
-              schema.truncate!(table) if schema
-            end
+      yield
+    ensure
+      if Thread.current[:cassie_inserted].present?
+        Cassie.instance.batch do
+          Thread.current[:cassie_inserted].each do |table|
+            keyspace, table = table.split(".", 2)
+            schema = Cassie::Schema.find(keyspace)
+            schema&.truncate!(table)
           end
-          Thread.current[:cassie_inserted] = nil
         end
+        Thread.current[:cassie_inserted] = nil
       end
     end
   end
-  
-  def insert_with_testing(table, *args)
-    Thread.current[:cassie_inserted] ||= Set.new
-    Thread.current[:cassie_inserted] << table
-    insert_without_testing(table, *args)
+
+  module OverrideMethods
+    def insert(table, *args)
+      Thread.current[:cassie_inserted] ||= Set.new
+      Thread.current[:cassie_inserted] << table
+      super(table, *args)
+    end
   end
 end

data/lib/whi-cassie.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require File.expand_path("../cassie.rb", __FILE__)

data/spec/cassie/config_spec.rb

@@ -1,7 +1,6 @@
 require "spec_helper"
 
 describe Cassie::Config do
-  
   let(:options) do
     {
       "cluster" => {
@@ -14,43 +13,42 @@ describe Cassie::Config do
       "default_keyspace" => "another"
     }
   end
-  
+
   it "should handle empty options" do
     config = Cassie::Config.new({})
-    config.cluster.should == {}
-    config.keyspace_names.should == []
-    config.default_keyspace.should == nil
-    config.schema_directory.should == nil
-    config.max_prepared_statements.should == 1000
+    expect(config.cluster).to eq({})
+    expect(config.keyspace_names).to eq([])
+    expect(config.default_keyspace).to eq(nil)
+    expect(config.schema_directory).to eq(nil)
+    expect(config.max_prepared_statements).to eq(1000)
   end
-  
+
   it "should have cluster options" do
     config = Cassie::Config.new(options)
-    config.cluster.should == {:consistency => :one, :timeout => 15}
+    expect(config.cluster).to eq({consistency: :one, timeout: 15})
   end
-  
+
   it "should have keyspaces" do
     config = Cassie::Config.new(options)
-    config.keyspace(:default).should start_with("test_default")
-    config.keyspace("other").should start_with("test_other")
-    config.keyspace_names.should =~ ["default", "other"]
+    expect(config.keyspace(:default)).to start_with("test_default")
+    expect(config.keyspace("other")).to start_with("test_other")
+    expect(config.keyspace_names).to match_array(["default", "other"])
   end
-  
+
   it "should have a default_keyspace" do
     config = Cassie::Config.new(options)
-    config.default_keyspace.should == "another"
+    expect(config.default_keyspace).to eq("another")
   end
-  
+
   it "should get the schema_directory" do
     config = Cassie::Config.new(options)
-    config.schema_directory.should == "/tmp"
-    Cassie::Config.new({}).schema_directory.should == nil
+    expect(config.schema_directory).to eq("/tmp")
+    expect(Cassie::Config.new({}).schema_directory).to eq(nil)
   end
-  
+
   it "should get the max_prepared_statements" do
     config = Cassie::Config.new(options)
-    config.max_prepared_statements.should == 100
-    Cassie::Config.new({}).max_prepared_statements.should == 1000
+    expect(config.max_prepared_statements).to eq(100)
+    expect(Cassie::Config.new({}).max_prepared_statements).to eq(1000)
   end
-  
 end

data/spec/cassie/model_spec.rb

@@ -1,506 +1,573 @@
 require "spec_helper"
 
 describe Cassie::Model do
-  
   describe "definition" do
     it "should define the table name" do
-      Cassie::Thing.table_name.should == "things"
-      Cassie::Thing.keyspace.should == "cassie_specs"
-      Cassie::Thing.full_table_name.should == "cassie_specs.things"
-      Cassie::Thing.column_names.should =~ [:owner, :id, :val]
+      expect(Cassie::Thing.table_name).to eq("things")
+      expect(Cassie::Thing.keyspace).to eq("cassie_specs")
+      expect(Cassie::Thing.full_table_name).to eq("cassie_specs.things")
+      expect(Cassie::Thing.column_names).to match_array([:owner, :id, :val])
     end
-    
+
     it "should define the primary key" do
-      Cassie::Thing.primary_key.should == [:owner, :id]
+      expect(Cassie::Thing.primary_key).to eq([:owner, :id])
     end
-    
+
     it "should alias abbreviated column names with human readable names" do
       m = Cassie::Thing.new
       m.id = 1
-      m.identifier.should == 1
+      expect(m.identifier).to eq(1)
       m.identifier = 2
-      m.id.should == 2
+      expect(m.id).to eq(2)
     end
-    
+
     it "should allow null values" do
-      Cassie::Thing.create!(:owner => 1, :id => 2)
-      record = Cassie::Thing.find(:owner => 1, :id => 2)
-      record.value.should == nil
+      Cassie::Thing.create!(owner: 1, id: 2)
+      record = Cassie::Thing.find(owner: 1, id: 2)
+      expect(record.value).to eq(nil)
     end
   end
-  
+
   describe "create" do
     it "should create a record" do
-      record = Cassie::Thing.create(:owner => 1, :identifier => 2, :value => 'foo')
-      record.owner.should == 1
-      Cassie::Thing.find(:owner => 1, :identifier => 2).value.should == 'foo'
+      record = Cassie::Thing.create(owner: 1, identifier: 2, value: "foo")
+      expect(record.owner).to eq(1)
+      expect(Cassie::Thing.find(owner: 1, identifier: 2).value).to eq("foo")
     end
-    
+
     it "should not save an invalid record" do
-      record = Cassie::Thing.create(:owner => 1, :value => 'foo')
-      record.should_not be_valid
-      Cassie::Thing.count(:owner => 1).should == 0
+      record = Cassie::Thing.create(owner: 1, value: "foo")
+      expect(record).not_to be_valid
+      expect(Cassie::Thing.count(owner: 1)).to eq(0)
     end
-    
+
     it "should error on an invalid record using the bang version" do
-      lambda{ Cassie::Thing.create!(:owner => 1, :value => 'foo') }.should raise_error(Cassie::RecordInvalid)
+      expect { Cassie::Thing.create!(owner: 1, value: "foo") }.to raise_error(Cassie::RecordInvalid)
     end
   end
-  
+
   describe "delete_all" do
     it "should delete all records matching the key" do
-      Cassie::Thing.create(:owner => 1, :id => 2, :val => 'foo')
-      Cassie::Thing.create(:owner => 1, :id => 3, :val => 'bar')
-      Cassie::Thing.count(:owner => 1).should == 2
-      Cassie::Thing.delete_all(:owner => 1, :id => 2)
-      Cassie::Thing.count(:owner => 1).should == 1
-      Cassie::Thing.find(:owner => 1, :id => 2).should == nil
-      Cassie::Thing.find(:owner => 1, :id => 3).should_not == nil
+      Cassie::Thing.create(owner: 1, id: 2, val: "foo")
+      Cassie::Thing.create(owner: 1, id: 3, val: "bar")
+      expect(Cassie::Thing.count(owner: 1)).to eq(2)
+      Cassie::Thing.delete_all(owner: 1, id: 2)
+      expect(Cassie::Thing.count(owner: 1)).to eq(1)
+      expect(Cassie::Thing.find(owner: 1, id: 2)).to eq(nil)
+      expect(Cassie::Thing.find(owner: 1, id: 3)).not_to eq(nil)
     end
   end
-  
+
   describe "finding" do
-    let!(:r1){ Cassie::Thing.create(:owner => 1, :id => 2, :val => 'foo') }
-    let!(:r2){ Cassie::Thing.create(:owner => 1, :id => 3, :val => 'bar') }
-    let!(:r3){ Cassie::Thing.create(:owner => 2, :id => 3, :val => 'blah') }
-    
+    let!(:r1) { Cassie::Thing.create(owner: 1, id: 2, val: "foo") }
+    let!(:r2) { Cassie::Thing.create(owner: 1, id: 3, val: "bar") }
+    let!(:r3) { Cassie::Thing.create(owner: 2, id: 3, val: "blah") }
+
     it "should find all records using a variety of syntaxes" do
-      Cassie::Thing.find_all(where: {:owner => 1}, order: "id ASC").should == [r1, r2]
-      Cassie::Thing.find_all(where: {:owner => 1}, order: "id DESC").should == [r2, r1]
-      Cassie::Thing.find_all(where: {:owner => 1}, order: "id ASC", limit: 1).should == [r1]
-      Cassie::Thing.find_all(where: "owner = 1", order: "id ASC").should == [r1, r2]
-      Cassie::Thing.find_all(where: ["owner = ?", 1], order: "id ASC").should == [r1, r2]
-      Cassie::Thing.find_all(where: {:owner => 0}, order: "id ASC").should == []
-      Cassie::Thing.find_all(where: {:owner => 1, :id => 2}).should == [r1]
-      Cassie::Thing.find_all(where: {:owner => [1, 2]}).should =~ [r1, r2, r3]
-      Cassie::Thing.find_all(where: {:owner => [1, 2]}, options: {:page_size => 1}).should =~ [r1, r2, r3]
-    end
-    
+      expect(Cassie::Thing.find_all(where: {owner: 1}, order: "id ASC")).to eq([r1, r2])
+      expect(Cassie::Thing.find_all(where: {owner: 1}, order: "id DESC")).to eq([r2, r1])
+      expect(Cassie::Thing.find_all(where: {owner: 1}, order: "id ASC", limit: 1)).to eq([r1])
+      expect(Cassie::Thing.find_all(where: "owner = 1", order: "id ASC")).to eq([r1, r2])
+      expect(Cassie::Thing.find_all(where: ["owner = ?", 1], order: "id ASC")).to eq([r1, r2])
+      expect(Cassie::Thing.find_all(where: {owner: 0}, order: "id ASC")).to eq([])
+      expect(Cassie::Thing.find_all(where: {owner: 1, id: 2})).to eq([r1])
+      expect(Cassie::Thing.find_all(where: {owner: [1, 2]})).to match_array([r1, r2, r3])
+      expect(Cassie::Thing.find_all(where: {owner: [1, 2]}, options: {page_size: 1})).to match_array([r1, r2, r3])
+    end
+
     it "should find one record" do
-      Cassie::Thing.find(:owner => 1, :id => 2).should == r1
-      Cassie::Thing.find(:owner => 1, :id => 3).should == r2
-      Cassie::Thing.find(:owner => 1, :id => 0).should == nil
+      expect(Cassie::Thing.find(owner: 1, id: 2)).to eq(r1)
+      expect(Cassie::Thing.find(owner: 1, id: 3)).to eq(r2)
+      expect(Cassie::Thing.find(owner: 1, id: 0)).to eq(nil)
     end
-    
+
     it "should raise an error if the record can't be found and called as find!" do
-      Cassie::Thing.find!(:owner => 1, :id => 2).should == r1
-      lambda{ Cassie::Thing.find!(:owner => 1, :id => 0) }.should raise_error(Cassie::RecordNotFound)
+      expect(Cassie::Thing.find!(owner: 1, id: 2)).to eq(r1)
+      expect { Cassie::Thing.find!(owner: 1, id: 0) }.to raise_error(Cassie::RecordNotFound)
     end
-    
+
     it "should mark found records as persisted" do
-      Cassie::Thing.find(:owner => 1, :id => 2).persisted?.should == true
+      expect(Cassie::Thing.find(owner: 1, id: 2).persisted?).to eq(true)
     end
-    
+
     it "should count records" do
-      Cassie::Thing.count(:owner => 1).should == 2
-      Cassie::Thing.count(:owner => 1, :id => 2).should == 1
+      expect(Cassie::Thing.count(owner: 1)).to eq(2)
+      expect(Cassie::Thing.count(owner: 1, id: 2)).to eq(1)
     end
-    
+
     it "won't find all records with a blank where clause" do
-      expect{ Cassie::Thing.find_all(where: {}) }.to raise_error(ArgumentError)
-      Cassie::Thing.find_all(where: :all).size.should == 3
+      expect { Cassie::Thing.find_all(where: {}) }.to raise_error(ArgumentError)
+      expect(Cassie::Thing.find_all(where: :all).size).to eq(3)
+    end
+
+    it "should be able to add subscribers" do
+      global = nil
+      local = nil
+      Cassie::Model.find_subscribers << lambda { |info| global = info.rows }
+      Cassie::Thing.find_subscribers << lambda { |info| local = info.rows }
+      expect(Cassie::Thing.find_all(where: {owner: 1}).size).to eq(2)
+      expect(global).to eq(2)
+      expect(local).to eq(2)
     end
   end
-  
+
   describe "offset_to_id" do
-    let!(:r1){ Cassie::Thing.create(:owner => 1, :id => 2, :val => 'foo') }
-    let!(:r2){ Cassie::Thing.create(:owner => 1, :id => 3, :val => 'bar') }
-    let!(:r3){ Cassie::Thing.create(:owner => 1, :id => 4, :val => 'blah') }
-    let!(:r4){ Cassie::Thing.create(:owner => 1, :id => 5, :val => 'mip') }
-    let!(:r5){ Cassie::Thing.create(:owner => 2, :id => 2, :val => 'grl') }
-    
+    let!(:r1) { Cassie::Thing.create(owner: 1, id: 2, val: "foo") }
+    let!(:r2) { Cassie::Thing.create(owner: 1, id: 3, val: "bar") }
+    let!(:r3) { Cassie::Thing.create(owner: 1, id: 4, val: "blah") }
+    let!(:r4) { Cassie::Thing.create(owner: 1, id: 5, val: "mip") }
+    let!(:r5) { Cassie::Thing.create(owner: 2, id: 2, val: "grl") }
+
     it "should calculate the ordering key at a specified offset" do
-      Cassie::Thing.offset_to_id({:owner => 1}, 2).should == 3
-      Cassie::Thing.offset_to_id({:owner => 1}, 2, order: :asc).should == 4
-      Cassie::Thing.offset_to_id({:owner => 1}, 2, batch_size: 1).should == 3
-      Cassie::Thing.offset_to_id({:owner => 1}, 3, batch_size: 1).should == 2
-      Cassie::Thing.offset_to_id({:owner => 1}, 4, batch_size: 1).should == nil
-      Cassie::Thing.offset_to_id({:owner => 1}, 4, batch_size: 100).should == nil
-      Cassie::Thing.offset_to_id({:owner => 1}, 1, batch_size: 1, min: 3).should == 4
-      Cassie::Thing.offset_to_id({:owner => 1}, 1, order: :desc, batch_size: 1, max: 5).should == 3
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 2)).to eq(3)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 2, order: :asc)).to eq(4)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 2, batch_size: 1)).to eq(3)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 3, batch_size: 1)).to eq(2)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 4, batch_size: 1)).to eq(nil)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 4, batch_size: 100)).to eq(nil)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 1, batch_size: 1, min: 3)).to eq(4)
+      expect(Cassie::Thing.offset_to_id({owner: 1}, 1, order: :desc, batch_size: 1, max: 5)).to eq(3)
     end
   end
-  
+
   describe "batch" do
-    it "should delegate to Cassie.batch" do
-      Cassie::Thing.connection.should be_a(Cassie)
-      expect(Cassie::Thing.connection).to receive(:batch).and_call_original
-      Cassie::Thing.batch{}
+    it "should delegate to Cassie.batch using the write consistency" do
+      expect(Cassie::Thing.connection).to be_a(Cassie)
+      expect(Cassie::Thing.connection).to receive(:batch).with(consistency: :quorum).and_call_original
+      Cassie::Thing.batch {}
     end
   end
-  
+
   describe "attributes" do
     it "should get and set attributes" do
-      record = Cassie::Thing.new(:owner => 1, :id => 2, :val => 'foo')
-      record.attributes.should == {:owner => 1, :id => 2, :val => 'foo'}
+      record = Cassie::Thing.new(owner: 1, id: 2, val: "foo")
+      expect(record.attributes).to eq({owner: 1, id: 2, val: "foo"})
     end
- 
+
     it "should get and set attributes using human readable names" do
-      record = Cassie::Thing.new(:owner => 1, :identifier => 2, :value => 'foo')
-      record.attributes.should == {:owner => 1, :id => 2, :val => 'foo'}
+      record = Cassie::Thing.new(owner: 1, identifier: 2, value: "foo")
+      expect(record.attributes).to eq({owner: 1, id: 2, val: "foo"})
     end
   end
-  
+
   describe "save" do
     it "should not save an invalid record" do
-      record = Cassie::Thing.new(:owner => 1, :val => 'foo')
-      record.save.should == false
-      Cassie::Thing.count(:owner => 1).should == 0
+      record = Cassie::Thing.new(owner: 1, val: "foo")
+      expect(record.save).to eq(false)
+      expect(Cassie::Thing.count(owner: 1)).to eq(0)
     end
-    
+
     it "should raise an error on the bang version on an invalid record" do
-      record = Cassie::Thing.new(:owner => 1, :val => 'foo')
-      lambda{ record.save! }.should raise_error(Cassie::RecordInvalid)
-      Cassie::Thing.count(:owner => 1).should == 0
+      record = Cassie::Thing.new(owner: 1, val: "foo")
+      expect { record.save! }.to raise_error(Cassie::RecordInvalid)
+      expect(Cassie::Thing.count(owner: 1)).to eq(0)
     end
-    
+
     it "should save new records and invoke the create callbacks" do
-      record = Cassie::Thing.new(:owner => 1, :id => 2, :val => 'foo')
-      record.persisted?.should == false
-      record.save.should == true
-      record.persisted?.should == true
-      record.callbacks.should == [:save, :create]
-      Cassie::Thing.find(:owner => 1, :id => 2).should == record
-    end
-    
+      record = Cassie::Thing.new(owner: 1, id: 2, val: "foo")
+      expect(record.persisted?).to eq(false)
+      expect(record.save).to eq(true)
+      expect(record.persisted?).to eq(true)
+      expect(record.callbacks).to eq([:save, :create])
+      expect(Cassie::Thing.find(owner: 1, id: 2)).to eq(record)
+    end
+
     it "should save existing records and invoke the update callbacks" do
-      Cassie::Thing.create(:owner => 1, :id => 2, :val => 'foo')
-      record = Cassie::Thing.find(:owner => 1, :id => 2)
-      record.persisted?.should == true
-      record.value = 'bar'
-      record.save.should == true
-      record.persisted?.should == true
-      record.callbacks.should == [:save, :update]
-      Cassie::Thing.find(:owner => 1, :id => 2).value.should == 'bar'
+      Cassie::Thing.create(owner: 1, id: 2, val: "foo")
+      record = Cassie::Thing.find(owner: 1, id: 2)
+      expect(record.persisted?).to eq(true)
+      record.value = "bar"
+      expect(record.save).to eq(true)
+      expect(record.persisted?).to eq(true)
+      expect(record.callbacks).to eq([:save, :update])
+      expect(Cassie::Thing.find(owner: 1, id: 2).value).to eq("bar")
+    end
+
+    it "should save new records with a ttl" do
+      expect(Cassie::Thing.connection).to receive(:insert).with("cassie_specs.things", {owner: 1, id: 2, val: "foo"}, {consistency: :quorum, ttl: 10}).and_call_original
+      record = Cassie::Thing.new(owner: 1, id: 2, val: "foo")
+      expect(record.persisted?).to eq(false)
+      expect(record.save(ttl: 10)).to eq(true)
+      expect(record.persisted?).to eq(true)
+      expect(record.callbacks).to eq([:save, :create])
+      expect(Cassie::Thing.find(owner: 1, id: 2)).to eq(record)
     end
   end
-  
+
   describe "destroy" do
     it "should delete a record from Cassandra calling any destroy callbacks" do
-      Cassie::Thing.create(:owner => 1, :id => 2, :val => 'foo')
-      record = Cassie::Thing.find(:owner => 1, :id => 2)
+      Cassie::Thing.create(owner: 1, id: 2, val: "foo")
+      record = Cassie::Thing.find(owner: 1, id: 2)
       record.destroy
-      Cassie::Thing.find(:owner => 1, :id => 2).should == nil
-      record.callbacks.should =~ [:destroy]
+      expect(Cassie::Thing.find(owner: 1, id: 2)).to eq(nil)
+      expect(record.callbacks).to match_array([:destroy])
+    end
+  end
+
+  describe "consistency" do
+    let(:connection) { Cassie::Thing.connection }
+
+    it "should be able to set a model level read consistency" do
+      expect(connection).to receive(:find).with("SELECT owner, id, val FROM cassie_specs.things WHERE owner = ?", [0], {consistency: :one}).and_call_original
+      Cassie::Thing.find_all(where: {owner: 0})
+    end
+
+    it "should be able to override the model level read consistency" do
+      save_val = Cassie::Thing.read_consistency
+      begin
+        Cassie::Thing.read_consistency = :quorum
+        expect(connection).to receive(:find).with("SELECT owner, id, val FROM cassie_specs.things WHERE owner = ?", [0], {consistency: :quorum}).and_call_original
+        Cassie::Thing.find_all(where: {owner: 0})
+      ensure
+        Cassie::Thing.read_consistency = save_val
+      end
+    end
+
+    it "should be able to set a model level write consistency" do
+      thing = Cassie::Thing.new(owner: 1, id: 2)
+      expect(connection).to receive(:insert).with("cassie_specs.things", {owner: 1, id: 2, val: nil}, {consistency: :quorum, ttl: nil}).and_call_original
+      thing.save
+
+      thing.val = "foo"
+      expect(connection).to receive(:update).with("cassie_specs.things", {val: "foo"}, {owner: 1, id: 2}, {consistency: :quorum, ttl: nil}).and_call_original
+      thing.save
+
+      expect(connection).to receive(:delete).with("cassie_specs.things", {owner: 1, id: 2}, {consistency: :quorum}).and_call_original
+      thing.destroy
+    end
+
+    it "should be able to override the model level write consistency" do
+      thing = Cassie::Thing.new(owner: 1, id: 2)
+      thing.write_consistency = :local_quorum
+
+      expect(connection).to receive(:insert).with("cassie_specs.things", {owner: 1, id: 2, val: nil}, {consistency: :local_quorum, ttl: nil}).and_call_original
+      thing.save
+
+      thing.val = "foo"
+      expect(connection).to receive(:update).with("cassie_specs.things", {val: "foo"}, {owner: 1, id: 2}, {consistency: :local_quorum, ttl: nil}).and_call_original
+      thing.save
+
+      expect(connection).to receive(:delete).with("cassie_specs.things", {owner: 1, id: 2}, {consistency: :local_quorum}).and_call_original
+      thing.destroy
     end
   end
-  
+
   describe "type conversion" do
-    let(:model){ Cassie::TypeTester.new }
-    
+    let(:model) { Cassie::TypeTester.new }
+
     it "should work with varchar columns" do
       model.varchar_value = "foo"
-      model.varchar_value.should == "foo"
+      expect(model.varchar_value).to eq("foo")
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.varchar_value.should == "foo"
-      
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.varchar_value).to eq("foo")
+
       model.varchar_value = nil
-      model.varchar_value.should == nil
+      expect(model.varchar_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.varchar_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.varchar_value).to eq(nil)
     end
-    
+
     it "should work with ascii columns" do
       model.ascii_value = "foo"
-      model.ascii_value.should == "foo"
+      expect(model.ascii_value).to eq("foo")
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.ascii_value.should == "foo"
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.ascii_value).to eq("foo")
 
       model.ascii_value = nil
-      model.ascii_value.should == nil
+      expect(model.ascii_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.ascii_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.ascii_value).to eq(nil)
     end
-    
+
     it "should work with text columns" do
       model.text_value = "foo"
-      model.text_value.should == "foo"
+      expect(model.text_value).to eq("foo")
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.text_value.should == "foo"
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.text_value).to eq("foo")
 
       model.text_value = nil
-      model.text_value.should == nil
+      expect(model.text_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.text_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.text_value).to eq(nil)
     end
-    
+
     it "should work with blob columns" do
       model.blob_value = "foo"
-      model.blob_value.should == "foo"
+      expect(model.blob_value).to eq("foo")
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.blob_value.should == "foo"
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.blob_value).to eq("foo")
 
       model.blob_value = nil
-      model.blob_value.should == nil
+      expect(model.blob_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.blob_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.blob_value).to eq(nil)
     end
-    
+
     it "should work with int columns" do
       model.int_value = "1"
-      model.int_value.should == 1
+      expect(model.int_value).to eq(1)
       model.int_value = 2
-      model.int_value.should == 2
+      expect(model.int_value).to eq(2)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.int_value.should == 2
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.int_value).to eq(2)
 
       model.int_value = nil
-      model.int_value.should == nil
+      expect(model.int_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.int_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.int_value).to eq(nil)
     end
-    
+
     it "should work with bigint columns" do
       model.bigint_value = "1"
-      model.bigint_value.should == 1
+      expect(model.bigint_value).to eq(1)
       model.bigint_value = 2
-      model.bigint_value.should == 2
+      expect(model.bigint_value).to eq(2)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.bigint_value.should == 2
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.bigint_value).to eq(2)
 
       model.bigint_value = nil
-      model.bigint_value.should == nil
+      expect(model.bigint_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.bigint_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.bigint_value).to eq(nil)
     end
-    
+
     it "should work with varint columns" do
       model.varint_value = "1"
-      model.varint_value.should == 1
+      expect(model.varint_value).to eq(1)
       model.varint_value = 2
-      model.varint_value.should == 2
+      expect(model.varint_value).to eq(2)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.varint_value.should == 2
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.varint_value).to eq(2)
 
       model.varint_value = nil
-      model.varint_value.should == nil
+      expect(model.varint_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.varint_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.varint_value).to eq(nil)
     end
-    
+
     it "should work with float columns" do
       model.float_value = "1.1"
-      model.float_value.should == 1.1
+      expect(model.float_value).to eq(1.1)
       model.float_value = 2.2
-      model.float_value.should == 2.2
+      expect(model.float_value).to eq(2.2)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.float_value.round(4).should == 2.2
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.float_value.round(4)).to eq(2.2)
 
       model.float_value = nil
-      model.float_value.should == nil
+      expect(model.float_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.float_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.float_value).to eq(nil)
     end
-    
+
     it "should work with double columns" do
       model.double_value = "1.1"
-      model.double_value.should == 1.1
+      expect(model.double_value).to eq(1.1)
       model.double_value = 2.2
-      model.double_value.should == 2.2
+      expect(model.double_value).to eq(2.2)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.double_value.should == 2.2
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.double_value).to eq(2.2)
 
       model.double_value = nil
-      model.double_value.should == nil
+      expect(model.double_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.double_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.double_value).to eq(nil)
     end
-    
+
     it "should work with decimal columns" do
       model.decimal_value = "1.1"
-      model.decimal_value.should == 1.1
-      model.decimal_value.should be_a(BigDecimal)
-      model.decimal_value = BigDecimal.new("3.3", 2)
-      model.decimal_value.should == BigDecimal.new("3.3", 2)
+      expect(model.decimal_value).to eq(1.1)
+      expect(model.decimal_value).to be_a(BigDecimal)
+      model.decimal_value = BigDecimal("3.3", 2)
+      expect(model.decimal_value).to eq(BigDecimal("3.3", 2))
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.decimal_value.should == BigDecimal.new("3.3", 2)
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.decimal_value).to eq(BigDecimal("3.3", 2))
 
       model.decimal_value = nil
-      model.decimal_value.should == nil
+      expect(model.decimal_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.decimal_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.decimal_value).to eq(nil)
     end
-    
+
     it "should work with timestamp columns" do
       model.timestamp_value = "2015-04-23T15:23:30"
-      model.timestamp_value.should == Time.new(2015, 4, 23, 15, 23, 30)
+      expect(model.timestamp_value).to eq(Time.new(2015, 4, 23, 15, 23, 30))
       model.timestamp_value = Time.new(2015, 4, 23, 15, 25, 30)
-      model.timestamp_value.should == Time.new(2015, 4, 23, 15, 25, 30)
+      expect(model.timestamp_value).to eq(Time.new(2015, 4, 23, 15, 25, 30))
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.timestamp_value.should == Time.new(2015, 4, 23, 15, 25, 30)
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.timestamp_value).to eq(Time.new(2015, 4, 23, 15, 25, 30))
 
       model.timestamp_value = nil
-      model.timestamp_value.should == nil
+      expect(model.timestamp_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.timestamp_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.timestamp_value).to eq(nil)
     end
-    
+
     it "should work with boolean columns" do
       model.boolean_value = true
-      model.boolean_value.should == true
+      expect(model.boolean_value).to eq(true)
       model.boolean_value = false
-      model.boolean_value.should == false
+      expect(model.boolean_value).to eq(false)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.boolean_value.should == false
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.boolean_value).to eq(false)
 
       model.boolean_value = nil
-      model.boolean_value.should == nil
+      expect(model.boolean_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.boolean_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.boolean_value).to eq(nil)
     end
-    
+
     it "should work with inet columns" do
       model.inet_value = "127.0.0.1"
-      model.inet_value.should == IPAddr.new("127.0.0.1")
+      expect(model.inet_value).to eq(IPAddr.new("127.0.0.1"))
       model.inet_value = IPAddr.new("10.1.0.1")
-      model.inet_value.should == IPAddr.new("10.1.0.1")
+      expect(model.inet_value).to eq(IPAddr.new("10.1.0.1"))
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.inet_value.should == IPAddr.new("10.1.0.1")
-      
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.inet_value).to eq(IPAddr.new("10.1.0.1"))
+
       model.inet_value = nil
-      model.inet_value.should == nil
+      expect(model.inet_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.inet_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.inet_value).to eq(nil)
     end
-    
+
     it "should work with uuid columns" do
       model.uuid_value = "eed6d678-ea0b-11e4-8772-793f91a64daf"
-      model.uuid_value.should == Cassandra::Uuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf")
+      expect(model.uuid_value).to eq(Cassandra::Uuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf"))
       model.uuid_value = Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.uuid_value.should == Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      expect(model.uuid_value).to eq(Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf"))
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.uuid_value.should == Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.uuid_value).to eq(Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf"))
 
       model.uuid_value = nil
-      model.uuid_value.should == nil
+      expect(model.uuid_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.uuid_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.uuid_value).to eq(nil)
     end
-    
+
     it "should work with timeuuid columns" do
       model.timeuuid_value = "eed6d678-ea0b-11e4-8772-793f91a64daf"
-      model.timeuuid_value.should == Cassandra::TimeUuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf")
+      expect(model.timeuuid_value).to eq(Cassandra::TimeUuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf"))
       model.timeuuid_value = Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.timeuuid_value.should == Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      expect(model.timeuuid_value).to eq(Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf"))
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.timeuuid_value.should == Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.timeuuid_value).to eq(Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf"))
 
       model.timeuuid_value = nil
-      model.timeuuid_value.should == nil
+      expect(model.timeuuid_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.timeuuid_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.timeuuid_value).to eq(nil)
     end
-    
+
     it "should work with list columns" do
       model.list_value = ["a", "b", "c"]
-      model.list_value.should == ["a", "b", "c"]
+      expect(model.list_value).to eq(["a", "b", "c"])
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.list_value.should == ["a", "b", "c"]
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.list_value).to eq(["a", "b", "c"])
 
       model.list_value = nil
-      model.list_value.should == nil
+      expect(model.list_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.list_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.list_value).to eq(nil)
     end
-    
+
     it "should work with set columns" do
       model.set_value = ["a", "b", "c", "a"]
-      model.set_value.should == ["a", "b", "c"].to_set
+      expect(model.set_value).to eq(["a", "b", "c"].to_set)
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.set_value.should == ["a", "b", "c"].to_set
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.set_value).to eq(["a", "b", "c"].to_set)
 
       model.set_value = nil
-      model.set_value.should == nil
+      expect(model.set_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.set_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.set_value).to eq(nil)
     end
-    
+
     it "should work with map columns" do
       model.map_value = [["a", "b"], ["c", "d"]]
-      model.map_value.should == {"a" => "b", "c" => "d"}
+      expect(model.map_value).to eq({"a" => "b", "c" => "d"})
       model.map_value = {"e" => "f", "g" => "h"}
-      model.map_value.should == {"e" => "f", "g" => "h"}
+      expect(model.map_value).to eq({"e" => "f", "g" => "h"})
       model.save
       id = model.id
-      model = Cassie::TypeTester.find(:id => id)
-      model.map_value.should == {"e" => "f", "g" => "h"}
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.map_value).to eq({"e" => "f", "g" => "h"})
 
       model.map_value = nil
-      model.map_value.should == nil
+      expect(model.map_value).to eq(nil)
       model.save
-      model = Cassie::TypeTester.find(:id => id)
-      model.map_value.should == nil
+      model = Cassie::TypeTester.find(id: id)
+      expect(model.map_value).to eq(nil)
     end
-    
+
     it "should work with counter columns" do
       id = SecureRandom.uuid
-      model = Cassie::TypeTesterCounter.new(:id => id)
-      model.counter_value.should == 0
+      model = Cassie::TypeTesterCounter.new(id: id)
+      expect(model.counter_value).to eq(0)
       model.increment_counter_value!
-      model.counter_value.should == 1
-      model = Cassie::TypeTesterCounter.find(:id => id)
-      model.counter_value.should == 1
+      expect(model.counter_value).to eq(1)
+      model = Cassie::TypeTesterCounter.find(id: id)
+      expect(model.counter_value).to eq(1)
 
       model.increment_counter_value!
-      model.counter_value.should == 2
-      model = Cassie::TypeTesterCounter.find(:id => id)
-      model.counter_value.should == 2
-      
+      expect(model.counter_value).to eq(2)
+      model = Cassie::TypeTesterCounter.find(id: id)
+      expect(model.counter_value).to eq(2)
+
       model.decrement_counter_value!
-      model.counter_value.should == 1
-      model = Cassie::TypeTesterCounter.find(:id => id)
-      model.counter_value.should == 1
+      expect(model.counter_value).to eq(1)
+      model = Cassie::TypeTesterCounter.find(id: id)
+      expect(model.counter_value).to eq(1)
     end
   end
 end