cassandro 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NmU5NmI3YWNjYjMwYTYyZjQ2YjNlOGM1NTc4NTRkMmZkNDIwNjNlOA==
+  data.tar.gz: !binary |-
+    NDZkYjJiMmZlOWU1ZTRjZDk4MmI2N2IzODFjYzJiYzY2OWI3M2Q3Yg==
+SHA512:
+  metadata.gz: !binary |-
+    MDJiNDg1MTkyYWRmNzVjYzc0N2FkZjEzOGZmYThjMjRhZDViMmMwNjU4Yjgy
+    ZDJjYzM4NTliYTdhNmNlZjI3MDRmMDgwZjc1ZTQ3ODQ1ZjQ4ZTNhYjEwOTcz
+    ZmMxNjM4NjRjYjlhNjJiMWZiNTY4MjljZDNlODJjYjZkM2NmY2I=
+  data.tar.gz: !binary |-
+    MGU1MjY0ZTE5NzlkNDIyMWE0N2QzODllZmRhZDZiMzBlNWI3NmI5NmZjY2E4
+    ZjQ5YTI1OWQwYTZhMjM0OTEyY2VmMDYxYzdjY2RmNjViMDVmZDJlYTVkMTgx
+    YmRjYjAyYzM2OWRiMjI0YmIxZGZkM2UxYmRkYTc0MDE5MDQ5ZDI=

data/.gems

@@ -0,0 +1 @@
+cassandra-driver -v 1.0.0.beta.3

data/.gems-test

