gotime-cassandra_object 0.6.1

data/test/identity/natural_key_factory_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+module Identity
+  class NaturalKeyFactoryTest < CassandraObjectTestCase
+    context "With one attribute" do
+      setup do
+        @key_factory = CassandraObject::Identity::NaturalKeyFactory.new :attributes => :name
+        @james = Person.new("name" => "james")
+      end
+
+      should "have a key whose string and param value is the value of that attribute" do
+        @key = @key_factory.next_key(@james)
+
+        assert_equal "james", @key.to_s
+        assert_equal "james", @key.to_param
+      end
+
+      should "parse to a key from a param value" do
+        @key = @key_factory.parse("james")
+
+        assert_equal "james", @key.to_s
+        assert_equal "james", @key.to_param
+      end
+
+      should "create a key from a value" do
+        @key = @key_factory.create("james")
+
+        assert_equal "james", @key.to_s
+        assert_equal "james", @key.to_param
+      end
+    end
+
+    context "With multiple attributes" do
+      setup do
+        @key_factory = CassandraObject::Identity::NaturalKeyFactory.new :attributes => [:name, :age]
+        @james = Person.new("name" => "james", "age" => 23)
+      end
+
+      should "create a key whose string value is the two values, joined with a separator" do
+        key = @key_factory.next_key(@james)
+        
+        assert_equal "james-23", key.to_s
+        assert_equal "james-23", key.to_param
+      end
+
+      should "parse the key" do
+        key = @key_factory.parse("james-23")
+        
+        assert_equal "james-23", key.to_s
+        assert_equal "james-23", key.to_param
+      end
+
+      should "create the key" do
+        key = @key_factory.create("james-23")
+        
+        assert_equal "james-23", key.to_s
+        assert_equal "james-23", key.to_param
+      end
+    end
+
+    context "With a custom separator" do
+      setup do
+        @key_factory = CassandraObject::Identity::NaturalKeyFactory.new :attributes => [:name, :age],
+                                                                        :separator  => "#"
+        @james = Person.new("name" => "james", "age" => 23)
+      end
+
+      should "join the attributes with the custom separator" do
+        key = @key_factory.next_key(@james)
+
+        assert_equal "james#23", key.to_s
+      end
+    end
+
+    context "Natural keys" do
+      setup do
+        @james         = CassandraObject::Identity::NaturalKeyFactory::NaturalKey.new("james")
+        @another_james = CassandraObject::Identity::NaturalKeyFactory::NaturalKey.new("james")
+        @joe           = CassandraObject::Identity::NaturalKeyFactory::NaturalKey.new("joe")
+      end
+
+      should "be equal, if their values are equal" do
+        assert @james == @another_james
+        assert @james.eql?(@another_james)
+      end
+
+      should "not be equal if their values are different" do
+        assert @james != @joe
+        assert !@james.eql?(@joe)
+      end
+    end
+  end
+end
+

data/test/index_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class IndexTest < CassandraObjectTestCase
+  context "A non-unique index" do
+    setup do
+      @last_name = ActiveSupport::SecureRandom.hex(5)
+      @koz = Customer.create :first_name=>"Michael", :last_name=>@last_name, :date_of_birth=>28.years.ago.to_date
+      @wife = Customer.create :first_name=>"Anika", :last_name=>@last_name, :date_of_birth=>30.years.ago.to_date
+    end
+    
+    should "Return both values" do
+      assert_ordered [@wife.key, @koz.key], Customer.find_all_by_last_name(@last_name).map(&:key)
+    end
+    
+    should "return the older when the newer is destroyed" do
+      @wife.destroy
+      assert_equal [@koz.key], Customer.find_all_by_last_name(@last_name).map(&:key)
+    end
+    
+    should "return a single value when the original one is changed" do
+      @wife.last_name = "WTF"
+      @wife.save
+      assert_equal [@koz.key], Customer.find_all_by_last_name(@last_name).map(&:key)
+    end
+  end
+
+  context "A corrupt non-unique index" do
+    setup do
+      @last_name = ActiveSupport::SecureRandom.hex(5)
+      @koz = Customer.create :first_name=>"Michael", :last_name=>@last_name, :date_of_birth=>28.years.ago.to_date
+      connection.insert("CustomersByLastName", @last_name, {"last_name"=>{SimpleUUID::UUID.new=>"ROFLSKATES"}})
+      @wife = Customer.create :first_name=>"Anika", :last_name=>@last_name, :date_of_birth=>30.years.ago.to_date
+    end
+    
+    should "Return both values and clean up" do
+      assert_ordered [@wife.key, @koz.key], Customer.find_all_by_last_name(@last_name).map(&:key)
+      assert_ordered [@wife.key, @koz.key], connection.get("CustomersByLastName", @last_name, "last_name", :reversed=>true).values
+    end
+    
+  end
+  
+  context "A unique index" do
+    setup do
+      @invoice = mock_invoice
+      @number = @invoice.number
+    end
+    
+    should "return the right record" do
+      assert_equal @invoice, Invoice.find_by_number(@number)
+    end
+    
+    should "return nil after destroy" do
+      @invoice.destroy
+      assert_nil Invoice.find_by_number(@number)
+    end
+  end
+  
+  context " A corrupt unique index" do
+    setup do
+      connection.insert("InvoicesByNumber", '15' , {"key"=>"HAHAHAHA"})
+    end
+    
+    should "return nil on fetch and cleanup" do
+      assert_nil Invoice.find_by_number(15)
+      assert connection.get("InvoicesByNumber", "15", "number").blank?
+    end
+    
+  end
+end

