datastax_rails 2.0.18 → 2.1.23

data/lib/datastax_rails/relation.rb

@@ -3,7 +3,7 @@ require 'pp' if ENV['DEBUG_SOLR'] == 'true'
 # TODO: Move functionality into modules
 module DatastaxRails
   # = DatastaxRails Relation
-  class Relation # rubocop:disable Style/ClassLength
+  class Relation # rubocop:disable Metrics/ClassLength
     MULTI_VALUE_METHODS = %i(order where where_not fulltext greater_than less_than select stats field_facet
                              range_facet slow_order)
     SINGLE_VALUE_METHODS = %i(page per_page reverse_order query_parser consistency ttl use_solr escape group
@@ -263,7 +263,8 @@ module DatastaxRails
         return :solr unless page_value == 1
         @where_values.each do |wv|
           wv.each do |k, _v|
-            next if klass.column_for_attribute(k).options[:cql_index]
+            col = klass.column_for_attribute(k)
+            next if col && (col.options[:cql_index] || col.primary)
             return :solr
           end
         end
@@ -290,7 +291,18 @@ module DatastaxRails
       cql = @cql.select(['count(*)'])
       cql.using(@consistency_value) if @consistency_value
       @where_values.each do |wv|
-        cql.conditions(wv)
+        wv.each do |k, v|
+          attr = (k.to_s == 'id' ? @klass.primary_key : k)
+          col = klass.column_for_attribute(attr)
+          if col.primary
+            v.compact! if v.respond_to?(:compact)
+            return 0 if v.blank?
+          end
+          values = Array(v).map do |val|
+            col.type_cast_for_cql3(val)
+          end
+          cql.conditions(attr => values)
+        end
       end
       cql.allow_filtering if @allow_filtering_value
       cql.execute.first['count']
@@ -305,7 +317,18 @@ module DatastaxRails
       cql = @cql.select((select_columns + [@klass.primary_key]).uniq)
       cql.using(@consistency_value) if @consistency_value
       @where_values.each do |wv|
-        cql.conditions(Hash[wv.map { |k, v| [(k.to_s == 'id' ? @klass.primary_key : k), v] }])
+        wv.each do |k, v|
+          attr = (k.to_s == 'id' ? @klass.primary_key : k)
+          col = klass.column_for_attribute(attr)
+          if col.primary
+            v.compact! if v.respond_to?(:compact!)
+            return [] if v.blank?
+          end
+          values = Array(v).map do |val|
+            col.type_cast_for_cql3(val)
+          end
+          cql.conditions(attr => values)
+        end
       end
       @greater_than_values.each do |gtv|
         gtv.each do |k, v|
@@ -322,9 +345,7 @@ module DatastaxRails
         end
       rescue ::Cql::CqlError => e # TODO: Break out the various exception types
         # If we get an exception about an empty key, ignore it.  We'll return an empty set.
-        if e.message =~ /Key may not be empty/
-          # No-Op
-        else
+        unless e.message =~ /Key may not be empty/
           raise
         end
       end
@@ -394,27 +415,35 @@ module DatastaxRails
       orders = []
       @where_values.each do |wv|
         wv.each do |k, v|
-          # If v is blank, check that there is no value for the field in the document
-          filter_queries << (v.blank? ? "-#{k}:#{full_solr_range(k)}" : "#{k}:(#{v})")
+          # If v is blank but not false, check that there is no value for the field in the document
+          if v.blank? && v != false
+            filter_queries << "-#{k}:#{full_solr_range(k)}"
+          else
+            filter_queries << "#{k}:(#{solr_format(k, v)})"
+          end
         end
       end
 
       @where_not_values.each do |wnv|
         wnv.each do |k, v|
-          # If v is blank, check for any value for the field in document
-          filter_queries << (v.blank? ? "#{k}:#{full_solr_range(k)}" : "-#{k}:(#{v})")
+          # If v is blank but not false, check for any value in the field in the document
+          if v.blank? && v != false
+            filter_queries << "#{k}:#{full_solr_range(k)}"
+          else
+            filter_queries << "-#{k}:(#{solr_format(k, v)})"
+          end
         end
       end
 
       @greater_than_values.each do |gtv|
         gtv.each do |k, v|
-          filter_queries << "#{k}:[#{v} TO *]"
+          filter_queries << "#{k}:[#{solr_format(k, v)} TO *]"
         end
       end
 
       @less_than_values.each do |ltv|
         ltv.each do |k, v|
-          filter_queries << "#{k}:[* TO #{v}]"
+          filter_queries << "#{k}:[* TO #{solr_format(k, v)}]"
         end
       end
 
@@ -497,43 +526,47 @@ module DatastaxRails
         params['stats.facet'] = @group_value
       end
       solr_response = nil
-      if @group_value
-        results = DatastaxRails::GroupedCollection.new
-        params[:group] = 'true'
-        params[:rows] = 10_000
-        params['group.field'] = @group_value
-        params['group.limit'] = @per_page_value
-        params['group.offset'] = (@page_value - 1) * @per_page_value
-        params['group.ngroups'] = 'false' # must be false due to issues with solr sharding
-        solr_response = rsolr.post('select', data: params)
-        response = solr_response['grouped'][@group_value.to_s]
-        results.total_groups = response['groups'].size
-        results.total_for_all = response['matches'].to_i
-        results.total_entries = 0
-        response['groups'].each do |group|
-          results[group['groupValue']] = parse_docs(group['doclist'], select_columns)
-          if results[group['groupValue']].total_entries > results.total_entries
-            results.total_entries = results[group['groupValue']].total_entries
+      ActiveSupport::Notifications.instrument(
+         'solr.datastax_rails',
+         name:   'Search',
+         klass:  @klass.name,
+         search: params) do
+        if @group_value
+          results = DatastaxRails::GroupedCollection.new
+          params[:group] = 'true'
+          params[:rows] = 10_000
+          params['group.field'] = @group_value
+          params['group.limit'] = @per_page_value
+          params['group.offset'] = (@page_value - 1) * @per_page_value
+          params['group.ngroups'] = 'false' # must be false due to issues with solr sharding
+          solr_response = rsolr.post('select', data: params)
+          response = solr_response['grouped'][@group_value.to_s]
+          results.total_groups = response['groups'].size
+          results.total_for_all = response['matches'].to_i
+          results.total_entries = 0
+          response['groups'].each do |group|
+            results[group['groupValue']] = parse_docs(group['doclist'], select_columns)
+            if results[group['groupValue']].total_entries > results.total_entries
+              results.total_entries = results[group['groupValue']].total_entries
+            end
           end
+        else
+          solr_response = rsolr.paginate(@page_value, @per_page_value, 'select', data: params, method: :post)
+          response = solr_response['response']
+          results = parse_docs(response, select_columns)
+          results.highlights = solr_response['highlighting']
         end
-      else
-        solr_response = rsolr.paginate(@page_value, @per_page_value, 'select', data: params, method: :post)
-        response = solr_response['response']
-        pp solr_response if ENV['DEBUG_SOLR'] == 'true'
-        results = parse_docs(response, select_columns)
-        results.highlights = solr_response['highlighting']
-      end
-      if solr_response['stats']
-        @stats = solr_response['stats']['stats_fields'].with_indifferent_access
-      end
-      # Apply Facets if they exist
-      if solr_response['facet_counts']
-        results.facets = {}
-        results.facets = results.facets.merge(solr_response['facet_counts']['facet_fields'].to_h)
-        results.facets = results.facets.merge(solr_response['facet_counts']['facet_ranges'].to_h)
+        if solr_response['stats']
+          @stats = solr_response['stats']['stats_fields'].with_indifferent_access
+        end
+        # Apply Facets if they exist
+        if solr_response['facet_counts']
+          results.facets = {}
+          results.facets = results.facets.merge(solr_response['facet_counts']['facet_fields'].to_h)
+          results.facets = results.facets.merge(solr_response['facet_counts']['facet_ranges'].to_h)
+        end
+        results
       end
-      pp params if ENV['DEBUG_SOLR'] == 'true'
-      results
     end
 
     # Parse out a set of documents and return the results
@@ -610,9 +643,7 @@ module DatastaxRails
         value.split(/\bAND\b/).map do |a|
           a.split(/\bOR\b/).map do |o|
             o.split(/\bNOT\b/).map do |n|
-              n.split(/\bTO\b/).map do |t|
-                t.downcase
-              end.join('TO')
+              n.split(/\bTO\b/).map(&:downcase).join('TO')
             end.join('NOT')
           end.join('OR')
         end.join('AND').gsub(SOLR_DATE_REGEX) { Regexp.last_match[1].upcase }

data/lib/datastax_rails/scoping.rb

@@ -57,7 +57,7 @@ module DatastaxRails
       #   end
       #
       # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
-      def with_scope(scope = {}, action = :merge, &_block) # rubocop:disable Style/CyclomaticComplexity
+      def with_scope(scope = {}, action = :merge, &_block) # rubocop:disable Metrics/CyclomaticComplexity
         # If another DatastaxRails class has been passed in, get its current scope
         scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
         previous_scope = current_scope

data/lib/datastax_rails/serialization.rb

@@ -7,7 +7,7 @@ module DatastaxRails
     def serializable_hash(options = nil)
       options = options.try(:clone) || {}
 
-      options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+      options[:except] = Array.wrap(options[:except]).map(&:to_s)
 
       hash = super(options)
 
@@ -19,16 +19,20 @@ module DatastaxRails
                             end
       end
 
-      hash
-    end
+      serializable_convert_uuids(hash)
 
-    def as_json(options = {})
-      json = super(options)
-      json.each { |k, v| json[k] = v.to_s if v.is_a?(::Cql::Uuid) }
+      hash
     end
 
     private
 
+    def serializable_convert_uuids(hash)
+      hash.each do |k, v|
+        serializable_convert_uuids(v) if v.is_a?(Hash)
+        hash[k] = v.to_s if v.is_a?(::Cql::Uuid)
+      end
+    end
+
     # Add associations specified via the <tt>:include</tt> option.
     #
     # Expects a block that takes as arguments:

data/lib/datastax_rails/serializers/xml_serializer.rb

@@ -241,7 +241,9 @@ module DatastaxRails
                end
 
         { text: :string,
-          time: :datetime }[type] || type
+          time: :datetime,
+          set:  :array,
+          list: :array }[type] || type
       end
       protected :compute_type
     end

