gotime-cassandra_object 2.2.0 → 2.2.1

data/test-old/fixture_models.rb

@@ -1,90 +0,0 @@
-module ReverseStorage
-  def encode(str)
-    str.reverse
-  end
-  module_function :encode
-
-  def decode(str)
-    str.reverse
-  end
-  module_function :decode
-end
-
-
-class Customer < CassandraObject::Base
-  attribute :first_name,     :type => :string
-  attribute :last_name,      :type => :string
-  attribute :date_of_birth,  :type => :date
-  attribute :preferences,    :type => :hash
-  attribute :custom_storage, :type => String, :converter=>ReverseStorage
-
-  validate :should_be_cool
-  validates_presence_of :last_name
-
-  after_create :set_after_create_called
-
-  key :uuid
-
-  index :last_name, :reversed=>true
-
-  association :invoices, :unique=>false, :inverse_of=>:customer, :reversed=>true
-  association :paid_invoices, :unique=>false, :class_name=>'Invoice'
-
-  def after_create_called?
-    @after_create_called
-  end
-
-  def set_after_create_called
-    @after_create_called = true
-  end
-
-  private
-
-  def should_be_cool
-    unless ["Michael", "Anika", "Evan", "Tom"].include?(first_name)
-      errors.add(:first_name, "must be that of a cool person")
-    end
-  end
-end
-
-class Invoice < CassandraObject::Base
-  attribute :number,     :type=>:integer
-  attribute :total,      :type=>:float
-  attribute :gst_number, :type=>:string
-
-  index :number, :unique=>true
-
-  association :customer, :unique=>true, :inverse_of=>:invoices
-
-  migrate 1 do |attrs|
-    attrs["total"] ||= (rand(2000) / 100.0).to_s
-  end
-
-  migrate 2 do |attrs|
-    attrs["gst_number"] = "66-666-666"
-  end
-
-  key :uuid
-end
-
-class Payment < CassandraObject::Base
-  attribute :reference_number, :type => :string
-  attribute :amount,           :type => :integer
-
-  key :natural, :attributes => :reference_number
-end
-
-MockRecord = Struct.new(:key)
-
-class Person < CassandraObject::Base
-  attribute :name, :type => :string
-  attribute :age,  :type => :integer
-end
-
-class Appointment < CassandraObject::Base
-  attribute :title,      :type => :string
-  attribute :start_time, :type => :time
-  attribute :end_time,   :type => :time_with_zone, :allow_nil => true
-
-  key :natural, :attributes => :title
-end

data/test-old/identity/natural_key_factory_test.rb

@@ -1,94 +0,0 @@
-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-old/index_test.rb

@@ -1,69 +0,0 @@
-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-old/legacy/test_helper.rb

@@ -1,18 +0,0 @@
-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-old/migration_test.rb

@@ -1,21 +0,0 @@
-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-old/one_to_many_associations_test.rb

@@ -1,163 +0,0 @@
-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