query_builder 0.0.1

data/spec/integration/insert_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+describe "INSERT" do
+
+  include QueryBuilder::CQL::Operators
+
+  let(:table) { QueryBuilder::CQL.keyspace(:wildlife).table(:species) }
+
+  it_behaves_like :query_builder do
+    subject do
+      table
+        .insert(names: ["tiger", "pantera tigra"])
+        .insert(sizes: { length: 3 })
+        .if_not_exists
+        .using(ttl: 500)
+        .using(timestamp: 100)
+    end
+
+    let(:cql) { "INSERT INTO wildlife.species (names, sizes) VALUES (['tiger', 'pantera tigra'], {'length': 3}) USING TIMESTAMP 100 AND TTL 500 IF NOT EXISTS;" }
+  end
+
+end # describe INSERT

data/spec/integration/list_permissions_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+describe "LIST" do
+
+  let(:root)     { QueryBuilder::CQL }
+  let(:keyspace) { root.keyspace(:wildlife) }
+  let(:table)    { keyspace.table(:species) }
+
+  it_behaves_like :query_builder do
+    subject { root.permission.of(:admin) }
+    let(:cql) { "LIST ALL PERMISSIONS ON ALL KEYSPACES OF admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { root.permission(:alter).of(:admin) }
+    let(:cql) { "LIST ALTER PERMISSION ON ALL KEYSPACES OF admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { keyspace.permission(:create).of(:admin) }
+    let(:cql) { "LIST CREATE PERMISSION ON KEYSPACE wildlife OF admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { table.permission(:drop).of(:admin) }
+    let(:cql) { "LIST DROP PERMISSION ON TABLE wildlife.species OF admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { table.permission(:drop).of(:admin).norecursive }
+    let(:cql) { "LIST DROP PERMISSION ON TABLE wildlife.species OF admin NORECURSIVE;" }
+  end
+
+end # describe LIST

data/spec/integration/list_roles_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe "LIST ROLES" do
+
+  let(:statement) { QueryBuilder::CQL.roles }
+
+  it_behaves_like :query_builder do
+    subject   { statement }
+    let(:cql) { "LIST ROLES;" }
+  end
+
+end # describe LIST ROLES

data/spec/integration/list_users_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe "LIST USERS" do
+
+  let(:statement) { QueryBuilder::CQL.users }
+
+  it_behaves_like :query_builder do
+    subject   { statement }
+    let(:cql) { "LIST USERS;" }
+  end
+
+end # describe LIST USERS

data/spec/integration/revoke_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+describe "REVOKE" do
+
+  let(:root)     { QueryBuilder::CQL }
+  let(:keyspace) { root.keyspace(:wildlife) }
+  let(:table)    { keyspace.table(:species) }
+
+  it_behaves_like :query_builder do
+    subject { root.permission.revoke_from(:admin) }
+    let(:cql) { "REVOKE ALL PERMISSIONS ON ALL KEYSPACES FROM admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { root.permission(:alter).revoke_from(:admin) }
+    let(:cql) { "REVOKE ALTER PERMISSION ON ALL KEYSPACES FROM admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { keyspace.permission(:create).revoke_from(:admin) }
+    let(:cql) { "REVOKE CREATE PERMISSION ON KEYSPACE wildlife FROM admin;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject { table.permission(:drop).revoke_from(:admin) }
+    let(:cql) { "REVOKE DROP PERMISSION ON TABLE wildlife.species FROM admin;" }
+  end
+
+end # describe REVOKE

data/spec/integration/select_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+describe "SELECT" do
+
+  include QueryBuilder::CQL::Operators
+
+  let(:table) { QueryBuilder::CQL.keyspace(:wildlife).table(:species) }
+
+  it_behaves_like :query_builder do
+    subject   { table.select }
+    let(:cql) { "SELECT * FROM wildlife.species;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject   { table.select.count }
+    let(:cql) { "SELECT COUNT(*) FROM wildlife.species;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject   { table.select.count(1) }
+    let(:cql) { "SELECT COUNT(1) FROM wildlife.species;" }
+  end
+
+  it_behaves_like :query_builder do
+    subject   { table.select.where_clustered(name: :tiger, family: :cat) }
+    let(:cql) { "SELECT * FROM wildlife.species WHERE (name, family) = ('tiger', 'cat');" }
+  end
+
+  it_behaves_like :query_builder do
+    subject do
+      table
+        .select(id: :uuid)
+        .select(:name)
+        .order(:name, :desc)
+        .distinct
+        .where(id: cql_gte(3))
+        .where(id: cql_lt(10), area: cql_in("park", "garden"))
+        .where(cql_element[:names, 1] => :cat)
+        .limit(10)
+        .allow_filtering
+    end
+
+    let(:cql) { "SELECT DISTINCT uuid AS id, name FROM wildlife.species WHERE id >= 3 AND id < 10 AND area IN ('park', 'garden') AND names[1] = 'cat' ORDER BY (name DESC) LIMIT 10 ALLOW FILTERING;" }
+  end
+
+end # describe SELECT

data/spec/integration/truncate_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe "TRUNCATE" do
+
+  let(:table) { QueryBuilder::CQL.keyspace(:wildlife).table(:species) }
+
+  it_behaves_like :query_builder do
+    subject   { table.truncate }
+    let(:cql) { "TRUNCATE wildlife.species;" }
+  end
+
+end # describe TRUNCATE

data/spec/integration/update_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+describe "UPDATE" do
+
+  include QueryBuilder::CQL::Operators
+
+  let(:table) { QueryBuilder::CQL.keyspace(:wildlife).table(:species) }
+
+  it_behaves_like :query_builder do
+    subject do
+      table
+        .update(name: :tiger, weight: 300)
+        .update(size: 3)
+        .where(id: 1, name: [:tiger, :bear])
+        .if_exists
+        .if(name: :tiger)
+        .using(ttl: 100, timestamp: 300)
+    end
+
+    let(:cql) { "UPDATE wildlife.species USING TIMESTAMP 300 AND TTL 100 SET name = 'tiger', weight = 300, size = 3 WHERE id = 1 AND name IN ('tiger', 'bear') IF EXISTS AND name = 'tiger';" }
+  end
+
+end # describe UPDATE

data/spec/integration/use_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe "USE" do
+
+  let(:keyspace) { QueryBuilder::CQL.keyspace(:wildlife) }
+
+  it_behaves_like :query_builder do
+    subject   { keyspace.use }
+    let(:cql) { "USE wildlife;" }
+  end
+
+end # describe USE

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "query_builder"
+
+# Load shared examples for specs
+require "transproc/rspec"
+require "query_builder/rspec"

data/spec/unit/core/attribute_error_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+describe QueryBuilder::Core::AttributeError do
+
+  let(:error) { described_class.new(:missed, attributes) }
+  let(:attributes) { [:foo] }
+
+  describe ".new" do
+    subject { error }
+
+    it "is a KeyError" do
+      expect(error).to be_kind_of KeyError
+    end
+
+    it "is immutable" do
+      expect(error).to be_frozen
+    end
+  end # describe .new
+
+  describe "#message" do
+    subject { error.message }
+
+    context "with one attribute" do
+      it "returns proper text" do
+        expect(subject).to eql "missed attribute: :foo"
+      end
+    end # context
+
+    context "with many attributes" do
+      let(:attributes) { [:foo, :bar] }
+
+      it "returns proper text" do
+        expect(subject).to eql "missed attributes: :foo, :bar"
+      end
+    end # context
+  end # describe #message
+
+end # describe QueryBuilder::Core::AttributeError

data/spec/unit/core/attribute_spec.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+describe QueryBuilder::Core::Attribute do
+
+  let(:attribute) { described_class.new :foo }
+
+  describe ".new" do
+    subject { attribute }
+
+    it "is immutable" do
+      expect(subject).to be_frozen
+    end
+  end # describe .new
+
+  describe "#arguments" do
+    subject { attribute.arguments }
+
+    let(:arguments) { [:foo, default: :FOO, required: true] }
+    let(:attribute) { described_class.new(*arguments) }
+
+    it "returns argumens of the initializer" do
+      expect(subject).to eql(arguments)
+    end
+  end # describe #arguments
+
+  describe "#name" do
+    subject { attribute.name }
+
+    it "is initialized" do
+      expect(subject).to eql(:foo)
+    end
+  end # describe #name
+
+  describe "#default" do
+    subject { attribute.default }
+
+    context "by default" do
+      it "returns nil" do
+        expect(subject).to be_nil
+      end
+    end # context
+
+    context "when value is set" do
+      let(:attribute) { described_class.new :foo, default: :FOO }
+
+      it "is initialized" do
+        expect(subject).to eql(:FOO)
+      end
+    end # context
+  end # describe #default
+
+  describe "#required" do
+    subject { attribute.required }
+
+    context "by default" do
+      it "returns false" do
+        expect(subject).to eql(false)
+      end
+    end # context
+
+    context "when value is set" do
+      let(:attribute) { described_class.new :foo, required: true }
+
+      it "is initialized" do
+        expect(subject).to eql(true)
+      end
+    end # context
+  end # describe #required
+
+end # describe QueryBuilder::Core::Attribute

data/spec/unit/core/base_spec.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+describe QueryBuilder::Core::Base do
+
+  let(:exception)  { QueryBuilder::Core::AttributeError }
+  let(:klass)      { Class.new(described_class) }
+  let(:instance)   { klass.new(attributes) }
+  let(:attributes) { { foo: :FOO } }
+
+  describe ".attribute" do
+    shared_examples :adding_attribute do
+      it "updates .attributes" do
+        expect { subject }
+          .to change { klass.attributes.map(&:name) }
+          .from([])
+          .to([:foo])
+      end
+
+      it "adds key to the #attributes" do
+        expect { subject }
+          .to change { klass.new.attributes }
+          .from({})
+          .to(foo: default)
+      end
+
+      it "defines the instance method" do
+        expect { subject }
+          .to change { klass.instance_methods }
+          .by [:foo]
+      end
+
+      it "makes the method to return the attribute" do
+        subject
+        expect(klass.new.foo).to eql(default)
+        expect(klass.new(foo: :FOO).foo).to eql(:FOO)
+      end
+    end # shared examples
+
+    it_behaves_like :adding_attribute do
+      subject { klass.attribute :foo }
+      let(:default) { nil }
+    end
+
+    it_behaves_like :adding_attribute do
+      subject { klass.attribute :foo, default: default }
+      let(:default) { :Foo }
+    end
+  end # describe .attributes
+
+  describe ".inherited" do
+    subject { Class.new(klass).attributes.map(&:name) }
+
+    let(:klass) do
+      Class.new(described_class) { attribute :foo, default: :FOO }
+    end
+
+    it "inherits the default attibutes of parent class" do
+      expect(subject).to eql [:foo]
+    end
+  end # describe .inherited
+
+  describe ".new" do
+    subject { instance }
+
+    before { klass.attribute :foo, required: true }
+
+    it "is immutable" do
+      expect(subject).to be_frozen
+    end
+
+    it "doesn't freeze attributes" do
+      expect { subject }.not_to change { attributes.frozen? }
+    end
+
+    context "with unknown attribute" do
+      let(:attributes) { { foo: :FOO, bar: :BAR } }
+
+      it "raises AttributeError" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of exception
+          expect(error.message).to include "unknown "
+          expect(error.message).to include "bar"
+        end
+      end
+    end
+
+    context "with missed attribute" do
+      before { klass.attribute :bar, required: true }
+
+      it "raises AttributeError" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of exception
+          expect(error.message).to include "missed "
+          expect(error.message).to include "bar"
+        end
+      end
+    end
+  end # describe .new
+
+  describe "#to_s" do
+    subject { instance.to_s }
+
+    let(:klass) { Class.new(described_class) { attribute :foo } }
+
+    it "returns empty string" do
+      expect(subject).to eql("")
+    end
+  end # describe #to_s
+
+end # describe QueryBuilder::Core::Base