extendi-cassandra_object 1.0.0

data/test/unit/schemaless_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class CassandraObject::SchemalessTest < CassandraObject::TestCase
+
+  test 'create_keyspace' do
+    CassandraObject::Schemaless.create_keyspace 'Blah'
+    begin
+      existing_keyspace = false
+      CassandraObject::Schemaless.create_keyspace 'Blah'
+    rescue Exception => e
+      assert_equal e.message, 'Cannot add existing keyspace "blah"'
+      existing_keyspace = true
+    ensure
+      CassandraObject::Schemaless.drop_keyspace 'Blah'
+    end
+
+    assert existing_keyspace
+  end
+
+  test 'drop undroppable' do
+    begin
+      CassandraObject::Schemaless.drop_keyspace 'cassandra_object_test'
+    rescue Exception => e
+      assert_equal e.message, 'Cannot drop keyspace cassandra_object_test. You must delete all tables before'
+    ensure
+    end
+  end
+
+  test 'create_table' do
+
+    CassandraObject::Schemaless.create_table 'TestRecords'
+
+    begin
+      CassandraObject::Schemaless.create_table 'TestRecords'
+      assert false, 'TestRecords should already exist'
+    rescue Exception => e
+      assert_equal e.message.gsub('column family', 'table'), 'Cannot add already existing table "testrecords" to keyspace "cassandra_object_test"'
+    end
+  end
+
+  test 'drop_table' do
+    class TestDrop < CassandraObject::BaseSchemaless
+      self.column_family = 'TestCFToDrop1'
+    end
+
+    CassandraObject::Schemaless.create_table 'TestCFToDrop1'
+    TestDrop.create
+    begin
+      CassandraObject::Schemaless.drop_table 'TestCFToDrop1'
+    rescue Exception => e
+      assert_equal e.message, 'The table TestCFToDrop1 is not empty! If you want to drop it add the option confirm = true'
+    end
+  end
+
+  test 'drop with confirm' do
+    CassandraObject::Schemaless.create_table 'TestCFToDrop2'
+
+    CassandraObject::Schemaless.drop_table 'TestCFToDrop2', true
+    begin
+      CassandraObject::Schemaless.drop_table 'TestCFToDrop2'
+      assert false, 'TestCFToDrop2 should not exist'
+    rescue Exception => e
+      assert_equal e.message.gsub('columnfamily', 'table'), 'unconfigured table testcftodrop2'
+    end
+  end
+
+  test 'drop empty' do
+    CassandraObject::Schemaless.create_table 'TestCFToDrop3'
+
+    CassandraObject::Schemaless.drop_table 'TestCFToDrop3'
+    begin
+      CassandraObject::Schemaless.drop_table 'TestCFToDrop3'
+      assert false, 'TestCFToDrop3 should not exist'
+    rescue Exception => e
+      assert_equal e.message.gsub('columnfamily', 'table'), 'unconfigured table testcftodrop3'
+    end
+  end
+
+  test 'create_index' do
+    CassandraObject::Schemaless.create_column_family 'TestIndexed'
+
+    CassandraObject::Schemaless.alter_column_family 'TestIndexed', 'ADD id_value varchar'
+
+    CassandraObject::Schemaless.add_index 'TestIndexed', 'id_value'
+  end
+
+  test 'drop_index' do
+    CassandraObject::Schemaless.create_column_family 'TestDropIndexes'
+
+    CassandraObject::Schemaless.alter_column_family 'TestDropIndexes', 'ADD id_value1 varchar'
+    CassandraObject::Schemaless.alter_column_family 'TestDropIndexes', 'ADD id_value2 varchar'
+
+    CassandraObject::Schemaless.add_index 'TestDropIndexes', 'id_value1'
+    CassandraObject::Schemaless.add_index 'TestDropIndexes', 'id_value2', 'special_name'
+
+    CassandraObject::Schemaless.drop_index 'TestDropIndexes_id_value1_idx'
+    CassandraObject::Schemaless.drop_index 'special_name'
+  end
+
+end

