cassandra-cql 1.0.1

data/spec/schema_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "Schema class" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+    @connection.execute("USE system")
+  end
+
+  context "initialize" do
+    it "should set a thrift schema object" do
+      @connection.schema.schema.should be_kind_of(CassandraCQL::Thrift::KsDef)
+    end
+
+    it "should set column family hash" do
+      @connection.schema.column_families.should be_kind_of(Hash)
+    end
+
+    it "should set column family hash" do
+      @connection.schema.column_families.should be_kind_of(Hash)
+    end
+  end
+
+  it "should method_missing" do
+    expect {
+      @connection.schema.this_method_does_not_exist
+    }.to raise_error NoMethodError
+  end
+
+  context "name" do
+    it "should return keyspace name" do
+      @connection.schema.name.should eq('system')
+    end
+  end
+
+  context "to_s" do
+    it "should return keyspace name" do
+      @connection.schema.to_s.should eq(@connection.schema.name)
+    end
+  end
+
+  context "column_family_names" do
+    it "should return cf_def names" do
+      @connection.schema.column_family_names.sort.should eq(@connection.schema.schema.cf_defs.map(&:name).sort)
+    end
+    
+    it "should be the same as tables" do
+      @connection.schema.column_family_names.should eq(@connection.schema.tables)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'yaml'
+require 'rspec'
+$LOAD_PATH << "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+require 'cassandra-cql'
+
+def yaml_fixture(file)
+  if file.kind_of?(Symbol)
+    file = "#{file}.yaml"
+  elsif file !~ /\.yaml$/
+    file = "#{file}.yaml"
+  end
+  YAML::load_file(File.dirname(__FILE__) + "/fixtures/#{file}")
+end
+
+def setup_cassandra_connection
+  connection = CassandraCQL::Database.new(["127.0.0.1:9160"], {}, :retries => 2, :timeout => 1) rescue false
+  if !connection.keyspaces.map(&:name).include?("CassandraCQLTestKeyspace")
+    connection.execute("CREATE KEYSPACE CassandraCQLTestKeyspace WITH strategy_class='org.apache.cassandra.locator.SimpleStrategy' AND strategy_options:replication_factor=1")
+  end
+  connection.execute("USE CassandraCQLTestKeyspace")
+  
+  connection
+end

data/spec/statement_spec.rb

