gotime-cassandra_object 2.2.0 → 2.2.1

data/test-old/test_case.rb

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

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

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

data/test-old/types_test.rb

@@ -1,252 +0,0 @@
-require 'test_helper'
-
-class TypeTest < CassandraObjectTestCase
-  context "IntegerType" do
-    context "encode" do
-
-      should "return an int with no errors" do
-        assert_nothing_raised {
-          i = 12
-          assert_equal i.to_s, CassandraObject::IntegerType.encode(i)
-        }
-      end
-
-      should "raises an error on non-Integer input" do
-        assert_raises(ArgumentError) { CassandraObject::IntegerType::encode('')}
-      end
-
-      should "work with Bignums" do
-        assert_nothing_raised {
-          i = 2**32
-          assert_equal i.to_s, CassandraObject::IntegerType.encode(i)
-        }
-      end
-
-      should "work with Fixnums" do
-        assert_nothing_raised {
-          i = 2**16
-          assert_equal Fixnum, i.class
-          assert_equal i.to_s, CassandraObject::IntegerType.encode(i)
-        }
-      end
-    end
-
-    context "decode" do
-      should "work with an int" do
-        assert_nothing_raised {
-          assert_equal 12, CassandraObject::IntegerType.decode('12')
-        }
-      end
-
-      should "work with Bignums" do
-        assert_nothing_raised {
-          assert_equal 2**32, CassandraObject::IntegerType.decode((2**32).to_s)
-        }
-      end
-
-      should "reject trash" do
-        assert_raises(ArgumentError) {
-          CassandraObject::IntegerType.decode('asdf')
-        }
-      end
-
-      should "work on a negative number" do
-        assert_equal -1, CassandraObject::IntegerType.decode('-1')
-      end
-
-      should "work with a leading +" do
-        assert_equal 1, CassandraObject::IntegerType.decode('+1')
-      end
-    end
-  end
-
-  context "FloatType" do
-    context "encode" do
-      should "should reject an Integer" do
-        assert_raises(ArgumentError) {
-          CassandraObject::FloatType.encode(1)
-        }
-      end
-
-      should "reject a string" do
-        assert_raises(ArgumentError) {
-          CassandraObject::FloatType.encode('asdf')
-        }
-      end
-
-      should "return a string" do
-        assert_equal '1.0', CassandraObject::FloatType.encode(1.0)
-      end
-
-      should "accept a negative number" do
-        assert_equal '-1.0', CassandraObject::FloatType.encode(-1.0)
-      end
-    end
-
-    context "decode" do
-      should "reject a non-float" do
-        assert_raises(ArgumentError) {
-          CassandraObject::FloatType.decode('asdf')
-        }
-      end
-
-      should "work on a float" do
-        assert_equal 1.2, CassandraObject::FloatType.decode('1.2')
-      end
-
-      should "work on a negative number" do
-        assert_equal -1.2, CassandraObject::FloatType.decode('-1.2')
-      end
-
-      should "work with a leading +" do
-        assert_equal 1.2, CassandraObject::FloatType.decode('+1.2')
-      end
-    end
-  end
-
-  context "DateType" do
-    context "encode" do
-      should "accept a valid Date object" do
-        assert_nothing_raised {
-          CassandraObject::DateType.encode(Date.today)
-        }
-      end
-
-      should "reject a String, even if it looks like a date" do
-        assert_raises(ArgumentError) { CassandraObject::DateType.encode('2009-10-31') }
-      end
-
-      should "reject an Integer" do
-        assert_raises(ArgumentError) { CassandraObject::DateType.encode(12) }
-      end
-
-      should "return a properly formatted string" do
-        str = '2009-10-31'
-        date = Date.strptime(str)
-        assert_equal str, CassandraObject::DateType.encode(date)
-      end
-    end
-
-    context "decode" do
-      should "work on a properly formatted string" do
-        s = '2009-10-31'
-        assert_equal Date.strptime(s), CassandraObject::DateType.decode(s)
-      end
-
-      should "reject a badly formatted string" do
-        assert_raises(ArgumentError) {
-          CassandraObject::DateType.decode('asdf')
-        }
-      end
-    end
-  end
-
-  context "TimeType" do
-    context "#encode" do
-      should "accept a Time" do
-        assert_nothing_raised {CassandraObject::TimeType.encode(Time.now)}
-      end
-
-      should "return a properly formated string for a legit time" do
-        t = Time.now
-        formatted = t.xmlschema(6)
-        assert_equal(formatted, CassandraObject::TimeType.encode(t))
-      end
-
-      should "reject things other than Time" do
-        assert_raises(ArgumentError) {
-          CassandraObject::TimeType.encode(1)
-        }
-        assert_raises(ArgumentError) {
-          CassandraObject::TimeType.encode('asdf')
-        }
-      end
-    end
-
-    context "#decode" do
-      should "parse a valid string and return a Time (with timezone)" do
-        time = Time.xmlschema(str = "2009-11-05T13:24:07-08:00")
-        assert_nothing_raised {
-          assert_equal time, CassandraObject::TimeType.decode(str)
-        }
-      end
-
-      should "parse a valid string and return a Time (with UTC)" do
-        time = Time.xmlschema(str = "2009-11-05T13:24:07Z")
-        assert_nothing_raised {
-          assert_equal time, CassandraObject::TimeType.decode(str)
-        }
-      end
-    end
-  end
-
-  context "HashType" do
-    context "encode" do
-      should "handle an empty Hash" do
-        assert_nothing_raised {
-          assert_equal(ActiveSupport::JSON.encode({}), CassandraObject::HashType.encode({}))
-        }
-      end
-
-      should "handle string keys" do
-        assert_nothing_raised {
-          h = {'foo' => 'bar'}
-          assert_equal(ActiveSupport::JSON.encode(h), CassandraObject::HashType.encode(h))
-        }
-      end
-
-      should "handle symbol keys" do
-        assert_nothing_raised {
-          h = {:foo => 'bar'}
-          assert_equal(ActiveSupport::JSON.encode(h), CassandraObject::HashType.encode(h))
-        }
-      end
-    end
-  end
-
-  context "BooleanType" do
-    context "encode" do
-      should "handle true" do
-        assert_nothing_raised {
-          assert_equal '1', CassandraObject::BooleanType.encode(true)
-        }
-      end
-
-      should "handle false" do
-        assert_nothing_raised {
-          assert_equal '0', CassandraObject::BooleanType.encode(false)
-        }
-      end
-
-      should "handle nil" do
-        assert_nothing_raised {
-          assert_equal '0', CassandraObject::BooleanType.encode(nil)
-        }
-      end
-
-      should "not handle normal objects" do
-        assert_raises(ArgumentError) {
-          assert_equal '1', CassandraObject::BooleanType.encode(Object.new)
-        }
-      end
-    end
-
-    context "decode" do
-      should "handle true" do
-        assert_nothing_raised {
-          assert_equal true, CassandraObject::BooleanType.decode('1')
-        }
-      end
-
-      should "handle false" do
-        assert_nothing_raised {
-          assert_equal false, CassandraObject::BooleanType.decode('0')
-        }
-      end
-
-      should "handle bad data as false" do
-        assert_equal false, CassandraObject::BooleanType.decode('')
-      end
-    end
-  end
-end

data/test-old/validation_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-class ValidationTest < CassandraObjectTestCase
-  
-  test "save! raises an error" do
-    begin
-      customer = Customer.new :first_name=>"steve", :date_of_birth=>Date.parse("1979/12/25")
-      customer.save!
-      flunk "Should have failed to save"
-    rescue CassandraObject::Validation::RecordInvalid => e
-      assert_equal customer, e.record
-    end
-  end
-
-  test "create! raises an error" do
-    begin
-      customer = Customer.create! :first_name=>"steve", :date_of_birth=>Date.parse("1979/12/25")
-      flunk "Should have failed to create!"
-    rescue CassandraObject::Validation::RecordInvalid => e
-      assert_kind_of Customer, e.record
-    end
-  end
-
-
-end

data/test-old/z_mock_test.rb

@@ -1,36 +0,0 @@
-# The filename is so that this test gets loaded last, since it depends on all the other tests.
-#  Suggestions of less janky ways to do this would be appreciated. -rk
-
-require 'test_helper'
-
-class MockTest < CassandraObjectTestCase
-  context CassandraObject::Base do
-    should "respond to use_mock!" do
-      assert CassandraObject::Base.respond_to?(:use_mock!)
-    end
-    context "use_mock!" do
-      should "set the connection_class" do
-        CassandraObject::Base.use_mock!
-        assert_equal Cassandra::Mock, CassandraObject::Base.connection_class
-        CassandraObject::Base.use_mock!(false)
-      end
-    end
-  end
-end
-
-module MockTestMixin
-  def setup
-    CassandraObject::Base.use_mock!
-    super
-  end
-
-  def teardown
-    CassandraObject::Base.use_mock!(false)
-  end
-end
-
-%w[BasicScenarios Cursor Dirty Index Migration OneToManyAssociations Time Types Validation].each do |test|
-  klass = Class.new(Kernel.const_get(test + 'Test'))
-  klass.send(:include, MockTestMixin)
-  Kernel.const_set(test + 'WithMockTest', klass)
-end

data/test/primary_key_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-
-class CassandraObject::PrimaryKeyTest < CassandraObject::TestCase
-  test 'id' do
-    issue = Issue.create
-
-    assert_equal issue.key.to_s, issue.id
-  end
-end