hallelujah-cassandra-cql 1.0.4

data/spec/conf/1.1/log4j-server.properties

@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# for production, you should probably set pattern to %c instead of %l.
+# (%l is slower.)
+
+# output messages into a rolling log file as well as stdout
+log4j.rootLogger=DEBUG,stdout,R
+
+# stdout
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%5p %d{HH:mm:ss,SSS} %m%n
+
+# rolling log file
+log4j.appender.R=org.apache.log4j.RollingFileAppender
+log4j.appender.R.maxFileSize=20MB
+log4j.appender.R.maxBackupIndex=50
+log4j.appender.R.layout=org.apache.log4j.PatternLayout
+log4j.appender.R.layout.ConversionPattern=%5p [%t] %d{ISO8601} %F (line %L) %m%n
+# Edit the next line to point to your logs directory
+log4j.appender.R.File=data/logs/system.log
+
+# Application logging options
+#log4j.logger.org.apache.cassandra=DEBUG
+#log4j.logger.org.apache.cassandra.db=DEBUG
+#log4j.logger.org.apache.cassandra.service.StorageProxy=DEBUG
+
+# Adding this to avoid thrift logging disconnect errors.
+log4j.logger.org.apache.thrift.server.TNonblockingServer=ERROR
+

data/spec/conf/1.1/schema.txt

@@ -0,0 +1,10 @@
+create keyspace TypeConversions with
+  placement_strategy = 'org.apache.cassandra.locator.LocalStrategy' AND
+  strategy_options = [{replication_factor:1}];
+use TypeConversions;
+create column family UUIDColumnConversion with comparator = TimeUUIDType;
+create column family SuperUUID with comparator = TimeUUIDType and column_type = Super;
+create column family IntegerConversion with comparator = 'IntegerType';
+create column family LongConversion with comparator = 'LongType';
+create column family CounterConversion with comparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;

