datastax_rails 1.2.3 → 2.0.3

data/lib/datastax_rails/validations/uniqueness.rb

@@ -7,10 +7,6 @@ module DatastaxRails
         super
       end
       
-      def setup(klass)
-        @klass = klass
-      end
-      
       def validate_each(record, attribute, value)
         return true if options[:allow_blank] && value.blank?
         # XXX: The following will break if/when abstract base classes

data/lib/datastax_rails/version.rb

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

data/lib/datastax_rails/wide_storage_model.rb

@@ -1,44 +1,28 @@
 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.
+  # This model type assumes that you have a unique ID that you want to
+  # store a lot of data about.  The data is stored as a single, very 
+  # wide row; however you can safely treat it as if there were multiple rows.
+  # A common example of this is a logs table
+  #
+  # You can also apply secondary indexes onto the other columns.
   #
   # 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
+  # * Once the cluster attribute 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
+  #     self.primary_key = :uuid
+  #     self.cluster_by = :created_at
+  #     # If you don't want the default ascending sort order
+  #     self.create_options = 'CLUSTERING ORDER BY (created_at DESC)' 
   #
   #     string :uuid
   #     string :message
+  #     string :user_id, :cql_index => true
   #     timestamps
   #   end
-  class WideStorageModel < CassandraOnlyModel
+  class WideStorageModel < DatastaxRails::Base
     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/schema_migration.rb

@@ -9,4 +9,8 @@ class SchemaMigration
   def self.column_family
     'schema_migrations'
   end
+  
+  def self.primary_key
+    'cf'
+  end
 end

data/spec/datastax_rails/associations_spec.rb

@@ -17,7 +17,6 @@ describe DatastaxRails::Base do
         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
       end

data/spec/datastax_rails/attribute_methods_spec.rb

@@ -2,12 +2,13 @@ require 'spec_helper'
 
 class AttributeMethodsTester < DatastaxRails::Base
   string :test_string
-  string :non_search_string, :searchable => false
+  string :non_search_string, :solr_index => false
 end 
 
-class CassandraOnlyTester < DatastaxRails::CassandraOnlyModel
+class CassandraOnlyTester < DatastaxRails::Base
+  include DatastaxRails::CassandraOnlyModel
   string :test_string
-  string :test_string2, :indexed => :both
+  string :test_string2, :cql_index => true
 end
 
 describe DatastaxRails::Base do
@@ -28,17 +29,19 @@ describe DatastaxRails::Base do
   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
+        expect(CassandraOnlyTester.attribute_definitions[:test_string].options[:solr_index]).to be_false
+        expect(CassandraOnlyTester.attribute_definitions[:test_string].options[:cql_index]).to be_false
       end
       
       it "does not index into solr" do
-        expect(CassandraOnlyTester.attribute_definitions[:test_string2].coder.options[:indexed]).to eq(:cassandra)
+        expect(CassandraOnlyTester.attribute_definitions[:test_string2].options[:solr_index]).to be_false
+        expect(CassandraOnlyTester.attribute_definitions[:test_string2].options[:cql_index]).to be_true
       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)
+        expect(AttributeMethodsTester.attribute_definitions[:test_string].options[:solr_index]).to be_true
       end
     end
   end

data/spec/datastax_rails/base_spec.rb

@@ -17,4 +17,30 @@ describe DatastaxRails::Base do
   it "should raise RecordNotFound when finding a bogus ID" do
     lambda { Person.find("xyzzy") }.should raise_exception(DatastaxRails::RecordNotFound)
   end
+  
+  describe "equality" do
+    it "considers new objects to be unequal" do
+      p1=Person.new(:name => 'John')
+      p2=Person.new(:name => 'John')
+      expect(p1).not_to eq(p2)
+    end
+    
+    it "considers a new object to be unequal to a saved object" do
+      p1=Person.create!(:name => 'John')
+      p2=Person.new(:name => 'John')
+      expect(p1).not_to eq(p2)
+    end
+    
+    it "considers two persisted objects to be equal if their primary keys are equal" do
+      p1=Person.create!(:name => 'John')
+      p2=Person.find(p1.id)
+      expect(p1).to eq(p2)
+    end
+    
+    it "considers two persisted objects to be unequal if they have different primary keys" do
+      p1=Person.create!(:name => 'John')
+      p2=Person.create!(:name => 'James')
+      expect(p1).not_to eq(p2)
+    end
+  end
 end