data/test/unit/scope/finder_methods_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+
+class CassandraObject::FinderMethodsTest < CassandraObject::TestCase
+  test 'find' do
+    Issue.create.tap do |issue|
+      assert_equal issue, Issue.find(issue.id)
+    end
+
+    begin
+      Issue.find(nil)
+      assert false
+    rescue => e
+      assert_equal "Couldn't find Issue with key nil", e.message
+    end
+
+    assert_raise CassandraObject::RecordNotFound do
+      Issue.find('what')
+    end
+  end
+
+  test 'find with ids' do
+    first_issue = Issue.create
+    second_issue = Issue.create
+
+    assert_equal [], Issue.find([])
+    assert_equal [first_issue, second_issue].to_set, Issue.find([first_issue.id, second_issue.id]).to_set
+  end
+
+  test 'find_by_id' do
+    Issue.create.tap do |issue|
+      assert_equal issue, Issue.find_by_id(issue.id)
+    end
+
+    assert_nil Issue.find_by_id('what')
+  end
+
+  test 'find all in batches dynamic' do
+    first_issue = IssueDynamic.create(key: '1', title: 'tit', dynamic_field1: 'one', dynamic_field2: 'two')
+    second_issue = IssueDynamic.create(key: '2', title: 'tit', dynamic_field1: 'one', dynamic_field2: 'two')
+    res = IssueDynamic.find_all_in_batches
+    reobjected = res[:results].map { |key, val| {key: key }.merge(val) }
+
+    assert_equal [first_issue, second_issue].size, reobjected.size
+  end
+
+  test 'find all in batches dynamic paged' do
+
+    issues = []
+    100.times.each do |i|
+      issues << IssueDynamic.create(key: i, title: 'tit', dynamic_field1: 'one', dynamic_field2: 'two')
+    end
+
+    res = []
+    next_cursor = nil
+    iter = 0
+    loop do
+      iter += 1
+      resp = IssueDynamic.limit(10).find_all_in_batches(next_cursor)
+      res << resp[:results].map { |key, val| {key: key.to_s }.merge(val) }
+      next_cursor = resp[:next_cursor]
+      break if next_cursor.nil?
+    end
+    res.flatten!
+    IssueDynamic.delete(issues.map{|x| x[:key]})
+
+    assert_equal issues.size, res.size
+  end
+
+  test 'first' do
+    first_issue = Issue.create
+    second_issue = Issue.create
+
+    assert [first_issue, second_issue].include?(Issue.first)
+  end
+
+  test 'cql response: find with ids' do
+    first_issue = Issue.create
+    second_issue = Issue.create
+
+    assert_equal [], Issue.find([])
+    assert_equal [first_issue.get_cql_response, second_issue.get_cql_response].to_set, Issue.cql_response.find([first_issue.id, second_issue.id]).to_set
+  end
+
+  test 'cql response: find_by_id' do
+    Issue.create.tap do |issue|
+      assert_equal issue.get_cql_response, Issue.cql_response.find_by_id(issue.id)
+    end
+
+    assert_nil Issue.find_by_id('what')
+  end
+
+  # test 'cql response: all' do
+  #   first_issue = Issue.create
+  #   second_issue = Issue.create
+  #   assert_equal [first_issue.get_cql_response, second_issue.get_cql_response].to_set, Issue.cql_response.find_all_in_batches[:results].to_set
+  # end
+
+  test 'cql response: first' do
+    first_issue = Issue.create
+    second_issue = Issue.create
+    assert [first_issue.id, second_issue.id].include?(Issue.cql_response.first.keys.first)
+  end
+
+  test 'where' do
+    # todo make better tests
+    # mono parameter
+    res1 = Issue.cql_response.where("column1 < 'poi'").to_a
+    # bi parameter
+    res = Issue.cql_response.where('column1 < ?', 'poi').to_a
+  end
+
+  # test 'limit in first' do
+  #   first_issue = IssueDynamic.create(key: '1', title: 'tit', dynamic_field1: 'one', dynamic_field2: 'two')
+  #   f = IssueDynamic.first
+  # end
+
+end

data/test/unit/scope/query_methods_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class CassandraObject::Scope::QueryMethodsTest < CassandraObject::TestCase
+  test 'select' do
+    original_issue = Issue.create title: 'foo', description: 'bar'
+    found_issue =  Issue.select(:title).find(original_issue.id)
+
+    assert_equal 'foo', found_issue.title
+    assert_equal original_issue.id, found_issue.id
+    assert_nil found_issue.description
+  end
+
+  test 'select with block' do
+    foo_issue = Issue.create title: 'foo'
+    Issue.create title: 'bar'
+    assert_equal [foo_issue], Issue.find_all_in_batches[:results].select { |issue| issue.title == 'foo' }
+  end
+
+  test 'chaining where with scope' do
+    issue = Issue.create title: 'abc', description: 'def'
+    query = Issue.select(:title).for_key(issue.id)
+
+    assert_equal [:title], query.select_values
+  end
+
+  test 'only column names' do
+    Issue.create title: 'foo', description: 'bar'
+    foo_issue_columns =  Issue.columns.first
+    assert_equal ['created_at', 'description', 'title', 'updated_at'], foo_issue_columns[foo_issue_columns.keys.first]
+  end
+
+end

data/test/unit/scoping_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class CassandraObject::ScopingTest < CassandraObject::TestCase
+  test "scope" do
+    assert_kind_of CassandraObject::Scope, Issue.scope
+  end
+end