data/lib/datastax_rails/tasks/ds.rake

@@ -1,6 +1,6 @@
 namespace :ds do
-  task :configure => :environment do
-    datastax_config = ERB.new(Rails.root.join('config',"datastax.yml").read).result(binding)
+  task configure: :environment do
+    datastax_config = ERB.new(Rails.root.join('config', 'datastax.yml').read).result(binding)
     @configs = YAML.load(datastax_config)
     @config = @configs[Rails.env || 'development']
     @migrator = DatastaxRails::Schema::Migrator.new(@config['keyspace'])
@@ -8,72 +8,71 @@ namespace :ds do
 
   desc 'Create the keyspace in config/datastax.yml for the current environment'
   task :create do
-    datastax_config = ERB.new(Rails.root.join('config',"datastax.yml").read).result(binding)
+    datastax_config = ERB.new(Rails.root.join('config', 'datastax.yml').read).result(binding)
     @configs = YAML.load(datastax_config)
     @config = @configs[Rails.env || 'development']
-    DatastaxRails::Base.establish_connection(@config.with_indifferent_access.merge(:keyspace => 'system'))
+    DatastaxRails::Base.establish_connection(@config.with_indifferent_access.merge(keyspace: 'system'))
     DatastaxRails::Schema::Migrator.new('system').create_keyspace(@config['keyspace'], @config)
   end
 
   desc 'Drop keyspace in config/datastax.yml for the current environment'
-  task :drop => :configure do
+  task drop: :configure do
     @migrator.drop_keyspace
   end
 
   desc 'Migrate keyspace to latest version -- pass in model name to force an upload of just that one (all force-uploads everything).'
-  task :migrate, [:force_cf] => :configure do |t, args|
+  task :migrate, [:force_cf] => :configure do |_t, args|
     if args[:force_cf].blank?
       @migrator.migrate_all
     else
       args[:force_cf] == 'all' ? @migrator.migrate_all(true) : @migrator.migrate_one(args[:force_cf].constantize, true)
     end
   end
-  
+
   desc 'Alias for ds:migrate to maintain backwards-compatibility'
   task :schema, [:force_cf] => :migrate
-  
+
   desc 'Rebuild SOLR Index -- pass in a model name (all rebuilds everything)'
-  task :reindex, [:model] => :configure do |t, args|
+  task :reindex, [:model] => :configure do |_t, args|
     if args[:model].blank?
       puts "\nUSAGE: rake ds:reindex[Model]"
     else
       @migrator.reindex_solr(args[:model].constantize)
     end
   end
-  
+
   desc 'Create SOLR Core (Normally not needed) -- pass in a model name (all creates everything)'
-  task :create_core, [:model] => :configure do |t, args|
+  task :create_core, [:model] => :configure do |_t, args|
     if args[:model].blank?
       puts "\nUSAGE: rake ds:create_core[Model]"
     else
       @migrator.create_solr_core(args[:model].constantize)
     end
   end
-  
+
   desc 'Load the seed data from ks/seeds.rb'
-  task :seed => :environment do
-    seed_file = Rails.root.join("ks","seeds.rb")
+  task seed: :environment do
+    seed_file = Rails.root.join('ks', 'seeds.rb')
     load(seed_file) if seed_file.exist?
   end
-  
-  if(defined?(ParallelTests))
+
+  if defined?(ParallelTests)
     namespace :parallel do
-      desc "create test keyspaces via ds:create --> ds:parallel:create[num_cpus]"
-      task :create, :count do |t,args|
+      desc 'create test keyspaces via ds:create --> ds:parallel:create[num_cpus]'
+      task :create, :count do |_t, args|
         ParallelTests::Tasks.run_in_parallel("rake ds:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
       end
-      
-      desc "drop test keyspaces via ds:drop --> ds:parallel:drop[num_cpus]"
-      task :drop, :count do |t,args|
+
+      desc 'drop test keyspaces via ds:drop --> ds:parallel:drop[num_cpus]'
+      task :drop, :count do |_t, args|
         ParallelTests::Tasks.run_in_parallel("rake ds:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
       end
-      
-      desc "update test keyspaces via ds:migrate --> ds:parallel:migrate[num_cpus]"
-      task :migrate, :count do |t,args|
-        args = args.to_hash.merge(:non_parallel => true)
+
+      desc 'update test keyspaces via ds:migrate --> ds:parallel:migrate[num_cpus]'
+      task :migrate, :count do |_t, args|
+        args = args.to_hash.merge(non_parallel: true)
         ParallelTests::Tasks.run_in_parallel("rake ds:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
       end
     end
   end
 end
-

data/lib/datastax_rails/timestamps.rb

@@ -79,7 +79,7 @@ module DatastaxRails
 
     def max_updated_column_timestamp
       if (timestamps = timestamp_attributes_for_update.map { |attr| self[attr] }.compact).present?
-        timestamps.map { |ts| ts.to_time }.max
+        timestamps.map(&:to_time).max
       end
     end
 

data/lib/datastax_rails/types/dynamic_set.rb

@@ -5,6 +5,10 @@ module DatastaxRails
     # built-in change tracking.
     class DynamicSet < Set
       include DirtyCollection
+
+      delegate :join, :[], :to_xml, to: :to_a
+
+      alias_method :to_ary, :to_a
     end
   end
 end

data/lib/datastax_rails/version.rb

@@ -1,4 +1,4 @@
 # rubocop:disable Style/Documentation
 module DatastaxRails
-  VERSION = '2.0.18'
+  VERSION = '2.1.23'
 end

data/lib/datastax_rails/wide_storage_model.rb

@@ -27,7 +27,9 @@ module DatastaxRails
 
     # Returns a primary key hash for updates that includes the cluster key
     def id_for_update
-      { self.class.primary_key.to_s => id, self.class.cluster_by.to_s => read_attribute(self.class.cluster_by.to_s) }
+      cc = self.class.column_for_attribute(self.class.cluster_by)
+      { self.class.primary_key.to_s => __id,
+        self.class.cluster_by.to_s  => cc.type_cast_for_cql3(read_attribute(self.class.cluster_by.to_s)) }
     end
   end
 end

data/lib/datastax_rails.rb

@@ -99,6 +99,7 @@ end
 
 require 'datastax_rails/railtie' if defined?(Rails)
 require 'datastax_rails/errors'
+require 'datastax_rails/instrumentation' if defined?(Rails)
 require 'cql-rb_extensions'
 
 ActiveSupport.run_load_hooks(:datastax_rails, DatastaxRails::Base)

data/spec/datastax_rails/attribute_methods/read_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe DatastaxRails::Base do
+  context 'attribute methods' do
+    context 'read' do
+      context 'overrides' do
+        subject { CollectionOverride.new }
+
+        context 'lists' do
+          before do
+            subject.list1 = ['foo']
+            subject.list2 = ['bar']
+          end
+
+          it 'returns the correct values before a save' do
+            expect(subject.read_attribute(:list1)).to eq(['foo'])
+            expect(subject.read_attribute(:list2)).to eq(['bar'])
+            expect(subject.list1).to eq(['FOO'])
+            expect(subject.list2).to eq(['BAR'])
+          end
+
+          it 'returns the correct values after a save' do
+            subject.save
+            expect(subject.read_attribute(:list1)).to eq(['FOO'])
+            expect(subject.read_attribute(:list2)).to eq(['bar'])
+            expect(subject.list1).to eq(['FOO'])
+            expect(subject.list2).to eq(['BAR'])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/datastax_rails/attribute_methods/typecasting_spec.rb

@@ -9,10 +9,21 @@ describe DatastaxRails::Base do
       its(:bool) { is_expected.to be(true) }
       its(:bool2) { is_expected.to be(false) }
       its(:bool3) { is_expected.to be_nil }
+      its(:version) { is_expected.to be(1) }
+      its(:complexity) { is_expected.to be(0.0) }
+      its(:previous_id) { is_expected.to eq('00000000-0000-0000-0000-000000000000') }
+      its(:epoch) { is_expected.to eq(Date.parse('1970-01-01')) }
+      its(:epoch2) { is_expected.to eq(Time.parse('1970-01-01 00:00:00')) }
+
       its(:changed_attributes) { is_expected.to include('str') }
       its(:changed_attributes) { is_expected.to include('bool') }
       its(:changed_attributes) { is_expected.to include('bool2') }
       its(:changed_attributes) { is_expected.not_to include('bool3') }
+      its(:changed_attributes) { is_expected.to include('version') }
+      its(:changed_attributes) { is_expected.to include('complexity') }
+      its(:changed_attributes) { is_expected.to include('previous_id') }
+      its(:changed_attributes) { is_expected.to include('epoch') }
+      its(:changed_attributes) { is_expected.to include('epoch2') }
 
       context 'setting the attribute to the default' do
         before { subject.bool = true }
@@ -20,6 +31,20 @@ describe DatastaxRails::Base do
         its(:bool) { is_expected.to be(true) }
         its(:changed_attributes) { is_expected.to include('bool') }
       end
+
+      context 'collections' do
+        context 'when not specified' do
+          its(:m) { is_expected.to eq({}) }
+          its(:s) { is_expected.to eq(Set.new) }
+          its(:l) { is_expected.to eq([]) }
+        end
+
+        context 'when specified' do
+          its(:m2) { is_expected.to eq('m2test' => 'string') }
+          its(:s2) { is_expected.to eq(Set.new(['unique string'])) }
+          its(:l2) { is_expected.to eq(['ordered string']) }
+        end
+      end
     end
   end
 end

data/spec/datastax_rails/base_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe DatastaxRails::Base do
   it 'should raise RecordNotFound when finding a bogus ID' do
-    expect { Person.find('xyzzy') }.to raise_exception(DatastaxRails::RecordNotFound)
+    expect { Person.find(::Cql::TimeUuid::Generator.new.next) }.to raise_exception(DatastaxRails::RecordNotFound)
   end
 
   describe 'equality' do

data/spec/datastax_rails/callbacks_spec.rb

@@ -33,6 +33,12 @@ describe DatastaxRails::Base do
         expect(subject).to receive(callback + '_callback')
         subject.destroy
       end
+
+      it 'provides a method to run without callbacks' do
+        subject.save
+        expect(subject).not_to receive(callback + '_callback')
+        subject.destroy_without_callbacks
+      end
     end
 
     it 'runs after_find' do

data/spec/datastax_rails/column_spec.rb

@@ -212,6 +212,10 @@ describe DatastaxRails::Column do
         expect(c.type_cast({ 'field_key' => '7' }, record)).to be_a(DatastaxRails::Types::DynamicMap)
       end
 
+      it 'casts nil to an empty hash' do
+        expect(c.type_cast(nil, record)).to eq({})
+      end
+
       describe 'to cql' do
         it 'casts map values to the appropriate type' do
           date = Date.parse('1980-10-19')
@@ -231,6 +235,14 @@ describe DatastaxRails::Column do
       it 'wraps list values in a DynamicList' do
         expect(c.type_cast([1, '2', 6.minutes], record)).to be_a(DatastaxRails::Types::DynamicList)
       end
+
+      it 'casts nil to an empty array' do
+        expect(c.type_cast(nil, record)).to eq([])
+      end
+
+      it 'casts a scalar value to a list' do
+        expect(c.type_cast(1, record)).to eq([1])
+      end
     end
 
     describe 'set' do
@@ -243,6 +255,14 @@ describe DatastaxRails::Column do
       it 'wraps list values in a DynamicSet' do
         expect(c.type_cast([1, '2', 6.minutes, 2], record)).to be_a(DatastaxRails::Types::DynamicSet)
       end
+
+      it 'casts nil to an empty set' do
+        expect(c.type_cast(nil, record)).to eq(Set.new)
+      end
+
+      it 'casts a scalar value to a set' do
+        expect(c.type_cast(1, record)).to eq(Set.new([1]))
+      end
     end
   end
 end

data/spec/datastax_rails/cql/base_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe DatastaxRails::Cql::Base do
   it 'caches prepared statements' do
-    expect(DatastaxRails::Base.connection).to receive(:prepare).once.and_return(double('statement', execute: true))
+    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

data/spec/datastax_rails/cql/select_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe DatastaxRails::Cql::Select do
-  let(:model_class) { double('Model Class', column_family: 'users', default_consistency: DatastaxRails::Cql::Consistency::QUORUM) }
+  let(:model_class) { double('Model Class', column_family: 'users', primary_key: 'id', default_consistency: DatastaxRails::Cql::Consistency::QUORUM) }
 
   it 'should generate valid CQL' do
     cql = DatastaxRails::Cql::Select.new(model_class, ['*'])
@@ -9,5 +9,11 @@ describe DatastaxRails::Cql::Select do
     expect(cql.to_cql).to eq("SELECT * FROM users WHERE \"key\" = ? LIMIT 1 ")
   end
 
+  it 'ignores multiple values for non-primary-key' do
+    cql = DatastaxRails::Cql::Select.new(model_class, ['*'])
+    cql.using(DatastaxRails::Cql::Consistency::QUORUM).conditions(key: %w(12345 67890)).limit(1)
+    expect(cql.to_cql).to eq("SELECT * FROM users WHERE \"key\" = ? LIMIT 1 ")
+  end
+
   it_has_behavior 'default_consistency'
 end

data/spec/datastax_rails/persistence_spec.rb

@@ -72,14 +72,24 @@ describe 'DatastaxRails::Base' do
         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 = Person.find_by(name: 'Steven')
           p.birthdate = nil
           p.save
           Person.commit_solr
-          Person.find by_name('Steven').birthdate.should be_nil
+          expect(Person.find_by(name: 'Steven').birthdate).to be_nil
+        end
+
+        it 'keeps existing attributes from being deleted' do
+          p = Person.create!(name: 'Jacob', birthdate: Date.today)
+          p.nickname = 'Jake'
+          p.save
+          Person.commit_solr
+          p2 = Person.find_by(name: 'Jacob')
+          expect(p2.name).to eql('Jacob')
+          expect(p2.nickname).to eql('Jake')
+          expect(p2.birthdate).to eql(Date.today)
         end
       end
     end
@@ -106,5 +116,14 @@ describe 'DatastaxRails::Base' do
         expect(CarPayload.find('limo').payload).to eq(smallfile)
       end
     end
+
+    describe '#write_attribute' do
+      let(:person) { create(:person) }
+
+      it 'writes an attribute directly to the database' do
+        Person.write_attribute(person, birthdate: Date.today)
+        expect(Person.find(person.id).birthdate).to eq(Date.today)
+      end
+    end
   end
 end

data/spec/datastax_rails/relation/finder_methods_spec.rb

@@ -116,5 +116,18 @@ describe DatastaxRails::Relation do
       Boat.commit_solr
       expect(Boat.find_by(name: 'Dumb: Name')).not_to be_nil
     end
+
+    it 'does not interpret wildcards' do
+      Boat.create(name: 'Water Lily')
+      Boat.commit_solr
+      expect(Boat.find_by(name: 'Wat*')).to be_nil
+    end
+
+    it 'finds a record by an attribute with a wildcard in it' do
+      Boat.create(name: 'L*ly')
+      Boat.commit_solr
+      Boat.commit_solr
+      expect(Boat.find_by(name: 'L*ly')).not_to be_nil
+    end
   end
 end