data/spec/database_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "Database" do
+  before do
+    @connection = setup_cassandra_connection
+  end
+  
+  describe "reset!" do
+    it "should create a new connection" do
+      @connection.should_receive(:connect!)
+      @connection.reset!
+    end
+  end
+  
+  describe "login!" do
+    it "should call login! on connection" do
+      creds = { 'username' => 'myuser', 'password' => 'mypass' }
+      @connection.connection.should_receive(:login) do |auth|
+        auth.credentials.should eq(creds)
+      end
+      @connection.login!(creds['username'], creds['password'])
+    end
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,173 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "void results" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+  end
+
+  it "should return nil" do
+    @connection.execute("USE system").should be_nil
+  end
+end
+
+describe "sparse row results" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+    if !@connection.schema.column_family_names.include?('sparse_results')
+      @connection.execute("CREATE COLUMNFAMILY sparse_results (id varchar PRIMARY KEY)")
+    else
+      @connection.execute("TRUNCATE sparse_results")
+    end
+  end
+
+  it "should should be handled properly" do
+    @connection.execute("INSERT INTO sparse_results (id, col1, col2, col3) VALUES (?, ?, ?, ?)", 'key1', 'val1', 'val2', 'val3').should be_nil
+    @connection.execute("INSERT INTO sparse_results (id, col4, col5, col6) VALUES (?, ?, ?, ?)", 'key2', 'val4', 'val5', 'val6').should be_nil
+    result = @connection.execute("SELECT col1, col2, col3, col4 FROM sparse_results")
+    result.rows.should eq(2)
+    # First column should have 3 columns set, one nil
+    row = result.fetch
+    row.columns.should eq(4)
+    row.column_names.should eq(['col1', 'col2', 'col3', 'col4'])
+    row.column_values.should eq(['val1', 'val2', 'val3', nil])
+
+    # Second column should have the last column set
+    row = result.fetch
+    row.columns.should eq(4)
+    row.column_names.should eq(['col1', 'col2', 'col3', 'col4'])
+    row.column_values.should eq([nil, nil, nil, 'val4'])
+  end
+end
+
+describe "row results" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+    @connection.execute("INSERT INTO sparse_results (id, col1, col2, col3) VALUES (?, ?, ?, ?)", 'key1', 'val1', 'val2', 'val3').should be_nil
+    @connection.execute("INSERT INTO sparse_results (id, col4, col5, col6) VALUES (?, ?, ?, ?)", 'key2', 'val4', 'val5', 'val6').should be_nil
+    @result = @connection.execute("SELECT col1, col2, col3, col4 FROM sparse_results")
+  end
+
+  it "should return true only for rows?" do
+    @result.void?.should be_false
+    @result.rows?.should be_true
+    @result.int?.should be_false
+  end
+
+  it "should have two rows" do
+    @result.rows.should eq(2)
+  end
+  
+  context "initialize" do
+    it "should have a cursor set to 0" do
+      @result.instance_variable_get(:@cursor).should eq(0)
+    end
+  
+    it "should have a result" do
+      @result.instance_variable_get(:@result).should be_kind_of(CassandraCQL::Thrift::CqlResult)
+    end
+  end
+  
+  context "setting the cursor" do
+    it "should set the cursor" do
+      expect {
+        @result.cursor = 15
+      }.to_not raise_error
+      @result.instance_variable_get(:@cursor).should eq(15)
+    end 
+
+    it "should not set the cursor" do
+      expect {
+        @result.cursor = Object
+      }.to raise_error(CassandraCQL::Error::InvalidCursor)
+    end 
+  end
+
+  context "fetching a single row" do
+    it "should return a row object twice then nil" do
+      @result.fetch_row.should be_kind_of(Row)
+      @result.instance_variable_get(:@cursor).should eq(1)
+
+      @result.fetch_row.should be_kind_of(Row)
+      @result.instance_variable_get(:@cursor).should eq(2)
+      
+      @result.fetch_row.should be_nil
+      @result.instance_variable_get(:@cursor).should eq(2)
+    end
+  end
+  
+  context "resetting cursor should fetch the same row" do
+    it "should return the same row" do
+      @result.instance_variable_get(:@cursor).should eq(0)
+      arr = @result.fetch_array
+      @result.cursor = 0
+      arr.should eq(@result.fetch_array)
+    end
+  end
+  
+  context "fetch without a block" do
+    it "should return a row twice then nil" do
+      @result.fetch.should be_kind_of(Row)
+      @result.instance_variable_get(:@cursor).should eq(1)
+
+      @result.fetch.should be_kind_of(Row)
+      @result.instance_variable_get(:@cursor).should eq(2)
+      
+      @result.fetch.should be_nil
+      @result.instance_variable_get(:@cursor).should eq(2)
+    end
+  end
+  
+  context "fetch with a block" do
+    it "fetched count should equal the number of rows" do
+      counter = 0
+      @result.fetch do |row|
+        counter += 1
+        row.should be_kind_of(Row)
+      end
+      counter.should eq(@result.rows)
+    end
+  end
+
+  context "fetch_array without a block" do
+    it "should return a row as an array" do
+      row = @result.fetch
+      @result.cursor = 0
+      arr = @result.fetch_array
+      arr.should be_kind_of(Array)
+      arr.should eq(row.column_values)
+    end
+  end
+  
+  context "fetch_array_with a block" do
+    it "fetched count should equal the number of rows" do
+      counter = 0
+      @result.fetch_array do |arr|
+        counter += 1
+        arr.should be_kind_of(Array)
+      end
+      counter.should eq(@result.rows)
+    end
+  end
+
+  context "fetch_hash without a block" do
+    it "should return a hash" do
+      row = @result.fetch
+      @result.cursor = 0
+      hash = @result.fetch_hash
+      hash.should be_kind_of(Hash)
+      hash.should eq(row.to_hash)
+    end
+  end
+  
+  context "fetch_hash_with a block" do
+    it "should iterate rows() times and return hashes" do
+      counter = 0
+      @result.fetch_hash do |hash|
+        counter += 1
+        hash.should be_kind_of(Hash)
+      end
+      counter.should eq(@result.rows)
+    end
+  end
+end

data/spec/row_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+
+describe "basic methods" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+    if @connection.schema.column_family_names.include?('basic_methods')
+      @connection.execute("DROP COLUMNFAMILY basic_methods")
+    end
+    @connection.execute("CREATE COLUMNFAMILY basic_methods (id varchar PRIMARY KEY, created_at uuid, default_column varchar, name varchar, serial int)")
+
+    @connection.execute("INSERT INTO basic_methods (id, created_at, name, serial, default_column) VALUES (?, ?, ?, ?, ?)", 'test', Time.new, 'name', 12345, 'snork')
+    @row = @connection.execute("SELECT * FROM basic_methods WHERE id=?", "test").fetch
+  end
+
+  context "column_names" do
+    it "should return a list of column names" do
+      @row.column_names.sort.should eq(["created_at", "default_column", "id", "name", "serial"].sort)
+    end
+  end
+
+  context "column_values" do
+    it "should return a list of column values as Ruby objects" do
+      @row.column_values.should be_kind_of(Array)
+      @row.column_values.size.should eq(@row.column_names.size)
+    end
+  end
+    
+  context "columns" do
+    it "should equal the number of columns" do
+      @row.column_names.size.should eq(@row.column_values.size)
+      @row.columns.should eq(@row.column_names.size)
+    end
+  end
+  
+  context "checking casting" do
+    it "should return column_values for to_a" do
+      @row.to_a.should eq(@row.column_values)
+    end
+
+    it "should return a hash for to_hash" do
+      h = @row.to_hash
+      h.should be_kind_of(Hash)
+      h.keys.sort.should eq(@row.column_names.sort)
+    end
+  end
+  
+end

data/spec/rowkey_spec.rb

@@ -0,0 +1,233 @@
+# encoding: utf-8
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "Validation Roundtrip tests" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+  end
+
+  def create_and_fetch_column(column_family, row_key)
+    @connection.execute("insert into #{column_family} (id, test_column) values (?, ?)", row_key, 'test')
+    res = @connection.execute("select * from #{column_family} where id = ?", row_key)
+    return res.fetch['id']
+  end
+
+  def create_column_family(name, test_row_key_type)
+    if !@connection.schema.column_family_names.include?(name)
+      @connection.execute("CREATE COLUMNFAMILY #{name} (id #{test_row_key_type} PRIMARY KEY, test_column text)")
+    end
+  end
+
+  context "with ascii row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_ascii" }
+    before(:each) { create_column_family(cf_name, 'ascii') }
+
+    it "should return an ascii string" do
+      create_and_fetch_column(cf_name, "test string").should eq("test string")
+    end
+  end
+
+  context "with bigint row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_bigint" }
+    before(:each) { create_column_family(cf_name, 'bigint') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+    it "should properly convert integer values that fit into 1 byte" do
+      test_for_value(1)
+    end
+    it "should properly convert integer values that fit into 2 bytes" do
+      test_for_value(2**8 + 80)
+    end
+    it "should properly convert integer values that fit into 3 bytes" do
+      test_for_value(2**16 + 622)
+    end
+    it "should properly convert integer values that fit into 4 bytes" do
+      test_for_value(2**24 + 45820)
+    end
+    it "should properly convert integer values that fit into 5 bytes" do
+      test_for_value(2**32 + 618387)
+    end
+  end
+
+  context "with blob row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_blob" }
+    if CASSANDRA_VERSION.to_f == 0.8
+      before(:each) { create_column_family(cf_name, 'bytea') }
+    else
+      before(:each) { create_column_family(cf_name, 'blob') }
+    end
+
+    it "should return a blob" do
+      bytes = "binary\x00"
+      bytes = bytes.force_encoding('ASCII-8BIT') if RUBY_VERSION >= "1.9"
+      create_and_fetch_column(cf_name, bytes).should eq(bytes)
+    end
+  end
+
+  context "with boolean row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_boolean" }
+    before(:each) { create_column_family(cf_name, 'boolean') }
+
+    it "should return true" do
+      create_and_fetch_column(cf_name, true).should be_true
+    end
+
+    it "should return false" do
+      create_and_fetch_column(cf_name, false).should be_false
+    end
+  end
+
+  if CASSANDRA_VERSION.to_f >= 1.0
+    context "with decimal row_key_validation" do
+      let(:cf_name) { "row_key_validation_cf_decimal" }
+      before(:each) { create_column_family(cf_name, 'decimal') }
+
+      def test_for_value(value)
+        create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+        create_and_fetch_column(cf_name, value).should eq(value)
+      end
+
+      it "should return a small decimal" do
+        test_for_value(15.333)
+      end
+      it "should return a huge decimal" do
+        test_for_value(BigDecimal.new('129182739481237481341234123411.1029348102934810293481039'))
+      end
+    end
+  end
+
+  context "with double row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_double" }
+    before(:each) { create_column_family(cf_name, 'double') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should be_within(0.1).of(value)
+      create_and_fetch_column(cf_name, value*-1).should be_within(0.1).of(value*-1)
+    end
+  
+    it "should properly convert some float values" do
+      test_for_value(1.125)
+      test_for_value(384.125)
+      test_for_value(65540.125)
+      test_for_value(16777217.125)
+      test_for_value(1099511627776.125)
+    end
+  end
+
+  context "with float row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_float" }
+    before(:each) { create_column_family(cf_name, 'float') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+      create_and_fetch_column(cf_name, value).should eq(value)
+    end
+  
+    it "should properly convert some float values" do
+      test_for_value(1.125)
+      test_for_value(384.125)
+      test_for_value(65540.125)
+    end
+  end
+
+  context "with int row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_int" }
+    before(:each) { create_column_family(cf_name, 'int') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+    it "should properly convert integer values that fit into 1 byte" do
+      test_for_value(1)
+    end
+    it "should properly convert integer values that fit into 2 bytes" do
+      test_for_value(2**8 + 80)
+    end
+    it "should properly convert integer values that fit into 3 bytes" do
+      test_for_value(2**16 + 622)
+    end
+    it "should properly convert integer values that fit into 4 bytes" do
+      test_for_value(2**24 + 45820)
+    end
+  end
+
+  context "with text row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_text" }
+    before(:each) { create_column_family(cf_name, 'varchar') }
+
+    it "should return a non-multibyte string" do
+      create_and_fetch_column(cf_name, "snark").should eq("snark")
+    end
+
+    it "should return a multibyte string" do
+      create_and_fetch_column(cf_name, "snårk").should eq("snårk")
+    end
+  end
+
+  context "with timestamp row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_timestamp" }
+    if CASSANDRA_VERSION.to_f == 0.8
+      before(:each) { create_column_family(cf_name, 'date') }
+    else
+      before(:each) { create_column_family(cf_name, 'timestamp') }
+    end
+
+    it "should return a timestamp" do
+      uuid = UUID.new
+      #create_and_fetch_column(cf_name, uuid).should eq(uuid)
+    end
+  end
+
+  context "with uuid row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_uuid" }
+    before(:each) { create_column_family(cf_name, 'uuid') }
+
+    it "should return a uuid" do
+      uuid = UUID.new
+      create_and_fetch_column(cf_name, uuid).should eq(uuid)
+    end
+  end
+
+  context "with varchar row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_varchar" }
+    before(:each) { create_column_family(cf_name, 'varchar') }
+
+    it "should return a non-multibyte string" do
+      create_and_fetch_column(cf_name, "snark").should eq("snark")
+    end
+
+    it "should return a multibyte string" do
+      create_and_fetch_column(cf_name, "snårk").should eq("snårk")
+    end
+  end
+
+  context "with varint row_key_validation" do
+    let(:cf_name) { "row_key_validation_cf_varint" }
+    before(:each) { create_column_family(cf_name, 'varint') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+    it "should properly convert integer values that fit into 1 byte" do
+      test_for_value(1)
+    end
+    it "should properly convert integer values that fit into 2 bytes" do
+      test_for_value(2**8 + 80)
+    end
+    it "should properly convert integer values that fit into 3 bytes" do
+      test_for_value(2**16 + 622)
+    end
+    it "should properly convert integer values that fit into more than 8 bytes" do
+      test_for_value(2**256)
+    end
+  end
+end