@@ -0,0 +1 @@
+protest -v 0.5.2

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright (C) 2014 Lautaro Orazi and Leonardo Mateo
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,187 @@
+# Cassandro
+
+Cassandro is a small Ruby ORM for Apache Cassandra 2.0 and CQL 3.0. Cassandro uses the new Datastax Ruby Driver (official driver).
+
+## Install
+ 
+`gem install cassandro`
+
+## Basic Cassandro
+
+Connecting to Cassandra DB: `Cassandro.connect(Hash options)`. For full list of options visit [Ruby Driver Documentation](http://datastax.github.io/ruby-driver/api/#cluster-class_method)
+
+```ruby
+Cassandro.connect(
+                  hosts: ['127.0.0.1'],
+                  keyspace: 'some_keyspace'
+                 )
+```
+
+Creating a new keyspace. For full details of keyspace creation visit [CLI keyspace](http://www.datastax.com/documentation/cassandra/2.0/cassandra/reference/referenceStorage_r.html)
+
+```ruby
+Cassandro.create_keyspace('new_keyspace', 'SimpleStrategy', 1)
+```
+
+Select keyspace outside `#connect`
+
+```ruby
+Cassandro.use('keyspace_name')
+```
+
+Create table.
+```ruby
+table = <<-TABLEDEF                                                              
+  CREATE TABLE IF NOT EXISTS table_name (                                              
+    id UUID,                                                                       
+    username VARCHAR,                                                                 
+    crypted_password VARCHAR,                                                      
+    created_at TIMESTAMP,                                                          
+    updated_at TIMESTAMP,                                                          
+    PRIMARY KEY(id,username)                                                          
+  )                                                                                
+TABLEDEF
+
+Cassandro.execute(table)
+```
+
+Execute queries.
+```ruby
+result = Cassandro.execute("SELECT * FROM table_name;")
+```
+
+Using Driver directly.
+```ruby
+statement = Cassandro.client.prepare("SELECT * FROM table_name WHERE colname = ?;")
+result = Cassandro.client.execute(statement, id)
+```
+
+## Cassandro::Model
+
+### Creating model
+Creating new model: make you class inherits form `Cassandro::Model`
+
+```ruby
+class SomeModel < Cassandro::Model
+end
+```
+
+Specifying table name using the method `table(table_name)`:
+
+```ruby
+class SomeModel < Cassandro::Model
+
+  table 'some_models'
+end
+```
+
+Adding attributes using the method `attribute(name, type, options)`:
+
+```ruby
+class SomeModel < Cassandro::Model
+
+  attribute :id, :uuid
+  attribute :name, :text
+end
+```
+
+types: :uuid, :text, :integer, :float, :timestamp, :datetime
+
+Setting the primary key using the method `primary_key(pk_name | Array)`:
+
+```ruby
+class SomeModel < Cassandro::Model
+
+  attribute :id, :uuid
+  attribute :name, :text
+  
+  primary_key :id
+
+end
+
+class SomeModel < Cassandro::Model
+
+  attribute :id, :uuid
+  attribute :name, :text
+  
+  primary_key [:id,:name]
+
+end
+```
+
+Setting unique field using the method `unique(field | Array)`:
+
+```ruby
+class SomeModel < Cassandro::Model
+
+  unique :name
+end
+```
+
+__A complete example__
+
+```ruby
+class SomeModel < Cassandro::Model
+
+  table 'some_models'
+
+  attribute :id, :uuid
+  attribute :name, :text
+  
+  primary_key [:id, :name]
+
+  unique :name
+end
+```
+
+### Interacting
+
+Creating a new row:
+
+```ruby
+somemodel = SomeModel.create(name: 'DaModel')
+=> #<SomeModel:0x00000001e7a0a8
+ @attributes={:name=>"DaModel", :id=>"1534214c-0e0b-455c-95e8-13677f56d6e5"},
+ @errors={},
+ @persisted=true>
+
+```
+
+Find row:
+
+```ruby
+SomeModel[name: 'DaModel']
+=> #<SomeModel:0x00000001d27930
+ @attributes={:id=>1534214c-0e0b-455c-95e8-13677f56d6e5, :name=>"DaModel"},
+ @errors={},
+ @persisted=true>
+```
+
+Checking errors:
+```ruby
+somemodel = SomeModel.create(name: 'DaModel')
+=> #<SomeModel:0x00000001d68160
+ @attributes={:name=>"DaModel", :id=>"a723301b-b94b-4a4b-8d36-872055734ab5"},
+ @errors={:unique=>"somemodel_not_unique"},
+ @persisted=false>
+
+somemodel.persisted?
+=> false
+
+somemodel.errors
+=> {:unique=>"somemodel_not_unique"}
+```
+
+## TODO
+
+* Migrations
+* Support Index
+* Better queries
+* Better documentation
+
+## How to collaborate
+
+If you find a bug or want to collaborate with the code, you can:
+
+* Report issues trhough the issue tracker
+* Fork the repository into your own account and submit a Pull Request

data/cassandro.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "cassandro"
+  s.version = "0.1.0"
+  s.summary = "Ruby ORM for Apache Cassandra"
+  s.license = "MIT"
+  s.description = "Lightweight Apache Cassandra ORM for Ruby"
+  s.authors = ["Lautaro Orazi", "Leonardo Mateo"]
+  s.email = ["orazile@gmail.com", "leonardomateo@gmail.com"]
+  s.homepage = "https://github.com/tarolandia/cassandro"
+  s.require_paths = ["lib"]
+  s.add_dependency "cassandra-driver", '>= 1.0.0.beta.3'
+  s.add_development_dependency "protest", '~> 0.5.3'
+
+  s.files = `git ls-files`.split("\n")
+end

data/lib/cassandro.rb

@@ -0,0 +1,4 @@
+require_relative './cassandro/core'
+require_relative './cassandro/support/hash'
+require_relative './cassandro/ext/soft_delete'
+require_relative './cassandro/model'

data/lib/cassandro/core.rb

@@ -0,0 +1,66 @@
+require 'cassandra'
+
+module Cassandro
+  @@cluster = nil
+  @@session = nil
+  @@tables = []
+
+  def self.cluster
+    @@cluster
+  end
+
+  def self.client
+    @@session
+  end
+
+  def self.tables
+    @@tables
+  end
+
+  def self.connect(options = {})
+    keyspace = options.delete(:keyspace)
+    @@cluster = Cassandra.connect(options)
+    @@session = @@cluster.connect(keyspace || nil)
+  end
+
+  def self.use(keyspace)
+    @@session.execute("USE #{keyspace}") if @session
+  end
+
+  def self.disconnect
+    @@cluster.close if @cluster
+    @@session = nil
+  end
+
+  def self.execute(cql_command)
+    @@session.execute(cql_command)
+  end
+
+  def self.create_keyspace(name, strategy = 'SimpleStrategy', replication_factor = 1)
+    keyspace_definition = <<-KSDEF
+      CREATE KEYSPACE IF NOT EXISTS #{name}
+      WITH replication = {
+        'class': '#{strategy}',
+        'replication_factor': #{replication_factor}
+      }
+    KSDEF
+    @@session.execute(keyspace_definition)
+  end
+
+  def self.truncate_table(table_name)
+    @@session.execute("TRUNCATE #{table_name}")
+  end
+
+  def self.register_table(table_def)
+    @@tables << table_def
+  end
+
+  def self.load_tables
+    @@tables.each do |table_definition|
+      queries = table_definition.split(";").map(&:strip)
+      queries.each do |query|
+        @@session.execute(query) unless query.empty?
+      end
+    end
+  end
+end

data/lib/cassandro/ext/soft_delete.rb

@@ -0,0 +1,24 @@
+module Cassandro
+  module SoftDelete
+    def self.included(model)
+      model.attribute :deleted, :boolean
+    end
+
+    def destroy
+      update_attributes(deleted: true)
+    end
+
+    def restore
+      update_attributes(deleted: false)
+    end
+
+    def deleted?
+      !!deleted
+    end
+
+    def exists?
+      !deleted
+    end
+  end
+end
+

data/lib/cassandro/model.rb

@@ -0,0 +1,318 @@
+module Cassandro
+  class Model
+    class ModelException < StandardError; end
+
+    attr_reader :attributes
+
+    def initialize(attrs = {}, persisted = false)
+      @attributes = {}
+      @errors = {}
+      @persisted = persisted
+
+      attrs.each do |att, val|
+        case val.class.name
+        when "Set"
+          send(:"#{att}=", val.to_a)
+        when "Cassandra::Uuid"
+          send(:"#{att}=", val.to_s)
+        else
+          send(:"#{att}=", val)
+        end
+      end
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def errors
+      @errors
+    end
+
+    def clear_errors
+      @errors = {}
+    end
+
+    def valid?
+      self.class.pk.any? && @errors.empty?
+    end
+
+    def cast(attribute)
+      self.class.cast_as(attribute, @attributes[attribute])
+    end
+
+    def unique?
+      self.class.uniqueness_defined? ? self.class[@attributes.slice(*self.class.uniques)].nil? : true
+    end
+
+    def update_attributes(attrs = {})
+      attrs = attrs.inject({}) do |memo, (k,v)|
+        memo[k.to_sym] = (v.nil? || v.to_s.empty?) ? nil : v #TODO: fix for Set, Map
+        memo
+      end#symbolize keys for later merge
+
+      p_keys = []
+      fields = []
+
+      self.class.pk.flatten.each do |k|
+        p_keys << "#{k} = #{cast(k)}"
+      end
+
+      attrs.keys.each do |field|
+        fields << "#{field} = ?"
+      end
+
+      query = "UPDATE #{self.class.table_name} SET #{fields.join(", ")} "
+      query += "WHERE #{p_keys.join(" AND ")}"
+
+      begin
+        st = Cassandro.client.prepare(query)
+        Cassandro.client.execute(st, *native_attributes(attrs))
+        @attributes.merge!(attrs)
+        true
+      rescue Exception => e
+        @errors[:update_error] = e.message
+        false
+      end
+    end
+
+    def save(insert_check = false)
+      clear_errors
+
+      if self.class.casts[:id] == :uuid
+        @attributes[:id] ||= SecureRandom.uuid
+      end
+
+      self.class.pk.flatten.each do |key|
+        if @attributes[key].nil?
+          @errors[:primary_key] = "#{key.to_s}_cant_be_nil"
+          return false
+        end
+      end
+
+      if !persisted? && self.class.uniqueness_defined? && !unique?
+        @errors[:unique] = "#{self.class.to_s.downcase}_not_unique"
+        return false
+      end
+
+      st = self.statement_for(:insert, :insert_check => insert_check)
+
+      begin
+        r = Cassandro.client.execute(st, *self.native_attributes)
+        raise ModelException.new('not_applied') unless !insert_check || (insert_check && r.first["[applied]"])
+        @persisted = true
+      rescue => e
+        @attributes[:id] = nil if !persisted? && @attributes.has_key?(:id)
+        @errors[:save] = e.message
+        false
+      end
+    end
+
+    def destroy
+      query = <<-QUERY
+        DELETE FROM #{self.class.table_name}
+        WHERE #{self.class.pk.flatten.map { |k| "#{k.to_s} = #{self.class.cast_as(k, @attributes[k])}" }.join(' AND ')}
+      QUERY
+      Cassandro.execute(query)
+    end
+
+    def self.table(name)
+      self.table_name = name.to_s
+    end
+
+    def self.attribute(name, type = String, options = {})
+      attributes << name
+      casts[name] = type
+
+      define_method(name) do
+        @attributes[name]
+      end
+
+      define_method(:"#{name}=") do |value|
+        @attributes[name] = value
+      end
+    end
+
+    def self.primary_key(keys)
+      if keys.is_a?(Array)
+        pk.push(*keys)
+      else
+        pk << keys
+      end
+    end
+
+    def self.unique(keys)
+      if keys.is_a?(Array)
+        uniques.push(*keys)
+      else
+        uniques << keys
+      end
+    end
+
+    def self.[](value)
+      if value.is_a?(Hash)
+        where = "#{value.map { |k,v| "#{k.to_s} = #{cast_as(k, v)}" }.join(' AND ')} ALLOW FILTERING"
+      else
+        where = "#{partition_key} = #{cast_as(partition_key, value)}"
+      end
+
+      query = <<-QUERY
+        SELECT *
+        FROM #{table_name}
+        WHERE #{where}
+      QUERY
+
+      result = Cassandro.execute(query)
+      return nil unless result.any?
+
+      self.new(result.first, true)
+    end
+
+    def self.create(attrs = {})
+      model = new(attrs)
+      model.save(true)
+
+      model
+    end
+
+    def self.all
+      query = "SELECT * FROM #{self.table_name}"
+
+      rows = Cassandro.execute(query)
+      all = []
+      rows.each do |row|
+        all << new(row)
+      end
+      all
+    end
+
+    def self.where(key, value)
+      key = key.to_sym
+      results = []
+
+      query = "SELECT * FROM #{table_name} WHERE #{key} = ? ALLOW FILTERING"
+
+      st = Cassandro.client.prepare(query)
+      rows = Cassandro.client.execute(st, value)
+
+      rows.each do |result|
+        results << new(result)
+      end
+
+      results
+    end
+
+    def self.count(key, value)
+      key = key.to_sym
+      query = "SELECT count(*) FROM #{table_name} WHERE #{key} = ? ALLOW FILTERING"
+
+      st = Cassandro.client.prepare(query)
+      results = Cassandro.client.execute(st, value)
+
+      results.first["count"]
+    end
+
+    def self.destroy_all
+      begin
+        query = "TRUNCATE #{table_name}"
+        st = Cassandro.execute(query)
+        st.is_a? Cassandra::Client::VoidResult
+      rescue e
+        false
+      end
+    end
+
+    def self.query(where, *values)
+      query = "SELECT * FROM #{table_name} WHERE #{where} ALLOW FILTERING"
+      st = Cassandro.client.prepare(query)
+      Cassandro.client.execute(st, *values)
+    end
+
+    protected
+    def self.attributes
+      @attributes ||= []
+    end
+
+    def self.pk
+      @pk ||= []
+    end
+
+    def self.table_name
+      @table_name ||= name.downcase
+    end
+
+    def self.table_name=(name)
+      @table_name = name
+    end
+
+    def self.casts
+      @cast ||= {}
+    end
+
+    def self.uniques
+      @unique ||= []
+    end
+
+    def self.uniqueness_defined?
+      uniques.any?
+    end
+
+    def self.cast_as(key, value)
+      return "NULL" if value.nil?
+
+      case casts[key]
+      when :text
+        "'#{value}'"
+      when :int, :integer
+        value.to_i
+      when :datetime
+        value.to_time.to_i * 1000
+      else
+        "#{value}"
+      end
+    end
+
+    def self.partition_key
+      pk.first
+    end
+
+    def statement_for(operation, options = {})
+      case operation
+      when :insert
+        #INSERT will update if the record already exists http://www.datastax.com/documentation/cql/3.0/cql/cql_reference/insert_r.html
+        query = <<-QUERY
+          INSERT INTO #{self.class.table_name}(#{@attributes.keys.map { |x| x.to_s}.join(',')})
+          VALUES(#{@attributes.keys.map { |x| '?' }.join(",")})
+          #{options[:insert_check] ? 'IF NOT EXISTS' : ''}
+        QUERY
+        if @insert_statement.nil? ||
+                      @insert_statement.metadata.count != @attributes.count
+          @insert_statement = Cassandro.client.prepare(query)
+        else
+          @insert_statement
+        end
+      end
+    end
+
+    def native_attributes(attrs = nil)
+      n_attrs = []
+      attrs ||= @attributes
+
+      attrs.each do |k, v|
+        case self.class.casts[k]
+        when :uuid
+          n_attrs << Cassandra::Uuid.new(attrs[k])
+        when :integer
+          n_attrs << attrs[k].to_i
+        when :float
+          n_attrs << attrs[k].to_f
+        when :datetime
+          n_attrs << attrs[k].to_time.to_i
+        else
+          n_attrs << attrs[k]
+        end
+      end
+      n_attrs
+    end
+  end
+end

data/lib/cassandro/support/hash.rb

@@ -0,0 +1,29 @@
+# Taken from i18n/core_ext/hash.rb ; https://github.com/svenfuchs/i18n/blob/master/lib/i18n/core_ext/hash.rb
+class Hash
+  def slice(*keep_keys)
+    h = {}
+    keep_keys.each { |key| h[key] = fetch(key) }
+    h
+  end unless Hash.method_defined?(:slice)
+
+  def except(*less_keys)
+    slice(*keys - less_keys)
+  end unless Hash.method_defined?(:except)
+
+  def deep_symbolize_keys
+    inject({}) { |result, (key, value)|
+      value = value.deep_symbolize_keys if value.is_a?(Hash)
+      result[(key.to_sym rescue key) || key] = value
+      result
+    }
+  end unless Hash.method_defined?(:deep_symbolize_keys)
+
+  # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+  HASH_MERGER = proc do |key, v1, v2|
+    Hash === v1 && Hash === v2 ? v1.merge(v2, &HASH_MERGER) : v2
+  end
+
+  def deep_merge!(data)
+    merge!(data, &HASH_MERGER)
+  end unless Hash.method_defined?(:deep_merge!)
+end

data/rakefile

@@ -0,0 +1,10 @@
+task default: :test
+
+desc "Run tests"
+task :test do
+  load_files 'test/*_test.rb'
+end
+
+def load_files(dir)                                                                                            
+  Dir[dir].each { |file| load file }                                                                           
+end 

data/test/cassandro_model_test.rb

@@ -0,0 +1,137 @@
+require_relative 'helper'
+require_relative 'support/tables'
+require 'securerandom'
+
+Protest.describe "Cassandro Model" do
+  setup do
+    Cassandro.connect(hosts: ['127.0.0.1'], keyspace: 'cassandro_test')
+  end
+
+  context 'Modeling' do
+    setup do
+      class Test < Cassandro::Model
+      end
+    end
+
+    test "adds table name" do
+      class Test < Cassandro::Model
+        table 'tests'
+      end
+      assert_equal 'tests', Test.table_name
+    end
+
+    test "adds attribute" do
+      class Test < Cassandro::Model
+        attribute :test_col_1, :uuid
+        attribute :test_col_2, :text
+      end
+      assert Test.attributes.include?(:test_col_1)
+      assert Test.attributes.include?(:test_col_2)
+    end
+
+    test "adds primary key" do
+      class Test < Cassandro::Model
+        primary_key :test_col_1
+      end
+      assert Test.pk.include?(:test_col_1)
+    end
+
+    test "adds unique field" do
+      class Test < Cassandro::Model
+        unique :test_col_1
+      end
+      assert Test.uniques.include?(:test_col_1)
+      assert Test.uniqueness_defined?
+    end
+
+    test "allows setting and getting attributes" do
+      uuid = SecureRandom.uuid
+      test = Test.new(test_col_1: uuid, test_col_2: 'test_value_2')
+      assert_equal uuid, test.test_col_1
+      assert_equal 'test_value_2', test.test_col_2
+    end
+  end
+
+  context 'Creating' do
+    setup do
+      class Test < Cassandro::Model
+        table 'tests'
+
+        attribute :test_col_1, :uuid
+        attribute :test_col_2, :text
+
+        primary_key :test_col_1
+        unique :test_col_1
+      end
+
+      Cassandro.truncate_table('tests')
+    end
+
+    test "creates a row" do
+      test = Test.create(test_col_1: SecureRandom.uuid, test_col_2: 'test_value_2')
+      assert test.persisted?
+    end
+
+    test "fails creating dup row" do
+      uuid = SecureRandom.uuid
+      test_1 = Test.create(test_col_1: uuid, test_col_2: 'test_value_2')
+      test_2 = Test.create(test_col_1: uuid, test_col_2: 'test_value_2')
+      assert !test_2.persisted?
+      assert_equal "test_not_unique", test_2.errors[:unique]
+    end
+  end
+
+  context 'Querying' do
+    setup do
+      class Test < Cassandro::Model
+        table 'tests'
+
+        attribute :test_col_1, :uuid
+        attribute :test_col_2, :text
+
+        primary_key :test_col_1
+        unique :test_col_1
+      end
+
+      Cassandro.truncate_table('tests')
+    end
+
+    test "gets row" do
+      uuid = SecureRandom.uuid
+      Test.create(test_col_1: uuid, test_col_2: 'test_value_2')
+      test = Test[uuid]
+      assert_equal uuid, test.test_col_1.to_s
+      assert_equal "test_value_2", test.test_col_2
+    end
+  end
+
+  context 'Updating' do
+    setup do
+      class Patient < Cassandro::Model
+        table :patients
+        attribute :name, :text
+        attribute :address, :text
+        attribute :age, :int
+
+        primary_key :name
+      end
+      Cassandro.truncate_table('patients')
+    end
+
+    test "updates attributes" do
+      patient = Patient.create(:name => "John Doe", :address => "Somewhere", :age => 30)
+      assert_equal 1, Patient.all.count
+
+      assert patient.update_attributes(:address => "Somewhere Else")
+      assert_equal 1, Patient.all.count
+      assert_equal "Somewhere Else", patient.address
+    end
+
+    test "won't update primary keys" do
+      patient = Patient.create(:name => "John Doe", :address => "Somewhere", :age => 30)
+
+      assert !patient.update_attributes(:name => "Jane Doe")
+      assert_equal "PRIMARY KEY part name found in SET part", patient.errors[:update_error]
+    end
+  end
+end

data/test/cassandro_test.rb

@@ -0,0 +1,19 @@
+require_relative 'helper'
+
+Protest.describe "Cassandro Module" do
+  setup do
+    SESSION.execute("DROP KEYSPACE IF EXISTS test_keyspace")
+  end
+
+  test "connects to database" do
+    client = Cassandro.connect(hosts: ["127.0.0.1"])
+    assert_equal Cassandra::Session, client.class
+  end
+
+  test "creates new keyspace" do
+    Cassandro.connect(hosts: ["127.0.0.1"])
+    assert_equal Cassandra::Results::Void, Cassandro.create_keyspace("test_keyspace").class
+    assert_equal NilClass, Cassandro.use("test_keyspace").class
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,24 @@
+require 'rack/test'
+require 'protest'
+
+require_relative '../lib/cassandro'
+
+CASSANDRA = Cassandra.connect(hosts: ['127.0.0.1'])
+SESSION = CASSANDRA.connect
+
+keyspace_definition = <<-KSDEF
+  CREATE KEYSPACE IF NOT EXISTS cassandro_test
+  WITH replication = {
+    'class': 'SimpleStrategy',
+    'replication_factor': 1
+  }
+KSDEF
+
+SESSION.execute(keyspace_definition)
+SESSION.execute("USE cassandro_test")
+
+class Protest::TestCase
+  include Rack::Test::Methods
+end
+
+Protest.report_with(:turn)

data/test/support/tables.rb

@@ -0,0 +1,20 @@
+SESSION.execute("DROP TABLE IF EXISTS tests")
+table = <<-TABLEDEF
+  CREATE TABLE IF NOT EXISTS tests (
+    test_col_1 UUID,
+    test_col_2 VARCHAR,
+    PRIMARY KEY(test_col_1)
+  )
+TABLEDEF
+SESSION.execute(table)
+
+SESSION.execute("DROP TABLE IF EXISTS patients")
+table = <<-TABLEDEF
+  CREATE TABLE IF NOT EXISTS patients (
+    name VARCHAR,
+    address VARCHAR,
+    age INT,
+    PRIMARY KEY(name)
+  )
+TABLEDEF
+SESSION.execute(table)

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: cassandro
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lautaro Orazi
+- Leonardo Mateo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.3
+- !ruby/object:Gem::Dependency
+  name: protest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+description: Lightweight Apache Cassandra ORM for Ruby
+email:
+- orazile@gmail.com
+- leonardomateo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gems
+- .gems-test
+- .gitignore
+- LICENSE
+- README.md
+- cassandro.gemspec
+- lib/cassandro.rb
+- lib/cassandro/core.rb
+- lib/cassandro/ext/soft_delete.rb
+- lib/cassandro/model.rb
+- lib/cassandro/support/hash.rb
+- rakefile
+- test/cassandro_model_test.rb
+- test/cassandro_test.rb
+- test/helper.rb
+- test/support/tables.rb
+homepage: https://github.com/tarolandia/cassandro
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Ruby ORM for Apache Cassandra
+test_files: []
+has_rdoc: