datastax_rails 1.1.0.3 → 1.2.3

data/lib/datastax_rails/types/date_type.rb

@@ -1,7 +1,7 @@
 module DatastaxRails
   module Types
     class DateType < BaseType
-      DEFAULTS = {:solr_type => 'date', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false}
+      DEFAULTS = {:solr_type => 'date', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false, :cassandra_type => 'timestamp'}
       FORMAT = '%Y-%m-%dT%H:%M:%SZ'
 
       def encode(value)

data/lib/datastax_rails/types/float_type.rb

@@ -1,16 +1,16 @@
 module DatastaxRails
   module Types
     class FloatType < BaseType
-      DEFAULTS = {:solr_type => 'float', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false}
+      DEFAULTS = {:solr_type => 'float', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false, :cassandra_type => 'float'}
       REGEX = /\A[-+]?(\d+(\.\d+)?|\.\d+)\Z/
       def encode(float)
-        return -10191980.0 if float.blank?
+        return "-10191980.0" if float.blank?
         raise ArgumentError.new("#{self} requires a Float. You passed #{float.to_s}") unless float.kind_of?(Float) || (float.kind_of?(String) && float.match(REGEX)) || float.kind_of?(Fixnum)
-        float.to_f
+        float.to_f.to_s
       end
 
       def decode(float)
-        return nil if float.blank? || (float.to_f < -10191979.9 && float.to_f > -10191980.1)
+        return nil if float.blank? || float.to_s == '-10191980.0' 
         float.to_f
       end
     end

data/lib/datastax_rails/types/integer_type.rb

@@ -1,12 +1,12 @@
 module DatastaxRails
   module Types
     class IntegerType < BaseType
-      DEFAULTS = {:solr_type => 'int', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false}
+      DEFAULTS = {:solr_type => 'int', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false, :cassandra_type => 'int'}
       REGEX = /\A[-+]?\d+\Z/
       def encode(int)
-        return -10191980 if int.blank?
+        return "-10191980" if int.blank?
         raise ArgumentError.new("#{self} requires an Integer. You passed #{int.to_s}") unless int.kind_of?(Integer) || (int.kind_of?(String) && int.match(REGEX)) 
-        int.to_i
+        int.to_i.to_s
       end
 
       def decode(int)

data/lib/datastax_rails/types/string_type.rb

@@ -1,7 +1,7 @@
 module DatastaxRails
   module Types
     class StringType < BaseType
-      DEFAULTS = {:solr_type => 'string', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => true}
+      DEFAULTS = {:solr_type => 'string', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => true, :cassandra_type => 'text'}
       def encode(str)
         str = "" unless str
         str.to_s

data/lib/datastax_rails/types/text_type.rb

@@ -1,7 +1,7 @@
 module DatastaxRails
   module Types
     class TextType < BaseType
-      DEFAULTS = {:solr_type => 'text', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => false, :tokenized => true, :fulltext => true}
+      DEFAULTS = {:solr_type => 'text', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => false, :tokenized => true, :fulltext => true, :cassandra_type => 'text'}
       def encode(str)
         str.to_s.dup
       end

data/lib/datastax_rails/types/time_type.rb

@@ -1,18 +1,18 @@
 module DatastaxRails
   module Types
     class TimeType < BaseType
-      DEFAULTS = {:solr_type => 'date', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false}
+      DEFAULTS = {:solr_type => 'date', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false, :cassandra_type => 'timestamp'}
       FORMAT = "%Y-%m-%dT%H:%M:%SZ"
 
       def encode(time)
         return unless time
         raise ArgumentError.new("#{self} requires a Time") unless time.kind_of?(Time)
-        time.strftime(FORMAT)
+        time.utc.strftime(FORMAT)
       end
 
       def decode(str)
         return str if str.kind_of?(Time)
-        Time.parse(str) rescue nil
+        Time.zone.parse(str) rescue nil
       end
       
       def full_solr_range

data/lib/datastax_rails/validations/uniqueness.rb

@@ -17,7 +17,7 @@ module DatastaxRails
         #      are implemented in datastax_rails (such as STI)
         finder_class = record.class
         
-        scope = finder_class.unscoped.where(attribute => value)
+        scope = finder_class.where(attribute => value)
         scope = scope.where_not(:id => record.id) if record.persisted?
         
         Array.wrap(options[:scope]).each do |scope_item|

data/lib/datastax_rails/version.rb

@@ -1,4 +1,4 @@
 module DatastaxRails
   # The current version of the gem
-  VERSION = "1.1.0.3"
+  VERSION = "1.2.3"
 end

data/lib/datastax_rails/wide_storage_model.rb

@@ -0,0 +1,44 @@
+module DatastaxRails
+  # A special model that is designed to efficiently store very wide data.
+  # This model type assumes that you have a unique ID and want to either
+  # search or sort on a second piece of data.  The store the data as a
+  # single, very wide row; however you can safely treat them as if
+  # there were multiple rows.
+  #
+  # CAVEATS: 
+  # * Wide Storage Models cannot be indexed into Solr.
+  # * Once the cluster is set, it cannot be changed as it becomes the column header in Cassandra
+  #
+  #   class AuditLog < DatastaxRails::WideStorageModel
+  #     self.column_family = 'audit_logs'
+  #
+  #     key :natural, :attributes => [:uuid]
+  #     cluster_by :created_at => :desc
+  #
+  #     string :uuid
+  #     string :message
+  #     timestamps
+  #   end
+  class WideStorageModel < CassandraOnlyModel
+    self.abstract_class = true
+    
+    def self.cluster_by(attr = nil)
+      @cluster_by ||= attr.is_a?(Hash) ? attr : {attr => :asc}
+    end
+    
+    def self.write(key, attributes, options = {})
+      attributes = encode_attributes(attributes)
+      level = (options[:consistency] || self.default_consistency).to_s.upcase
+      if(valid_consistency?(level))
+        options[:consistency] = level
+      else
+        raise ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
+      end
+      key.tap do |key|
+        ActiveSupport::Notifications.instrument("insert.datastax_rails", :column_family => column_family, :key => key, :attributes => attributes) do
+            cql.insert.using(level).columns(attributes).execute
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails.rb

@@ -8,16 +8,19 @@ module DatastaxRails
   extend ActiveSupport::Autoload
   
   autoload :Associations
+  autoload :AttributeAssignment
   autoload :AttributeMethods
   autoload :Base
   autoload :Batches
   autoload :Callbacks
+  autoload :CassandraOnlyModel
   autoload :Collection
   autoload :Connection
   autoload :Cql
   autoload :GroupedCollection
   autoload :Identity
-  autoload :Migrations
+  autoload :Index
+  autoload :Inheritance
   autoload :PayloadModel
   autoload :Persistence
   autoload :Reflection
@@ -30,6 +33,7 @@ module DatastaxRails
     autoload :SpawnMethods
     autoload :StatsMethods
     autoload :Batches
+    autoload :FacetMethods
   end
   
   autoload :RSolrClientWrapper, 'datastax_rails/rsolr_client_wrapper'
@@ -42,6 +46,8 @@ module DatastaxRails
     autoload :SolrRepair
   end
   autoload :Validations
+  autoload :Version
+  autoload :WideStorageModel
   
   module AttributeMethods
     extend ActiveSupport::Autoload
@@ -52,6 +58,15 @@ module DatastaxRails
       autoload :Typecasting
     end
   end
+  
+  module Scoping
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Named
+      autoload :Default
+    end
+  end
 
   module Tasks
     extend ActiveSupport::Autoload
@@ -77,23 +92,6 @@ module DatastaxRails
   end
 end
 
-require "thrift"
-# Thrift is how we communicate with Cassandra.  We need to do a little fixup
-# work to handle UTF-8 properly in Ruby 1.8.6.
-# module Thrift
-  # class BinaryProtocol
-    # def write_string(str)
-      # if(str.respond_to?(:bytesize))
-        # size = str.bytesize
-      # else
-        # size = str.size
-      # end
-      # write_i32(size)
-      # trans.write(str)
-    # end
-  # end
-# end
-
 require 'datastax_rails/railtie' if defined?(Rails)
 require 'datastax_rails/errors'
 

data/spec/datastax_rails/associations_spec.rb

@@ -1,18 +1,22 @@
 require 'spec_helper'
 
 describe DatastaxRails::Base do
-  describe "Relations" do
+  describe "Associations" do
     describe "belongs_to" do
       it "should set the id when setting the object" do
         person = Person.create(:name => "Jason")
         job = Job.create(:title => "Developer")
+        Person.commit_solr
         job.person = person
         job.person_id.should == person.id
       end
       
       it "should look up the owning model by id" do
-        person = Person.create(:name => "John")
-        job = Job.create(:title => "Developer", :person_id => person.id)
+        Job.truncate
+        Job.commit_solr
+        person = Person.create!(:name => "John")
+        job = Job.create!(:title => "Developer", :person_id => person.id)
+        Person.commit_solr
         Person.commit_solr
         Job.commit_solr
         Job.first.person.should == person

data/spec/datastax_rails/attribute_methods_spec.rb

@@ -5,6 +5,11 @@ class AttributeMethodsTester < DatastaxRails::Base
   string :non_search_string, :searchable => false
 end 
 
+class CassandraOnlyTester < DatastaxRails::CassandraOnlyModel
+  string :test_string
+  string :test_string2, :indexed => :both
+end
+
 describe DatastaxRails::Base do
   def tester
     @tester ||= AttributeMethodsTester.new
@@ -20,4 +25,22 @@ describe DatastaxRails::Base do
     end
   end
   
+  describe "#attribute" do
+    context "Cassandra-only models" do
+      it "does not index columns by default" do
+        expect(CassandraOnlyTester.attribute_definitions[:test_string].coder.options[:indexed]).to be_false
+      end
+      
+      it "does not index into solr" do
+        expect(CassandraOnlyTester.attribute_definitions[:test_string2].coder.options[:indexed]).to eq(:cassandra)
+      end
+    end
+    
+    context "Normal models" do
+      it "indexes data into solr by default" do
+        expect(AttributeMethodsTester.attribute_definitions[:test_string].coder.options[:indexed]).to eq(:solr)
+      end
+    end
+  end
+  
 end

data/spec/datastax_rails/base_spec.rb

@@ -8,6 +8,7 @@ describe DatastaxRails::Base do
   end
   
   it "should run after_save" do
+    Person.commit_solr
     p = Person.new(:name => "Jason")
     p.save!
     p.instance_variable_get(:@after_save_ran).should == "yup"
@@ -16,10 +17,4 @@ describe DatastaxRails::Base do
   it "should raise RecordNotFound when finding a bogus ID" do
     lambda { Person.find("xyzzy") }.should raise_exception(DatastaxRails::RecordNotFound)
   end
-  
-  xit "should skip records that are missing dsr in cassandra" do
-    p = Person.create(:name => 'Jason')
-    Person.cql.delete(p.id).columns(['dsr']).execute
-    Person.find_by_name('Jason').should be_nil
-  end
 end

data/spec/datastax_rails/inheritance_spec.rb

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

data/spec/datastax_rails/persistence_spec.rb

@@ -2,6 +2,16 @@ require 'spec_helper'
 
 describe "DatastaxRails::Base" do
   describe "persistence" do
+    describe "#update_attributes" do
+      it "only overwrites attributes that are passed in as part of the hash" do
+        person = Person.create(:name => 'Jason', :birthdate => Date.parse("Oct 19, 1981"), :nickname => 'Jas')
+        person.birthdate = Date.parse("Oct 19, 1980")
+        person.update_attributes(:nickname => 'Jace')
+        person.birthdate.should eql(Date.parse("Oct 19, 1980"))
+        person.nickname.should eql('Jace')
+      end
+    end
+    
     describe "with cql" do
       describe "#create" do
         it "should persist at the given consistency level" do
@@ -62,19 +72,19 @@ describe "DatastaxRails::Base" do
     end
     
     describe "#store_file" do
-      it "should store a file" do
+      it "should store a file", :slow => true do
         file = "abcd"*1.megabyte
         CarPayload.create(:digest => 'limo', :payload => file)
         CarPayload.find('limo').payload.should == file
       end
       
-      it "should store really large files" do
+      it "should store really large files", :slow => true do
         file = IO.read("/dev/zero", 25.megabyte)
         CarPayload.create(:digest => 'limo', :payload => file)
         CarPayload.find('limo').payload.should == file
       end
       
-      it "should successfully overwrite a larger file with a smaller one" do
+      it "should successfully overwrite a larger file with a smaller one", :slow => true do
         file = "abcd"*1.megabyte
         car = CarPayload.create(:digest => 'limo', :payload => file)
         smallfile = "e"*1.kilobyte

data/spec/datastax_rails/relation/batches_spec.rb

@@ -8,12 +8,12 @@ describe DatastaxRails::Relation do
       sleep(1) if idx % 5 == 4 # Performance hack
     end
     Hobby.commit_solr
-    Hobby.commit_solr
   end
   
   ['cassandra', 'solr'].each do |method|
     describe "#find_each" do
       it "returns each record one at a time with #{method}" do
+        sleep(1)
         missed_hobbies = ('a'..'l').to_a
         @relation.send('with_'+method).find_each(:batch_size => 5) do |hobby|
           missed_hobbies.delete_if {|h| h == hobby.name}

data/spec/datastax_rails/relation/facet_methods_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe DatastaxRails::Relation do
+  before(:each) do
+    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+  end
+
+  describe "#field_facet" do
+    
+    it "should return facets on a field" do
+      Hobby.create(:name => 'skiing')
+      Hobby.create(:name => 'boating')
+      Hobby.create(:name => 'fishing')
+      Hobby.create(:name => 'skiing')
+      Hobby.commit_solr
+      @relation.field_facet(:name).all.facets['name'].should == ["skiing", 2, "boating", 1, "fishing", 1]
+    end
+    
+    it "should allow options to be specified" do
+      Hobby.create(:name => 'skiing')
+      Hobby.create(:name => 'singing')
+      Hobby.create(:name => 'reading')
+      Hobby.commit_solr
+      @relation.field_facet(:name, :prefix => 's').all.facets['name'].should == ["singing", 1, "skiing", 1]
+    end
+    
+  end
+
+  describe "#range_facet" do
+    
+    it "should return facets on a field" do
+      Hobby.create(:complexity => 1.0)
+      Hobby.create(:complexity => 5.0)
+      Hobby.create(:complexity => 8.0)
+      Hobby.create(:complexity => 9.0)
+      Hobby.create(:complexity => 10.0)
+      Hobby.commit_solr
+      @relation.range_facet(:complexity, 1.0, 10.0, 2.0).all.facets['complexity'].should == {"counts"=>["1.0", 1, "3.0", 0, "5.0", 1, "7.0", 1, "9.0", 2], "gap"=>2.0, "start"=>1.0, "end"=>11.0}
+    end
+
+    it "should allow options to be specified" do
+      Hobby.create(:complexity => 1.0)
+      Hobby.create(:complexity => 5.0)
+      Hobby.create(:complexity => 8.0)
+      Hobby.create(:complexity => 9.0)
+      Hobby.create(:complexity => 10.0)
+      Hobby.commit_solr
+      @relation.range_facet(:complexity, 1.0, 10.0, 2.0, :include => 'upper').all.facets['complexity'].should == {"counts"=>["1.0", 0, "3.0", 1, "5.0", 0, "7.0", 2, "9.0", 1], "gap"=>2.0, "start"=>1.0, "end"=>11.0}
+    end
+         
+  end            
+end

data/spec/datastax_rails/relation/finder_methods_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe DatastaxRails::Relation do
   before(:each) do
     @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    Hobby.commit_solr
   end
   
   describe "#first" do
@@ -56,7 +57,7 @@ describe DatastaxRails::Relation do
     it "finds a record by an attribute" do
       Boat.create(:name => 'Spooner')
       Boat.commit_solr
-      Boat.find_by_name('Spooner').should_not be_nil
+      Boat.find_all_by_name('Spooner').should_not be_nil
     end
 
     it "finds a record by an attribute with a space in it" do
@@ -71,4 +72,24 @@ describe DatastaxRails::Relation do
       Boat.find_by_name('Dumb: Name').should_not be_nil
     end
   end
+  
+  describe "#find_by" do
+    it "finds a record by an attribute" do
+      Boat.create(:name => 'Spooner')
+      Boat.commit_solr
+      Boat.find_by(name: 'Spooner').should_not be_nil
+    end
+
+    it "finds a record by an attribute with a space in it" do
+      Boat.create(:name => 'Water Lily')
+      Boat.commit_solr
+      Boat.find_by(name: 'Water Lily').should_not be_nil
+    end
+
+    it "finds a record by an attribute with a colon in it" do
+      Boat.create(:name => 'Dumb: Name')
+      Boat.commit_solr
+      Boat.find_by(name: 'Dumb: Name').should_not be_nil
+    end
+  end
 end

data/spec/datastax_rails/relation/search_methods_spec.rb

@@ -58,13 +58,29 @@ describe DatastaxRails::Relation do
     
     it "should return items in descending order" do
       %w[fishing hiking boating jogging swimming chess].each do |word|
-        Hobby.create(:name => word)
+        Hobby.create!(:name => word)
       end
       @relation.commit_solr
       @relation.order(:name => :desc).collect {|h| h.name}.should == %w[swimming jogging hiking fishing chess boating]
     end
   end
   