@@ -0,0 +1,224 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "initialize" do
+  it "should set a handle and prepare statement" do
+    statement = "use keyspace1"
+    handle = double("Database")
+    sth = Statement.new(handle, statement)
+    sth.statement.should eq(statement)
+    sth.instance_variable_get("@handle").should eq(handle)
+  end
+end
+
+describe "execute" do
+  context "when performing keyspace operations" do
+    before(:each) do
+      @connection = setup_cassandra_connection
+    end
+
+    it "should set keyspace without compression" do
+      @connection.keyspace.should_not eq('system')
+      stmt = @connection.prepare("use system")
+      stmt.execute([], :compression => false).should be_nil
+      @connection.keyspace.should eq('system')
+    end
+
+    it "should set keyspace with compression" do
+      @connection.keyspace.should_not eq('system')
+      stmt = @connection.prepare("use system")
+      stmt.execute([], :compression => true).should be_nil
+      @connection.keyspace.should eq('system')
+    end
+    
+    it "should set keyspace to nil when deleting keyspace" do
+      @connection.execute("DROP KEYSPACE #{@connection.keyspace}").should be_nil
+      @connection.keyspace.should be_nil
+    end
+  end
+  
+  context "when performing void-returning column_family operations" do
+    before(:each) do
+      @connection = setup_cassandra_connection
+      if !@connection.schema.column_family_names.include?('colfam_ops')
+        @connection.execute("CREATE COLUMNFAMILY colfam_ops (id varchar PRIMARY KEY)")
+      else
+        @connection.execute("TRUNCATE colfam_ops")
+      end
+    end
+
+    it "should return nil when inserting" do
+      @connection.execute("INSERT INTO colfam_ops (id, column) VALUES (?, ?)", "key", "value").should be_nil
+    end
+
+    it "should return nil when updating" do
+      @connection.execute("UPDATE colfam_ops SET column=? WHERE id=?", "value", "key").should be_nil
+    end
+
+    it "should return nil when deleting" do
+      @connection.execute("DELETE FROM colfam_ops WHERE id=?", "key").should be_nil
+    end
+  end
+end
+
+describe "escape" do
+  it "should escape quotes" do
+    Statement.escape(%q{'}).should eq(%q{''})
+    Statement.escape(%q{\'}).should eq(%q{\''})
+    Statement.escape(%q{''}).should eq(%q{''''})
+  end
+end
+
+describe "quote" do
+  context "with a string" do
+    it "should add quotes" do
+      Statement.quote("test").should eq("'test'")
+    end
+  end
+
+  context "with an integer" do
+    it "should not add quotes" do
+      Statement.quote(15).should eq(15)
+    end
+  end
+
+  context "with an array" do
+    it "should return a comma-separated list" do
+      Statement.quote([1, 2, 3]).should eq("1,2,3")
+      Statement.quote(["a", "b''", "c"]).should eq("'a','b''','c'")
+    end
+  end
+
+  context "with an unsupported object" do
+    it "should raise an exception" do
+      expect {
+        Statement.quote(Time.new)
+      }.to raise_error(CassandraCQL::Error::UnescapableObject)
+    end
+  end
+end
+
+describe "cast_to_cql" do
+  context "with a Time object" do
+    it "should return a guid of a UUID" do
+      ts = Time.new - 86400 # set it to yesterday just to be sure no defaulting to today misses an error
+      guid = Statement.cast_to_cql(ts)
+      guid.should be_kind_of(String)
+      expect {
+        ret = UUID.new(guid)
+        uuid_ts = Time.at(ret.seconds)
+        [:year, :month, :day, :hour, :min, :sec].each do |sym|
+          uuid_ts.send(sym).should eq(ts.send(sym))
+        end
+      }.to_not raise_error
+    end
+  end
+  
+  context "with a Fixnum object" do
+    it "should return the same object" do
+      Statement.cast_to_cql(15).should eq(15)
+    end
+  end
+  
+  context "with a UUID object" do
+    it "should return the a guid" do
+      uuid = UUID.new
+      guid = Statement.cast_to_cql(uuid)
+      guid.should eq(uuid.to_guid)
+    end
+  end
+
+  context "with a String without quotes" do
+    it "should return a copy of itself" do
+      str = "This is a string"
+      new_str = Statement.cast_to_cql(str)
+      str.should eq(str)
+      new_str.object_id.should_not eq(str.object_id)
+    end
+  end
+  
+  context "with a String with quotes" do
+    it "should return a quoted version" do
+      str = "This is a ' string"
+      new_str = Statement.cast_to_cql(str)
+      new_str.should_not eq(str)
+      new_str.should eq(Statement.escape(str))
+    end
+  end
+  
+  context "with binary data" do
+    it "should return an unpacked version" do
+      bytes = "binary\x00"
+      bytes = bytes.force_encoding('ASCII-8BIT') if RUBY_VERSION >= "1.9"
+      new_data = Statement.cast_to_cql(bytes)
+      new_data.should_not eq(bytes)
+      [new_data].pack('H*').should eq(bytes)
+    end
+  end
+  
+  context "with an array of Fixnums" do
+    it "should equal itself" do
+      arr = [1, 2, 3]
+      Statement.cast_to_cql(arr).should eq(arr)
+    end
+  end
+  
+  context "with an array of Strings" do
+    it "should return quoted versions of itself" do
+      arr = ["test", "'"]
+      res = Statement.cast_to_cql(arr)
+      arr.map { |o| Statement.cast_to_cql(o) }.should eq(res)
+    end
+  end
+end
+
+describe "sanitize" do
+  context "with no bind vars" do
+    it "should return itself" do
+      Statement.sanitize("use keyspace").should eq("use keyspace")
+    end
+  end
+  
+  context "when expecting bind vars" do
+    it "should raise an exception with bind variable mismatch" do
+      expect {
+        Statement.sanitize("use keyspace ?")
+      }.to raise_error(Error::InvalidBindVariable)
+
+      expect {
+        Statement.sanitize("use keyspace ?", ['too', 'many'])
+      }.to raise_error(Error::InvalidBindVariable)
+    end
+
+    it "should not raise an exception with matching bind vars" do
+      expect {
+        Statement.sanitize("use keyspace ?", ["test"]).should eq("use keyspace 'test'")
+      }.to_not raise_error(Error::InvalidBindVariable)
+    end
+
+    it "should have bind vars in the right order" do
+      expect {
+        Statement.sanitize("use keyspace ? with randomness (?)", ["test", "stuff"]).should eq("use keyspace 'test' with randomness ('stuff')")
+      }.to_not raise_error(Error::InvalidBindVariable)
+    end
+
+    it "should not double-escape the single quotes in your string" do
+      Statement.sanitize(
+        "insert into keyspace (key, ?) values (?)", ["vanilla", %Q{I\'m a string with \'cool\' quotes}]
+      ).should eq("insert into keyspace (key, 'vanilla') values ('I''m a string with ''cool'' quotes')")
+    end
+
+    it "should handle numbers and stuff appropriately" do
+      Statement.sanitize(
+        "insert into keyspace (key, ?) values (?)", [488, 60.368]
+      ).should eq("insert into keyspace (key, 488) values (60.368)")
+    end
+
+  end
+end
+
+describe "finish" do
+  it "should just return true .. nothing to clean up yet" do
+    Statement.new(nil, 'whatever').finish.should be_true
+  end
+end

data/spec/utility_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "compress" do
+  it "should return some valid gzipped stuff" do
+    stuff = "This is some stuff"
+    bytes = Utility.compress(stuff)
+    Utility.binary_data?(bytes).should be_true
+    Utility.decompress(bytes).should eq(stuff)
+  end
+  
+  it "should be binary data" do
+    if RUBY_VERSION >= "1.9"
+      Utility.binary_data?("binary\x00".force_encoding('ASCII-8BIT')).should be_true
+    else
+      Utility.binary_data?("binary\x00").should be_true
+    end
+  end
+
+  it "should not be binary data" do
+    Utility.binary_data?("test").should_not be_true
+    Utility.binary_data?("snårk").should_not be_true
+  end
+end
+

data/spec/uuid_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "UUID" do
+  it "should respond_to to_guid" do
+    UUID.new.respond_to?(:to_guid)
+  end
+
+  it "should respond_to to_time" do
+    UUID.new.respond_to?(:to_time)
+  end
+  
+  it "should instantiate from raw bytes" do
+    UUID.new("\252}\303\374\3137\021\340\237\214\251}\315\351 ]")
+  end
+
+  it "should instantiate from a Time object" do
+    ts = Time.new
+    UUID.new(ts).to_time.should eq(ts)
+  end
+  
+  it "should turn have a to_time class method that takes bytes" do
+    UUID.to_time("\252}\303\374\3137\021\340\237\214\251}\315\351 ]").should be_kind_of(Time)
+  end
+end
+

data/spec/validation_spec.rb

@@ -0,0 +1,250 @@
+# 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, value)
+    @connection.execute("insert into #{column_family} (id, test_column) values (?, ?)", 'test', value)
+    return @connection.execute("select test_column from #{column_family} where id = ?", 'test').fetch[0]
+  end
+
+  def create_column_family(name, test_column_type, opts="")
+    if !@connection.schema.column_family_names.include?(name)
+      @connection.execute("CREATE COLUMNFAMILY #{name} (id text PRIMARY KEY, test_column #{test_column_type}) #{opts}")
+    end
+  end
+
+  context "with ascii validation" do
+    let(:cf_name) { "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 validation" do
+    let(:cf_name) { "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 validation" do
+    let(:cf_name) { "validation_cf_blob" }
+    before(:each) { create_column_family(cf_name, 'blob') }
+
+    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 validation" do
+    let(:cf_name) { "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
+
+  context "with counter validation" do
+    let(:cf_name) { "validation_cf_counter" }
+    before(:each) {
+      if !@connection.schema.column_family_names.include?(cf_name)
+        @connection.execute("CREATE COLUMNFAMILY #{cf_name} (id text PRIMARY KEY) WITH default_validation=CounterColumnType")
+      end
+      @connection.execute("TRUNCATE #{cf_name}")
+    }
+
+    it "should increment a few times" do
+      10.times do |i|
+        @connection.execute("UPDATE #{cf_name} SET test=test + 1 WHERE id=?", 'test_key')
+        @connection.execute("SELECT test FROM #{cf_name} WHERE id=?", 'test_key').fetch[0].should eq(i+1)
+      end
+    end
+
+    it "should decrement a few times" do
+      10.times do |i|
+        @connection.execute("UPDATE #{cf_name} SET test=test - 1 WHERE id=?", 'test_key')
+        @connection.execute("SELECT test FROM #{cf_name} WHERE id=?", 'test_key').fetch[0].should eq((i+1)*-1)
+      end
+    end
+  end
+
+  context "with decimal validation" do
+    let(:cf_name) { "validation_cf_decimal" }
+    before(:each) { create_column_family(cf_name, 'decimal') }
+
+    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 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
+
+  context "with double validation" do
+    let(:cf_name) { "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(-1*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)
+      test_for_value(16777217.125)
+      test_for_value(1099511627776.125)
+    end
+  end
+
+  context "with float validation" do
+    let(:cf_name) { "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 validation" do
+    let(:cf_name) { "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 validation" do
+    let(:cf_name) { "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
+      if RUBY_VERSION >= "1.9"
+        create_and_fetch_column(cf_name, "sn\xC3\xA5rk".force_encoding('UTF-8')).should eq("sn\xC3\xA5rk".force_encoding('UTF-8'))
+      else
+        create_and_fetch_column(cf_name, "snårk").should eq("snårk")
+      end
+    end
+  end
+
+  context "with timestamp validation" do
+    let(:cf_name) { "validation_cf_timestamp" }
+    before(:each) { create_column_family(cf_name, 'timestamp') }
+
+    it "should return a timestamp" do
+      uuid = UUID.new
+      #create_and_fetch_column(cf_name, uuid).should eq(uuid)
+    end
+  end
+
+  context "with uuid validation" do
+    let(:cf_name) { "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 validation" do
+    let(:cf_name) { "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 validation" do
+    let(:cf_name) { "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