data/spec/datastax_rails/column_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe DatastaxRails::Column do
+  describe "type casting" do
+    let(:record) {double(Person, :changed_attributes => {}, :attributes => {})}
+    
+    describe "boolean" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "boolean")}
+      
+      describe "to ruby" do
+        it "casts '' to nil" do 
+          expect(c.type_cast('')).to be_nil
+        end
+        
+        it "casts nil to nil" do
+          expect(c.type_cast(nil)).to be_nil
+        end
+    
+        [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].each do |val|
+          it "casts #{val.inspect} to true" do
+            expect(c.type_cast(val)).to eq(true)
+          end
+        end
+        
+        [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF', ' ', "\u3000\r\n", "\u0000", 'SOMETHING RANDOM'].each do |val|
+          it "casts #{val.inspect} to false" do
+            expect(c.type_cast(val)).to eq(false)
+          end
+        end
+      end
+      
+      describe "to cql3" do
+        it "casts false to false" do
+          expect(c.type_cast_for_cql3(false)).to be_false
+        end
+        
+        it "casts true to true" do
+          expect(c.type_cast_for_cql3(true)).to be_true
+        end
+      end
+      
+      describe "to solr" do
+        it "casts false to 'false'" do
+          expect(c.type_cast_for_solr(false)).to eq('false')
+        end
+        
+        it "casts true to 'true'" do
+          expect(c.type_cast_for_solr(true)).to eq('true')
+        end
+      end
+    end
+    
+    describe "integer" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "integer")}
+      
+      describe "to ruby" do
+        [1,'1','1ignore','1.7',true].each do |val|
+          it "casts #{val.inspect} to true" do
+            expect(c.type_cast(val)).to eq(1)
+          end
+        end
+        
+        ['bad1','bad',false].each do |val|
+          it "casts #{val.inspect} to 0" do
+            expect(c.type_cast(val)).to eq(0)
+          end
+        end
+        
+        [nil,[1,2],{1 => 2},(1..2),Object.new,Float::NAN,(1.0/0.0)].each do |val|
+          it "casts #{val.inspect} to nil" do
+            expect(c.type_cast(val)).to be_nil
+          end
+        end
+        
+        it "casts a duration to an integer" do
+          expect(c.type_cast(30.minutes)).to be(1800)
+        end
+      end
+      
+      describe "to cql3" do
+        it "casts 1 to 1" do
+          expect(c.type_cast_for_cql3(1)).to be(1)
+        end
+      end
+      
+      describe "to solr" do
+        it "casts 1 to 1" do
+          expect(c.type_cast_for_solr(1)).to be(1)
+        end
+      end
+    end
+    
+    describe "time" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "time")}
+      
+      describe "to ruby" do
+        [nil,'ABC',''].each do |val|
+          it "casts #{val.inspect} to nil" do
+            expect(c.type_cast(val)).to be_nil
+          end
+        end
+        
+        it "casts a time string to Time" do
+          time_string = Time.now.utc.strftime("%T")
+          expect(c.type_cast(time_string).strftime("%T")).to eq(time_string)
+        end
+      end
+      
+      describe "to cql3" do
+        it "casts a Time object to a Time object" do
+          time = Time.parse('1980-10-19 17:55:00')
+          expect(c.type_cast_for_cql3(time)).to eq(time)
+        end
+      end
+      
+      describe "to solr" do
+        it "casts a Time object to a solr formatted time string" do
+          time = Time.parse('1980-10-19 17:55:00')
+          expect(c.type_cast_for_solr(time)).to eq('1980-10-19T17:55:00Z')
+        end
+      end
+    end
+    
+    describe "timestamp" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "timestamp")}
+      
+      describe "to ruby" do
+        [nil,'',' ', 'ABC'].each do |val|
+          it "casts #{val.inspect} to nil" do
+            expect(c.type_cast(val)).to be_nil
+          end
+        end
+        
+        it "casts a datetime string to Time" do
+          datetime_string = Time.now.utc.strftime("%FT%T")
+          expect(c.type_cast(datetime_string).strftime("%FT%T")).to eq(datetime_string)
+        end
+        
+        it "casts a datetime string with timezone to Time" do
+          begin
+            old = DatastaxRails::Base.default_timezone
+            [:utc, :local].each do |zone|
+              DatastaxRails::Base.default_timezone = zone
+              datetime_string = "Wed, 04 Sep 2013 03:00:00 EAT"
+              expect(c.type_cast(val)).to eq(Time.utc(2013, 9, 4, 0, 0, 0))
+            end
+          rescue
+            DatastaxRails::Base.default_timezone = old
+          end
+        end
+      end
+      
+      describe "to cql3" do
+        it "casts a Time object to a Time object" do
+          time = Time.parse('1980-10-19 17:55:00')
+          expect(c.type_cast_for_cql3(time)).to eq(time)
+        end
+      end
+      
+      describe "to solr" do
+        it "casts a Time object to a solr formatted time string" do
+          time = Time.parse('1980-10-19 17:55:00')
+          expect(c.type_cast_for_solr(time)).to eq('1980-10-19T17:55:00Z')
+        end
+      end
+    end
+    
+    describe "date" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "date")}
+      
+      [nil,'',' ', 'ABC'].each do |val|
+        it "casts #{val.inspect} to nil" do
+          expect(c.type_cast(val)).to be_nil
+        end
+      end
+      
+      it "casts a date string to Date" do
+        date_string = Time.now.utc.strftime("%F")
+        expect(c.type_cast(date_string).strftime("%F")).to eq(date_string)
+      end
+      
+      describe "to cql3" do
+        it "casts a Date object to a Time object" do
+          time = Time.parse('1980-10-19 00:00:00')
+          date = Date.parse('1980-10-19')
+          expect(c.type_cast_for_cql3(date)).to eq(time)
+        end
+      end
+      
+      describe "to solr" do
+        it "casts a Date object to a solr formatted time string" do
+          date = Date.parse('1980-10-19')
+          expect(c.type_cast_for_solr(date)).to eq('1980-10-19T00:00:00Z')
+        end
+      end
+    end
+    
+    describe "map" do
+      let(:c) {DatastaxRails::Column.new("field_", nil, "map", :holds => :integer)}
+      
+      it "casts map keys to strings" do
+        expect(c.type_cast({:field_key => 7}, record)).to eq({"field_key" => 7})
+      end
+      
+      it "casts map values to the type specified in the options" do
+        expect(c.type_cast({'field_key' => '7'}, record)).to eq({"field_key" => 7})
+      end
+      
+      it "wraps map values in a DynamicMap" do
+        expect(c.type_cast({'field_key' => '7'}, record)).to be_a(DatastaxRails::Types::DynamicMap)
+      end
+    end
+    
+    describe "list" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "list", :holds => :integer)}
+      
+      it "casts list values to the type specified in the options" do
+        expect(c.type_cast([1,"2",6.minutes], record)).to eq([1,2,360])
+      end
+      
+      it "wraps list values in a DynamicList" do
+        expect(c.type_cast([1,"2",6.minutes], record)).to be_a(DatastaxRails::Types::DynamicList)
+      end
+    end
+    
+    describe "set" do
+      let(:c) {DatastaxRails::Column.new("field", nil, "set", :holds => :integer)}
+      
+      it "casts list values to the type specified in the options" do
+        expect(c.type_cast([1,"2",6.minutes, 2], record)).to eq(Set.new([1,2,360]))
+      end
+      
+      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
+    end
+  end
+end