+  describe "#slow_order" do
+    it "should manually order items coming from Cassandra" do
+      %w[john jason michael tony billy jim phil].each_with_index do |name,i|
+        AuditLog.create!(:uuid => "c1401540-f092-11e2-9001-6a5ab73a986#{i}", :user => name, :message => 'changed')
+      end
+      AuditLog.unscoped.slow_order(:user => :asc).collect {|log| log.user}.should == %w[billy jason jim john michael phil tony]
+    end
+    
+    it "should manually order items coming from Cassandra in descending order" do
+      %w[john jason michael tony billy jim phil].each_with_index do |name,i|
+        AuditLog.create!(:uuid => "c1401540-f092-11e2-9001-6a5ab73a986#{i}", :user => name, :message => 'changed')
+      end
+      AuditLog.unscoped.slow_order(:user => :desc).collect {|log| log.user}.should == %w[tony phil michael john jim jason billy]
+    end
+  end
+  
   describe "#where" do
     it "should return documents where a field is nil (does not exist)" do
       Hobby.create(:name => 'Swimming')
@@ -186,4 +202,38 @@ describe DatastaxRails::Relation do
       @relation.fulltext("swimming").should_not be_empty
     end
   end
+  
+  describe '#highlight' do
+    let(:hl) { @relation.highlight(:name, :description, :snippet => 3, :fragsize => 200) }
+    
+    it { expect(hl.highlight_options[:fields]).to eq [:name, :description] }
+    it { expect(hl.highlight_options[:snippet]).to eq 3 }
+    it { expect(hl.highlight_options[:fragsize]).to eq 200 }
+    
+    context 'with duplicate fields' do
+      let(:hl) { @relation.highlight(:name, :description, :name) }
+      
+      it { expect(hl.highlight_options[:fields]).to eq [:name, :description] }
+    end
+  end
+  
+  describe '#solr_format' do
+    context 'when formatting Time' do
+      let(:time) { Time.new 2011, 10, 9, 8, 7, 6, "-05:00" }
+      
+      it { expect(@relation.solr_format(time)).to eq '2011-10-09T13:07:06Z' }
+    end
+    
+    context 'when formatting Date' do
+      let(:date) { Date.new 2001, 2, 3 }
+      
+      it { expect(@relation.solr_format(date)).to eq '2001-02-03T00:00:00Z' }
+    end
+    
+    context 'when formatting DateTime' do
+      let(:datetime) { DateTime.new 2001, 2, 3, 4, 5, 6, "-07:00" }
+      
+      it { expect(@relation.solr_format(datetime)).to eq '2001-02-03T11:05:06Z' }
+    end
+  end
 end

data/spec/datastax_rails/relation_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 describe DatastaxRails::Relation do
   before(:each) do
     @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation.default_scoped = true
+    @relation.commit_solr
   end
   
   describe "#==" do
@@ -30,14 +32,16 @@ describe DatastaxRails::Relation do
     end
     
     it "should cache the total count on any solr query" do
-      @relation.should_receive(:query_via_solr).and_return(mock("ResultSet", :total_entries => 42))
+      @relation = @relation.with_solr
+      @relation.should_receive(:query_via_solr).and_return(double("ResultSet", :total_entries => 42))
       @relation.all
       @relation.count.should == 42
     end
     
     it "should execute a fast search to determine the count" do
-      mock_relation = mock(DatastaxRails::Relation)
+      mock_relation = double(DatastaxRails::Relation)
       mock_relation.stub_chain(:select, :to_a, :total_entries).and_return(37)
+      @relation = @relation.with_solr
       @relation.should_receive(:limit).with(1).and_return(mock_relation)
       @relation.count.should == 37
     end
@@ -62,6 +66,12 @@ describe DatastaxRails::Relation do
       relation.count.should == 0
       relation.default_scope.count.should == 1
     end
+    
+    it "should return a relation that has a default scope set" do
+      relation = DatastaxRails::Relation.new(Boat, "boats")
+      relation.default_scoped = true
+      relation.default_scope.order_values.should_not be_empty
+    end
   end
   
   describe "#empty?" do
@@ -130,6 +140,7 @@ describe DatastaxRails::Relation do
   
   describe "grouped queries" do
     before(:each) do
+      Person.commit_solr
       Person.create(:name => 'John', :nickname => 'J')
       Person.create(:name => 'Jason', :nickname => 'J')
       Person.create(:name => 'James', :nickname => 'J')
@@ -146,7 +157,7 @@ describe DatastaxRails::Relation do
       results['steve'].should have(1).item
     end
     
-    it "should return total_entires as the highest value of any group" do
+    it "should return total_entries as the highest value of any group" do
       results = Person.group(:nickname).all
       results.total_entries.should eq(3)
     end