virsandra 0.5.0

data/lib/virsandra/version.rb

@@ -0,0 +1,3 @@
+module Virsandra
+  VERSION = "0.5.0"
+end

data/spec/feature_helper.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+TEST_KEYSPACE = "virtest"
+
+module IntegrationTestHelper
+  def create_keyspace
+    Virsandra.keyspace = 'system'
+    Virsandra.execute("CREATE KEYSPACE #{TEST_KEYSPACE} WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1}")
+    Virsandra.reset!
+  end
+
+  def create_companies_table
+    cql = <<-CQL
+       CREATE TABLE companies (
+          id uuid,
+          name text,
+          score int,
+          founder text,
+          founded int,
+          PRIMARY KEY (id, score))
+    CQL
+    Virsandra.keyspace = TEST_KEYSPACE
+    Virsandra.execute(cql)
+  end
+
+  def drop_keyspace
+    Virsandra.reset!
+    Virsandra.keyspace = 'system'
+    Virsandra.execute("DROP KEYSPACE #{TEST_KEYSPACE}")
+  end
+
+  def build_up
+    begin
+      create_keyspace
+      create_companies_table
+    rescue Cql::QueryError
+      drop_keyspace
+
+      if defined?(retried)
+        raise $!
+      else
+        retried = true
+        retry
+      end
+    end
+  end
+end
+
+
+
+RSpec.configure do |config|
+
+  config.include(IntegrationTestHelper)
+
+  config.before do
+    if example.metadata[:integration]
+      build_up
+      Virsandra.reset!
+      Virsandra.keyspace = TEST_KEYSPACE
+    end
+  end
+end

data/spec/integration/virsandra_spec.rb

@@ -0,0 +1,13 @@
+require 'feature_helper'
+
+describe "Virsandra", integration: true do
+
+  it "return connection to server" do
+    Virsandra.connection.should_not be_nil
+  end
+
+  it "allows to disconnect" do
+    Virsandra.connection.should_receive(:disconnect!).and_call_original
+    Virsandra.disconnect!
+  end
+end

data/spec/lib/virsandra/configuration_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Virsandra::Configuration do
+  subject(:config){ described_class.new(given_options) }
+  let(:given_options){ {} }
+
+  its(:servers){ should eq("127.0.0.1") }
+  its(:consistency){ should eq(:quorum) }
+  its(:keyspace){ should be_nil }
+
+  it "uses given values over default ones" do
+    described_class.new(consistency: :one).consistency.should eq(:one)
+  end
+
+  describe "validate!" do
+    context "no keyspace" do
+      it "should raise an error" do
+        expect{ config.validate! }.to raise_error(Virsandra::ConfigurationError)
+      end
+    end
+
+    context "no servers" do
+      let(:given_options){ {servers: nil} }
+
+      it "should raise an error" do
+        expect{ config.validate! }.to raise_error(Virsandra::ConfigurationError)
+      end
+    end
+  end
+
+  describe "#reset!" do
+    let(:given_options){ {keyspace: :my_keyspace} }
+
+    it "reset options to default ones" do
+      config.reset!
+      config.keyspace.should == :my_keyspace
+    end
+  end
+
+  describe "to_hash" do
+    it "returns all options as a hash" do
+      config.to_hash.should eq({
+        consistency: :quorum,
+        keyspace: nil,
+        servers: "127.0.0.1"
+      })
+    end
+  end
+
+  describe "changed?" do
+    it "should be changed when option attribute value changes" do
+      config.changed?.should be_false
+      config.keyspace = :other
+      config.changed?.should be_true
+    end
+
+    it "stops being changed when changes are accepted" do
+      config.changed?.should be_false
+      config.keyspace = :other
+      config.changed?.should be_true
+      config.accept_changes
+      config.changed?.should be_false
+    end
+  end
+
+end

