virsandra 0.5.0

data/spec/lib/virsandra/queries/add_query_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Virsandra::AddQuery do
+  let(:column_name){ "new_column" }
+  let(:column_type){ nil }
+  subject(:query){ described_class.new(column_name, column_type) }
+
+  describe "#to_s" do
+    subject{ super().to_s }
+
+    it{ should eq("ADD new_column varchar") }
+
+    context "column type specified" do
+      let(:column_type){ "int" }
+
+      it{ should eq("ADD new_column int") }
+    end
+
+    context "column name not specified" do
+      let(:column_name){ nil }
+      it "should raise error" do
+        expect{ subject }.to raise_error(Virsandra::InvalidQuery, "You must specify column name")
+      end
+    end
+  end
+end

data/spec/lib/virsandra/queries/alter_query_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Virsandra::AlterQuery do
+  let(:skip_validation){ true }
+  subject(:query){ described_class.new(skip_validation) }
+
+  describe "#to_s" do
+    subject{ super().to_s }
+
+    it{ should eq("ALTER") }
+
+  end
+
+  describe "#table" do
+    subject{ super().table("foo").to_s }
+
+    it{ should eq("ALTER TABLE foo")}
+
+    context "with validation" do
+      let(:skip_validation){ false }
+
+      it "should raise error when table not specified" do
+        expect{ query.to_s }.to raise_error(Virsandra::InvalidQuery, "You must set the table")
+      end
+    end
+  end
+
+  describe "#add" do
+    context "without column type" do
+      subject{ super().table("foo").add(:new_column).to_s }
+
+      it{ should eq("ALTER TABLE foo ADD new_column varchar")}
+    end
+  end
+end

data/spec/lib/virsandra/queries/delete_query_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Virsandra::DeleteQuery do
+  subject(:query){ described_class.new }
+
+  its(:to_s){ should eq("DELETE") }
+
+  describe "#from" do
+    it "deletes from given table" do
+      query.from("foo")
+      query.to_s.should eq("DELETE FROM foo")
+    end
+
+    it "allows to use table as alias method" do
+      query.table("foo")
+      query.to_s.should eq("DELETE FROM foo")
+    end
+  end
+
+  describe "#where" do
+    it "adds given criteria to query" do
+      query.from("foo").where(id: "123")
+      query.to_s.should eq("DELETE FROM foo WHERE id = '123'")
+    end
+
+    context "called more than once" do
+      it "should join all wheres together" do
+        query.from("foo").where(id: 1)
+        query.where(count: {gt: 4})
+        query.to_s.should eq("DELETE FROM foo WHERE id = 1 AND count > 4")
+      end
+    end
+  end
+end

data/spec/lib/virsandra/queries/insert_query_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Virsandra::InsertQuery do
+  subject(:query){ described_class.new }
+
+  describe "#into" do
+    subject{ super().into("foo") }
+
+    it "should raise error when values are missing" do
+      expect{ subject.to_s }.to raise_error(Virsandra::InvalidQuery, "You must set values")
+    end
+  end
+
+  describe "#values" do
+    subject{ super().values(column_name: "name") }
+
+    it "should raise error when into is missing" do
+      expect{ subject.to_s }.to raise_error(Virsandra::InvalidQuery, "You must set into")
+    end
+  end
+
+  describe "#to_s" do
+    context "when into is missing" do
+      it "should raise error when into is missing" do
+        expect{ query.to_s }.to raise_error(Virsandra::InvalidQuery, "You must set into")
+      end
+    end
+
+    context "when into and values are set" do
+      subject{ super().into("foo").values(id: 1, date: '2011-11-11').to_s }
+
+      it{ should eq("INSERT INTO foo (id, date) VALUES (1, '2011-11-11')") }
+    end
+  end
+
+end

data/spec/lib/virsandra/queries/limit_query_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virsandra::LimitQuery do
+  let(:number){ 4 }
+  subject{ described_class.new(number) }
+
+  describe "#to_s" do
+    subject{ super().to_s }
+
+    it{ should eq("LIMIT 4")}
+
+    context "when number is less than 1" do
+      let(:number){ 0 }
+
+      it "should raise error" do
+        expect{ subject }.to raise_error(Virsandra::InvalidQuery, "Limit must be positive number")
+      end
+    end
+  end
+end