data/test/legacy/test_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+
+gem 'activesupport', "~> 2.3.5"
+
+puts "LEGACY TEST"
+
+require 'cassandra_object'
+require 'connection'
+
+require 'test/unit'
+require 'active_support/test_case'
+require 'shoulda'
+
+require 'fixture_models'
+require 'pp'
+
+require 'test_case'
+

data/test/migration_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class MigrationTest < CassandraObjectTestCase
+  test "a new invoice should have the right schema version" do
+    i = mock_invoice
+    assert_equal 2, i.schema_version
+  end
+  
+  test " a new invoice should have an empty gst_number" do
+    assert_equal nil, mock_invoice.gst_number
+  end
+  
+  test "an old invoice should get fetched and updated" do
+    key = Invoice.next_key.to_s
+    connection.insert(Invoice.column_family, key, {"schema_version"=>"1", "number"=>"200", "total"=>"150.35"})
+    
+    invoice = Invoice.get(key)
+    assert_equal 2, invoice.schema_version
+    assert_equal 150.35, invoice.total
+  end
+end

data/test/one_to_many_associations_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+class OneToManyAssociationsTest < CassandraObjectTestCase
+  
+  context "A customer with no invoices added to its invoice association" do 
+    setup do
+      @customer = Customer.create :first_name    => "Michael",
+                                  :last_name     => "Koziarski",
+                                  :date_of_birth => Date.parse("1980/08/15")
+
+      assert @customer.valid?, @customer.errors                            
+    end
+    
+    should "return an empty array for the association" do
+      assert_equal [], @customer.invoices.to_a 
+    end
+  end
+  
+  context "A customer with an invoice added to its invoice association" do 
+    setup do
+      @customer = Customer.create :first_name    => "Michael",
+                                  :last_name     => "Koziarski",
+                                  :date_of_birth => Date.parse("1980/08/15")
+
+      assert @customer.valid?, @customer.errors                            
+
+      @invoice  = mock_invoice
+      assert @invoice.valid?, @invoice.errors
+
+      @customer.invoices << @invoice
+    end
+    
+    should "have set the inverse" do
+      assert_equal @customer, @invoice.customer
+    end
+    
+    should "have also written to cassandra" do
+      assert_equal @invoice, @customer.invoices.to_a.first
+    end
+    
+    context "Simple Read-Repair" do
+      setup do
+        add_junk_key
+        assert_ordered ["SomethingStupid", @invoice.key], association_keys_in_cassandra
+      end
+    
+      should "tidy up when fetching" do
+        assert_equal [@invoice], @customer.invoices.all
+        assert_equal [@invoice.key.to_s], association_keys_in_cassandra
+      end
+    end
+  
+    context "More complicated Read-Repair" do
+      setup do
+        # Now add a second legit invoice
+        @second_invoice = mock_invoice
+        @customer.invoices << @second_invoice
+
+        add_junk_key
+
+        @third_invoice = mock_invoice
+        @customer.invoices << @third_invoice
+
+        #
+
+        assert_ordered [@third_invoice.key,"SomethingStupid", @second_invoice.key,  @invoice.key],
+                     association_keys_in_cassandra
+      end
+    
+      should "return the last one when passed a limit of one, and not touch the keys" do
+        assert_equal [@third_invoice], @customer.invoices.all(:limit=>1)
+        assert_ordered [@third_invoice.key,"SomethingStupid", @second_invoice.key,  @invoice.key],
+                     association_keys_in_cassandra
+      end
+    
+      should "return them all when passed a limit of 3, and clean up the keys" do
+        assert_ordered [@third_invoice, @second_invoice, @invoice], @customer.invoices.all(:limit=>3), false
+        assert_ordered [@third_invoice.key, @second_invoice.key,  @invoice.key],
+                     association_keys_in_cassandra
+                   
+      end
+    
+      should "return the first invoice when told to start after the second" do
+        assert_ordered [@invoice.key], @customer.invoices.all(:limit=>1, :start_after=>index_key_for(@second_invoice)).map(&:key)
+        assert_ordered [@third_invoice.key,"SomethingStupid", @second_invoice.key,  @invoice.key],
+                     association_keys_in_cassandra
+      end
+    end
+  end
+  
+  context "A customer with an invoice added to its paid invoices association (which has no explicit reversed option)" do
+    setup do
+      @customer = Customer.create :first_name    => "Michael",
+                                  :last_name     => "Koziarski",
+                                  :date_of_birth => Date.parse("1980/08/15")
+
+      assert @customer.valid?, @customer.errors
+
+      @invoice  = mock_invoice
+      assert @invoice.valid?, @invoice.errors
+
+      @customer.paid_invoices << @invoice
+    end
+
+    should "return invoice from association" do
+      assert_equal @invoice, @customer.paid_invoices.to_a.first
+    end
+  end
+
+  context "Association proxy create" do
+    setup do
+      @customer = Customer.create! :first_name    => "Michael",
+                                   :last_name     => "Koziarski",
+                                   :date_of_birth => Date.parse("1980/08/15")
+      @invoice = @customer.invoices.create :number=>50, :total=>25.0
+    end
+    
+    should "return the invoice" do
+      assert_kind_of Invoice, @invoice
+    end
+    
+    should "have set the attributes" do
+      assert_equal 50, @invoice.number
+      assert_equal 25.0, @invoice.total
+    end
+    
+    should "have set the inverse" do
+      assert_equal @customer, @invoice.customer 
+    end
+  end
+
+  context "Association proxy all" do
+    setup do
+      @customer = Customer.create! :first_name    => "Michael",
+                                   :last_name     => "Koziarski",
+                                   :date_of_birth => Date.parse("1980/08/15")
+      @first  = @customer.invoices.create :number => 50, :total => 25.0
+      @second = @customer.invoices.create :number => 50, :total => 25.0
+    end
+
+    should "suport overriding :reversed value" do
+      assert_ordered [@first.key, @second.key], @customer.invoices.all(:reversed => false).map(&:key)
+    end
+  end
+
+  def add_junk_key
+    Customer.associations[:invoices].add(@customer, MockRecord.new("SomethingStupid"))
+  end
+
+  def association_keys_in_cassandra
+    Customer.connection.get(Customer.associations[:invoices].column_family, @customer.key.to_s, "invoices", :reversed=>true).values
+  end
+  
+  def index_key_for(object)
+    Customer.connection.get(Customer.associations[:invoices].column_family, @customer.key.to_s, "invoices").each do |(key, value)|
+      if value == object.key.to_s
+        return key
+      end
+    end
+    raise "Not found"
+  end
+  
+end