data/spec/lib/virsandra/connection_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Virsandra::Connection do
+  let(:config){ Virsandra::Configuration.new(keyspace: :my_keyspace) }
+  let(:handle){ double("handle", use: nil) }
+  subject(:connection){ described_class.new(config) }
+
+  before do
+    Cql::Client.stub(:connect).and_return(handle)
+  end
+
+  its(:config){ should eq(config) }
+
+  context "invalid configuration" do
+    it "raises an exception if settings are invalid" do
+      config.keyspace = nil
+      expect { connection }.to raise_error(Virsandra::ConfigurationError)
+    end
+  end
+
+  it "obtains a db connection" do
+    connection.handle.should eq(handle)
+  end
+
+  it "delegates to the cassandra handle" do
+    connection.handle.should_receive(:keyspace)
+    connection.keyspace
+  end
+
+  it "checks if a cassandra connection will respond to a method" do
+    handle.stub(:respond_to? => true)
+    connection.should respond_to :execute
+  end
+
+  it "should disconnect" do
+    handle.should_receive(:close)
+    connection.disconnect!
+  end
+
+  describe "#execute" do
+    it "should use configuration consistency when none is given" do
+      config.consistency = :one
+      handle.should_receive(:execute).with("query", :one)
+      connection.execute("query")
+    end
+  end
+end

data/spec/lib/virsandra/cql_value_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Virsandra::CQLValue do
+
+  subject { Virsandra::CQLValue }
+
+  it "returns plain numbers" do
+    subject.convert(10).should == "10"
+    subject.convert(10.0).should == "10.0"
+    subject.convert(BigDecimal.new("10.0")).should == "0.1E2"
+  end
+
+  it "quotes strings" do
+    subject.convert("Hello").should == "'Hello'"
+  end
+
+  it "escapes strings" do
+    subject.convert("It's all good.").should == "'It''s all good.'"
+  end
+
+  it "converts UUID to guid" do
+    uuid = SimpleUUID::UUID.new
+    subject.convert(uuid).should == uuid.to_guid
+  end
+end

data/spec/lib/virsandra/model_query_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Virsandra::ModelQuery do
+
+  let(:model) {
+    stub(:model,
+         attributes: {id: 123, name: 'Funky Circle'},
+         table: :companies,
+         key: {id: 123})
+  }
+
+  let(:model_query) { Virsandra::ModelQuery.new(model) }
+
+  it "stores the model on initialization" do
+    model_query
+    model_query.instance_variable_get(:@model).should == model
+  end
+
+  it "saves the model" do
+    query = stub(into: '', values: '', fetch: '')
+
+    Virsandra::Query.should_receive(:insert).and_return(query)
+
+    query.should_receive(:into).with(:companies).and_return(query)
+    query.should_receive(:values).with(id: 123, name: "Funky Circle").and_return(query)
+    query.should_receive(:fetch)
+    model_query.save
+  end
+
+  it "can retrieve the hash row from cassandra using the model's key" do
+    query = stub(from: '', where: '', fetch: '')
+
+    Virsandra::Query.should_receive(:select).and_return(query)
+    model.should_receive(:valid?).and_return(true)
+    query.should_receive(:from).with(:companies).and_return(query)
+    query.should_receive(:where).with(id: 123).and_return(query)
+    query.should_receive(:fetch)
+
+    model_query.find_by_key
+  end
+
+  it "doesn't fetch a row if the model is invalid" do
+    model.should_receive(:valid?).and_return(false)
+    model_query.find_by_key.should == {}
+  end
+
+  it "deletes the model" do
+    query = stub(from: '', where: '', fetch: '')
+
+    Virsandra::Query.should_receive(:delete).and_return(query)
+    query.should_receive(:from).with(:companies).and_return(query)
+    query.should_receive(:where).with(id: 123).and_return(query)
+    query.should_receive(:fetch)
+
+    model_query.delete
+  end
+
+end

data/spec/lib/virsandra/model_spec.rb