data/spec/lib/virsandra/queries/order_query_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Virsandra::OrderQuery do
+  let(:columns){ nil }
+  subject{ described_class.new(columns) }
+
+  describe "#to_s" do
+    subject{ super().to_s }
+
+    it{ should eq("") }
+
+    context "when columns given as string" do
+      let(:columns){ "date DESC" }
+
+      it{ should eq("ORDER BY date DESC")}
+    end
+
+    context "when columns given as hash" do
+      let(:columns){ {date: :asc, user_id: :asc} }
+
+      it{ should eq("ORDER BY date ASC, user_id ASC")}
+    end
+
+    context "when unknown order given" do
+      let(:columns){ {data: :bzz} }
+
+      it "raises an error" do
+        expect{ subject }.to raise_error(Virsandra::InvalidQuery, "Unknown order bzz")
+      end
+    end
+
+  end
+end

data/spec/lib/virsandra/queries/select_query_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Virsandra::SelectQuery do
+  let(:columns){ nil }
+  let(:skip_validation){ true }
+  let(:query){ described_class.new(columns, skip_validation) }
+  subject{ query }
+
+  it "uses * as default columns" do
+    subject.to_s.should eq("SELECT *")
+  end
+
+  context "empty array given as columns" do
+    let(:columns){ [] }
+    it "uses * as default columns" do
+      subject.to_s.should eq("SELECT *")
+    end
+  end
+
+  context "when columns are given" do
+    subject{ super().to_s }
+
+    let(:columns){ "id, date" }
+
+    it{ should eq("SELECT id, date")}
+
+    context "when columns are array" do
+      let(:columns){ ['id', 'date'] }
+
+      it{ should eq("SELECT id, date")}
+    end
+  end
+
+  describe "#from" do
+    subject{ super().from("foo").to_s }
+
+    it{ should eq("SELECT * FROM foo")}
+  end
+
+  describe "#where" do
+    subject{ super().from("foo").where(id: 1).to_s }
+
+    it{ should eq("SELECT * FROM foo WHERE id = 1")}
+
+    context "called more than once" do
+      it "should join all wheres together" do
+        query.from("foo").where(id: 1)
+        query.where(count: {gt: 4})
+        query.to_s.should eq("SELECT * FROM foo WHERE id = 1 AND count > 4")
+      end
+    end
+  end
+
+  describe "#order" do
+    subject{ super().from("foo").order(date: "asc").to_s }
+
+    it{ should eq("SELECT * FROM foo ORDER BY date ASC")}
+  end
+
+  describe "#limit" do
+    subject{ super().from("foo").limit(3).to_s }
+
+    it{ should eq("SELECT * FROM foo LIMIT 3")}
+
+    context "when called more than once" do
+      it "uses only last one" do
+        query.from("foo").limit(1)
+        query.limit(4)
+        query.to_s.should eq("SELECT * FROM foo LIMIT 4")
+      end
+    end
+  end
+
+  describe "#reset" do
+    subject{ super().from("foo").where(id: 1) }
+
+    it "should reset query" do
+      subject.to_s.should eq("SELECT * FROM foo WHERE id = 1")
+      subject.reset
+      subject.where(date: "2011-11-11")
+      subject.to_s.should eq("SELECT * FROM foo WHERE date = '2011-11-11'")
+    end
+  end
+
+  describe "#to_s" do
+    let(:skip_validation){ false }
+    it "should validate from existence" do
+      expect{ query.to_s }.to raise_error(Virsandra::InvalidQuery, "You must set from")
+    end
+  end
+
+  describe "#allow_filtering!" do
+    subject{ super().from("foo").where(id: 1).allow_filtering!.to_s }
+
+    it{ should eq("SELECT * FROM foo WHERE id = 1 ALLOW FILTERING")}
+  end
+
+  describe "#deny_filtering!" do
+    subject{ super().from("foo").where(id: 1) }
+
+    it "should remove allow filtering clause" do
+      subject.allow_filtering!
+      subject.to_s.should eq("SELECT * FROM foo WHERE id = 1 ALLOW FILTERING")
+      subject.deny_filtering!
+      subject.to_s.should eq("SELECT * FROM foo WHERE id = 1")
+    end
+  end
+end