data/test/unit/timestamps_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class CassandraObject::TimestampsTest < CassandraObject::TestCase
+  test 'timestamps set on create' do
+    issue = Issue.create
+
+    assert_in_delta Time.now.to_i, issue.created_at.to_i, 3
+    assert_in_delta Time.now.to_i, issue.updated_at.to_i, 3
+  end
+
+  test 'updated_at set on change' do
+    issue = Issue.create
+
+    issue.updated_at = nil
+    issue.description = 'lol'
+    issue.save
+
+    assert_in_delta Time.now.to_i, issue.updated_at.to_i, 3
+  end
+
+  test 'created_at sets only if nil' do
+    time = 5.days.ago
+    issue = Issue.create created_at: time
+
+    assert_equal time, issue.created_at
+  end
+end

data/test/unit/types/array_type_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class CassandraObject::Types::ArrayTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal ['1', '2'].to_json, coder.encode(['1', '2'])
+
+    assert_raise ArgumentError do
+      coder.encode('wtf')
+    end
+  end
+
+  test 'decode' do
+    assert_equal ['1', '2'], coder.decode(['1', '2'].to_json)
+    assert_nil coder.decode(nil)
+    assert_nil coder.decode('')
+  end
+end

data/test/unit/types/base_type_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class CassandraObject::Types::BaseTypeTest < CassandraObject::Types::TestCase
+  test 'default' do
+    assert_nil coder.default
+    assert_equal '5', CassandraObject::Types::BaseType.new(default: '5').default
+    assert_equal 5.object_id, CassandraObject::Types::BaseType.new(default: 5).default.object_id
+  end
+
+  test 'encode' do
+    assert_equal '1', coder.encode(1)
+    assert_equal '', coder.encode(nil)
+    assert_equal '1', coder.encode('1')
+  end
+
+  test 'decode' do
+    assert_equal 'abc', coder.decode('abc')
+  end
+end

data/test/unit/types/boolean_type_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class CassandraObject::Types::BooleanTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal '1', coder.encode(true)
+    assert_equal '1', coder.encode('true')
+    assert_equal '1', coder.encode('1')
+
+    assert_equal '0', coder.encode(false)
+    assert_equal '0', coder.encode('false')
+    assert_equal '0', coder.encode('0')
+    assert_equal '0', coder.encode('')
+
+    assert_raise ArgumentError do
+      coder.encode('wtf')
+    end
+  end
+
+  test 'decode' do
+    assert_equal true, coder.decode('1')
+    assert_equal false, coder.decode('0')
+    # assert_nil coder.decode(nil)
+  end
+end

data/test/unit/types/date_type_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class CassandraObject::Types::DateTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal '2004-04-25', coder.encode(Date.new(2004, 4, 25))
+  end
+
+  test 'decode' do
+    assert_equal Date.new(2004, 4, 25), coder.decode('2004-04-25')
+  end
+
+  test 'decoding a blank dates' do
+    assert_nil coder.decode('')
+  end
+end

data/test/unit/types/float_type_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class CassandraObject::Types::FloatTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal '5.01', coder.encode(5.01)
+
+    assert_raise ArgumentError do
+      coder.encode('x')
+    end
+  end
+
+  test 'decode' do
+    assert_equal 0.0, coder.decode('xyz')
+    assert_equal 3.14, coder.decode('3.14')
+    assert_equal 5, coder.decode('5')
+  end
+end

data/test/unit/types/integer_type_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class CassandraObject::Types::IntegerTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal('3', coder.encode(3))
+    assert_equal('-3', coder.encode(-3))
+
+    assert_raise ArgumentError do
+      coder.encode('xx')
+    end
+  end
+
+  test 'decode' do
+    assert_nil coder.decode('')
+    assert_equal(0, coder.decode('abc'))
+    assert_equal(3, coder.decode('3'))
+    assert_equal(-3, coder.decode('-3'))
+  end
+end

data/test/unit/types/json_type_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class CassandraObject::Types::JsonTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal({a: 'b'}.to_json, coder.encode(a: 'b'))
+    assert_equal '-3', coder.encode(-3)
+  end
+
+  test 'decode' do
+    assert_equal({'a' => 'b'}, coder.decode({'a' => 'b'}.to_json))
+  end
+
+  test 'encode array' do
+    assert_equal(['a', 'b'].to_json, coder.encode(['a', 'b']))
+    assert_equal '-3', coder.encode(-3)
+  end
+
+  test 'decode array' do
+    assert_equal(['a', 'b'], coder.decode(['a', 'b'].to_json))
+  end
+
+
+end

data/test/unit/types/string_type_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class CassandraObject::Types::StringTypeTest < CassandraObject::Types::TestCase
+  test 'encode' do
+    assert_equal 'abc', coder.encode('abc')
+
+    assert_raise ArgumentError do
+      coder.encode(123)
+    end
+  end
+
+  test 'encode as utf' do
+    assert_equal(
+      '123'.force_encoding('UTF-8').encoding,
+      coder.encode('123'.force_encoding('ASCII-8BIT')).encoding
+    )
+  end
+
+  test 'encode frozen as utf' do
+    assert_equal(
+      '123'.force_encoding('UTF-8').encoding,
+      coder.encode('123'.force_encoding('ASCII-8BIT').freeze).encoding
+    )
+  end
+end