@@ -0,0 +1,173 @@
+require 'feature_helper'
+
+class Company
+  include Virsandra::Model
+
+  attribute :id, SimpleUUID::UUID, :default => proc { SimpleUUID::UUID.new }
+  attribute :name, String
+  attribute :score, Fixnum
+  attribute :founded, Fixnum
+  attribute :founder, String
+
+  table :companies
+  key :id, :score
+end
+
+
+describe Virsandra::Model, integration: true do
+
+  let(:id) { SimpleUUID::UUID.new }
+
+  let(:company) { Company.new(id: id, name: "Testco", score: 78)}
+
+  it "has attributes" do
+    company.attributes.should be_a Hash
+  end
+
+  it "selects keys" do
+    company.key.should == {id: id, score: 78}
+  end
+
+  it "reads the configured table" do
+    company.table.should == :companies
+  end
+
+  it "is valid with a key" do
+    company.should be_valid
+  end
+
+  it "is invalid when a key element is nil" do
+    company.id = nil
+    company.should_not be_valid
+  end
+
+  describe "with no assigned id" do
+    it "creates unique uuid's for each instance" do
+      company_one = Company.new(name: 'x')
+      company_two = Company.new(name: 'x')
+      company_one.should_not == company_two
+      company_one[:id].should_not == company_two[:id]
+    end
+  end
+
+  it "is equivelent with the same model same attributes" do
+    Company.new(id: id, name: 'x').should == Company.new(id: id, name: 'x')
+  end
+
+  it "is not equivelent with different attributes" do
+    Company.new(id: id, name: 'x').should_not == Company.new(id: id, name: 'y')
+  end
+
+  it "is not equivelent to a different model" do
+    Company.new(id: id, name: 'x').should_not == stub(attributes: {id: id, name: 'x'})
+  end
+
+  describe "finding an existing record" do
+    before do
+      Virsandra.execute("INSERT INTO companies (id, score, name, founded) VALUES (#{id.to_guid}, 101, 'Funky', 1990)")
+    end
+
+    it "can find a record from a key" do
+      company = Company.find(id: id, score: 101)
+      company.attributes.should == {id: id, score: 101, name: "Funky", founded: 1990, founder: nil}
+    end
+
+    it "raises an error with an incomplete key" do
+      expect { Company.find(score: 11) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an error with an over-specified key" do
+      expect { Company.find(score: 11, id: id, name: 'Whatever') }.to raise_error(ArgumentError)
+    end
+
+    it "populates missing columns, keeping specified values" do
+      attrs = {id: id, name: "Google", score: 101, founder: "Larry Brin"}
+
+      company = Company.load(attrs)
+      company.attributes.should == attrs.merge(founded: 1990)
+    end
+  end
+
+  describe "saving a model" do
+    before do
+      Virsandra.execute("USE virtest")
+      Virsandra.execute("TRUNCATE companies")
+    end
+
+    it "can be saved" do
+      company = Company.new(id: id, score: 101, name: "Job Place")
+      company.save
+      Company.find(company.key).should == company
+    end
+
+    it "doesn't save when invalid" do
+      company = Company.new(name: "Keyless Inc.")
+      Virsandra::ModelQuery.should_not_receive(:new)
+      company.save
+    end
+  end
+
+  describe "deleting a model" do
+    before do
+      Virsandra.execute("USE virtest")
+      Virsandra.execute("TRUNCATE companies")
+    end
+
+    it "can be deleted" do
+      Virsandra.execute("INSERT INTO companies (id, score) VALUES (#{id.to_guid}, 101)")
+      company = Company.find(id: id, score: 101)
+      company.delete
+      Company.where(id: id, score: 101).to_a.should be_empty
+    end
+
+    it "only deletes the current model" do
+      Virsandra.execute("INSERT INTO companies (id, score) VALUES (#{id.to_guid}, 101)")
+      Virsandra.execute("INSERT INTO companies (id, score) VALUES (#{id.to_guid}, 102)")
+      company = Company.find(id: id, score: 101)
+      company.delete
+      Company.where(id: id, score: 102).to_a.should_not be_empty
+
+    end
+
+
+
+  end
+
+  describe "working with existing records" do
+    before do
+      Virsandra.execute("USE virtest")
+      Virsandra.execute("TRUNCATE companies")
+
+      5.times { |n| Company.new(id: id, score: n + 1, name: "Test").save }
+      5.times { |n| Company.new(id: SimpleUUID::UUID.new, score: n + 1, name: "Test").save }
+    end
+
+    it "checks all search terms are attributes" do
+      expect { Company.where(id: 1, missing: 'key') }.to raise_error(ArgumentError)
+      expect { Company.where(id: id, score: 10) }.not_to raise_error(ArgumentError)
+    end
+
+    it "returns an enumerable" do
+      Company.where(id: id).should be_an Enumerator
+    end
+
+    it "creates an model instance for each entry " do
+      Company.where(id: id).map(&:score).should == [1,2,3,4,5]
+    end
+
+    it "can get all records" do
+      Company.all.to_a.length.should == 10
+    end
+
+    it "lazily instanciates models" do
+      Company.should_receive(:new).twice
+      Company.all.take(2)
+    end
+
+    it "can be empty" do
+      Company.where(id: id, score: 1009).to_a.should be_empty
+    end
+
+  end
+
+end