data/spec/lib/virsandra/queries/table_query_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virsandra::TableQuery do
+  describe "#to_s" do
+    it "return given table name" do
+      described_class.new("FROM", "foo").to_s.should eq("FROM foo")
+    end
+
+    it "return empty string when nil given" do
+      described_class.new("FROM",nil).to_s.should eq("")
+    end
+  end
+end

data/spec/lib/virsandra/queries/values_query_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Virsandra::ValuesQuery do
+  let(:values){ {} }
+  subject(:query){ described_class.new(values) }
+
+  describe "#to_s" do
+    subject{ super().to_s }
+
+    it{ should eq("") }
+
+    context "when values given" do
+      let(:values){ {id: 1, date: '2011-11-11'} }
+
+      it{ should eq("(id, date) VALUES (1, '2011-11-11')")}
+
+      it "should convert each value" do
+        Virsandra::CQLValue.should_receive(:convert).twice
+        subject
+      end
+    end
+
+    context "when any value is nil" do
+      let(:values){ {id: 1, date: nil} }
+
+      it{ should eq("(id) VALUES (1)")}
+    end
+
+    context "when all values are nil" do
+      let(:values){ {id: nil, date: nil} }
+
+      it{ should eq("")}
+    end
+
+    context "when values is something else than hash" do
+      let(:values){ [] }
+
+      it{ should eq("") }
+    end
+  end
+end

data/spec/lib/virsandra/queries/where_query_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Virsandra::WhereQuery do
+  subject(:query){ described_class.new(clause) }
+
+  describe "#+" do
+    let(:clause){ {id: [1,2]} }
+    let(:other_query){ described_class.new(other_clause) }
+    let(:other_clause){ {count: {lt_or_eq: 4}} }
+
+    it "merge both where clauses with AND" do
+      (query + other_query).should eq("WHERE id IN (1, 2) AND count <= 4")
+    end
+
+    it "should raise error when something else than WhereQuery is given" do
+      expect{ query + 1}.to raise_error(Virsandra::InvalidQuery, "WhereQuery can be mereged only with other WhereQuery")
+    end
+  end
+
+  describe "#to_s" do
+    subject{ super().to_s }
+
+    context "when clause given as string" do
+      let(:clause){ "id='1' AND count=6" }
+
+      it{ should eq("WHERE id='1' AND count=6")}
+    end
+
+    context "when clause given as hash" do
+      let(:clause){ {id: '1', count: 6} }
+
+      it{ should eq("WHERE id = '1' AND count = 6")}
+
+      it "should convert each value" do
+        Virsandra::CQLValue.should_receive(:convert).twice
+        subject
+      end
+    end
+
+
+    described_class::OPERATOR_MAPPING.reject{|key,value| key == :in}.each do |operator_name, operator|
+      context "when any clause value given as hash" do
+        let(:clause){ {id: '1', count: Hash[operator_name, 6]} }
+
+        it{ should eq("WHERE id = '1' AND count #{operator} 6") }
+
+        it "should convert each value" do
+          Virsandra::CQLValue.should_receive(:convert).twice
+          subject
+        end
+      end
+    end
+
+    context "when any clause value given as hash and hash key is :in" do
+      let(:clause){ {id: '1', count: {:in => 6}} }
+
+      it{ should eq("WHERE id = '1' AND count IN (6)")}
+
+      it "should convert each value" do
+        Virsandra::CQLValue.should_receive(:convert).twice
+        subject
+      end
+    end
+
+    context "when any clause value given as array" do
+      let(:clause){ {id: '1', count: [2,3]} }
+
+      it{ should eq("WHERE id = '1' AND count IN (2, 3)") }
+
+      it "should convert each value" do
+        Virsandra::CQLValue.should_receive(:convert).exactly(3).times
+        subject
+      end
+    end
+  end
+end

data/spec/lib/virsandra/query_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Virsandra::Query do
+
+  [:from, :table, :into, :where, :order, :limit, :add, :values].each do |method_name|
+    it "should raise error when #{method_name} called" do
+      expect{ described_class.new.send(method_name) }.to raise_error(Virsandra::InvalidQuery  )
+    end
+  end
+
+  it "should return empty hash when can't fetch hash from results" do
+    Virsandra.stub(:execute => double("row", :first => nil))
+    described_class.new.fetch.should eq({})
+  end
+
+  it "should return empty hash when results are not available" do
+    Virsandra.stub(:execute => nil )
+    described_class.new.fetch.should eq({})
+  end
+
+  it "adds a from method" do
+    q = Virsandra::Query.select.from(:foo)
+    q.to_s.should == "SELECT * FROM foo"
+
+    q = Virsandra::Query.insert.into(:foo).values(id: 1)
+    q.to_s.should == "INSERT INTO foo (id) VALUES (1)"
+
+    q = Virsandra::Query.delete.from(:foo)
+    q.to_s.should == "DELETE FROM foo"
+
+    q = Virsandra::Query.alter.table(:foo)
+    q.to_s.should == "ALTER TABLE foo"
+  end
+
+  it "can change the table" do
+    q = Virsandra::Query.insert.into(:foo).values(id: 1)
+
+    q.into(:bar)
+    q.to_s.should == "INSERT INTO bar (id) VALUES (1)"
+  end
+
+  it "adds a where clause when appropriate" do
+    q = Virsandra::Query.select.from(:foo).where(id: 'Funky', location: 'town')
+    q.to_s.should == "SELECT * FROM foo WHERE id = 'Funky' AND location = 'town'"
+
+    q.reset
+    q.where(can: "change options")
+    q.to_s.should == "SELECT * FROM foo WHERE can = 'change options'"
+
+    uuid = SimpleUUID::UUID.new
+    uuid.stub(to_guid: 'i-am-a-guid')
+
+    q.reset
+    q.where(cid: uuid, nummer: 123)
+    q.to_s.should == "SELECT * FROM foo WHERE cid = i-am-a-guid AND nummer = 123"
+
+    expect {
+      Virsandra::Query.insert.into(:foo).where(id: 1)
+    }.to raise_error(Virsandra::InvalidQuery)
+  end
+
+  it "can add values to an insert statement" do
+    q = Virsandra::Query.insert.into(:foo).values(id: 93, comment: "Stuff!")
+    q.to_s.should == "INSERT INTO foo (id, comment) VALUES (93, 'Stuff!')"
+
+    uuid = SimpleUUID::UUID.new
+    uuid.stub(to_guid: 'i-am-a-guid')
+
+    q.values(fun: 'time', lol: 'who', uuidz: uuid)
+    q.to_s.should == "INSERT INTO foo (fun, lol, uuidz) VALUES ('time', 'who', i-am-a-guid)"
+
+    expect {
+      Virsandra::Query.select.from(:foo).values(id: 1)
+    }.to raise_error(Virsandra::InvalidQuery)
+  end
+
+  it "alters the table" do
+    query = Virsandra::Query.alter.table(:foo).add(:name)
+    query.to_s.should == "ALTER TABLE foo ADD name varchar"
+
+    query.add(:patents, :integer)
+    query.to_s.should == "ALTER TABLE foo ADD patents integer"
+
+    expect {
+      Virsandra::Query.select.from(:foo).add(:funky)
+    }.to raise_error(Virsandra::InvalidQuery)
+
+  end
+
+  it "executes the query" do
+    q = Virsandra::Query.select.from(:foo).where({:id => 123, :name => "Funky"})
+
+    Virsandra.should_receive(:execute).
+      with("SELECT * FROM foo WHERE id = 123 AND name = 'Funky'")
+
+    q.execute
+  end
+
+  it "can fetch the row with symbolized keys" do
+    query = Virsandra::Query.select.from(:foo).where({:id => "0123", :name => "Funky"})
+
+    query.should_receive(:execute)
+    query.should_receive(:fetch_with_symbolized_keys)
+    query.fetch
+  end
+
+
+  it "can fetch a raw query" do
+    cql = "SELECT * FROM cities WHERE town = 'funky'"
+    query = Virsandra::Query.new
+
+    Virsandra.should_receive(:execute).with(cql)
+
+    query.fetch(cql)
+  end
+
+end