data/test/test_case.rb

@@ -0,0 +1,28 @@
+
+class CassandraObjectTestCase < ActiveSupport::TestCase
+  def teardown
+    CassandraObject::Base.connection.clear_keyspace!
+  end
+
+  def mock_invoice
+    Invoice.create :number=>Time.now.to_i*(rand(5)), :total=>Time.now.to_f
+  end
+
+  def connection
+    CassandraObject::Base.connection
+  end
+  
+  def assert_ordered(expected_object_order, actual_order, to_s_before_comparing = true)
+    # don't use map! so we don't go changing user's arguments
+    if to_s_before_comparing
+      expected_object_order = expected_object_order.map(&:to_s) 
+      actual_order = actual_order.map(&:to_s)
+    end
+    
+    assert_equal Set.new(expected_object_order), Set.new(actual_order), "Collections weren't equal"
+    actual_indexes = actual_order.map do |e|
+      expected_object_order.index(e)
+    end
+    assert_equal expected_object_order, actual_order, "Collection was ordered incorrectly: #{actual_indexes.inspect}"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'cassandra_object'
+require 'connection'
+
+require 'test/unit'
+require 'active_support/test_case'
+require 'shoulda'
+
+require 'fixture_models'
+require 'pp'
+
+require 'test_case'

data/test/time_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class TimeTest < CassandraObjectTestCase
+
+  test "new raises an error" do
+    begin
+      appt = Appointment.new :start_time => 1
+      flunk "Should have failed to save"
+    rescue ArgumentError => e
+      assert_equal "CassandraObject::TimeType requires a Time", e.message
+    end
+  end
+
+  test "the attribute writer raises an error" do
+    begin
+      appt = Appointment.new
+      appt.start_time = 1
+      flunk "Should have failed to save"
+    rescue ArgumentError => e
+      assert_equal "CassandraObject::TimeType requires a Time", e.message
+    end
+  end
+
+  test "Time's should be round-trip-able" do
+    appt = Appointment.new :start_time => (t = Time.now.utc), :title => "team meeting"
+    appt.save!
+    appt2 = Appointment.get(appt.key)
+
+    assert_equal appt.start_time.class, appt2.start_time.class
+    assert_equal appt.start_time,       appt2.start_time
+  end
+end