data/spec/datastax_rails/cql/select_spec.rb

@@ -8,7 +8,7 @@ describe DatastaxRails::Cql::Select do
   it "should generate valid CQL" do
     cql = DatastaxRails::Cql::Select.new(@model_class, ["*"])
     cql.using(DatastaxRails::Cql::Consistency::QUORUM).conditions(:key => '12345').limit(1)
-    cql.to_cql.should == "SELECT * FROM users WHERE \"key\" = '12345' LIMIT 1 "
+    cql.to_cql.should == "SELECT * FROM users WHERE \"key\" = ? LIMIT 1 "
   end
   
   it_has_behavior "default_consistency"

data/spec/datastax_rails/cql/update_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe DatastaxRails::Cql::Update do
   before(:each) do
-    @model_class = double("Model Class", :column_family => 'users', :default_consistency => DatastaxRails::Cql::Consistency::QUORUM)
+    @model_class = double("Model Class", :column_family => 'users', :default_consistency => DatastaxRails::Cql::Consistency::QUORUM, :primary_key => 'id')
   end
   
   it "should generate valid CQL" do
     cql = DatastaxRails::Cql::Update.new(@model_class, "12345")
     cql.using(DatastaxRails::Cql::Consistency::QUORUM).columns(:name => 'John', :age => '23')
-    cql.to_cql.should match(/update users SET ("name" = 'John', "age" = '23'|"age" = '23', "name" = 'John') WHERE key IN \('12345'\)/)
+    cql.to_cql.should match(/update users SET ("name" = \?, "age" = \?|"age" = \?, "name" = \?) WHERE id IN \(\?\)/)
   end
   
   it_has_behavior "default_consistency"

data/spec/datastax_rails/persistence_spec.rb

@@ -13,29 +13,53 @@ describe "DatastaxRails::Base" do
     end
     
     describe "with cql" do
+      before(:each) do
+        Person.storage_method = :cql
+        @statement = double("prepared statement")
+        DatastaxRails::Base.connection.stub(:prepare).and_return(@statement)
+      end
+      
       describe "#create" do
         it "should persist at the given consistency level" do
-          Person.storage_method = :cql
-          DatastaxRails::Base.connection.should_receive(:execute_cql_query).with(an_instance_of(String), :consistency => CassandraCQL::Thrift::ConsistencyLevel::LOCAL_QUORUM)
+          @statement.should_receive(:execute) do |*args|
+            expect(args.last).to include(:consistency => :local_quorum)
+          end
           Person.create({:name => 'Steven'},{:consistency => 'LOCAL_QUORUM'})
         end
       end
     
       describe "#save" do
         it "should persist at the given consistency level" do
-          Person.storage_method = :cql
-          DatastaxRails::Base.connection.should_receive(:execute_cql_query).with(an_instance_of(String), :consistency => CassandraCQL::Thrift::ConsistencyLevel::LOCAL_QUORUM)
+          @statement.should_receive(:execute) do |*args|
+            expect(args.last).to include(:consistency => :local_quorum)
+          end
           p=Person.new(:name => 'Steven')
           p.save(:consistency => 'LOCAL_QUORUM')
         end
       end
+      
+      describe "#remove" do
+        it "should remove at the given consistency level" do
+          @statement.stub(:execute)
+          p=Person.create(:name => 'Steven')
+          @statement.should_receive(:execute) do |*args|
+            expect(args.last).to include(:consistency => :local_quorum)
+          end
+          p.destroy(:consistency => :local_quorum)
+        end
+      end
     end
 
     describe "with solr" do
+      around(:each) do |example|
+        Person.storage_method = :solr
+        example.run
+        Person.storage_method = :cql
+      end
+      
       describe "#create" do
         it "should persist at the given consistency level" do
           Person.solr_connection.should_receive(:update).with(hash_including(:params => hash_including({:cl => 'LOCAL_QUORUM'}))).and_return(true)
-          Person.storage_method = :solr
           Person.create({:name => 'Steven'},{:consistency => 'LOCAL_QUORUM'})
         end
       end
@@ -43,14 +67,12 @@ describe "DatastaxRails::Base" do
       describe "#save" do
         it "should persist at the given consistency level" do
           Person.solr_connection.should_receive(:update).with(hash_including(:params => hash_including({:cl => 'LOCAL_QUORUM'}))).and_return(true)
-          Person.storage_method = :solr
           p=Person.new(:name => 'Steven')
           p.save(:consistency => 'LOCAL_QUORUM')
         end
         
         it "should successfully remove columns that are set to nil" do
           pending do 
-            Person.storage_method = :solr
             p = Person.create!(:name => 'Steven', :birthdate => Date.today)
             Person.commit_solr
             p = Person.find_by_name('Steven')
@@ -63,14 +85,6 @@ describe "DatastaxRails::Base" do
       end
     end
     
-    describe "#remove" do
-      it "should remove at the given consistency level" do
-        p=Person.create(:name => 'Steven')
-        DatastaxRails::Base.connection.should_receive(:execute_cql_query).with(an_instance_of(String), :consistency => CassandraCQL::Thrift::ConsistencyLevel::LOCAL_QUORUM)
-        p.destroy(:consistency => :local_quorum)
-      end
-    end
-    
     describe "#store_file" do
       it "should store a file", :slow => true do
         file = "abcd"*1.megabyte