rom-cassandra 0.0.1

data/spec/shared/users.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+shared_examples :users do
+
+  let(:setup)   { ROM.setup(:cassandra, hosts: ["127.0.0.1"], port: 9042) }
+  let(:gateway) { setup[:default] }
+  let(:rom)     { setup.finalize }
+  let(:select)  { rom.relation(:users) }
+
+  before do
+    setup.relation(:users) do
+      dataset "auth.users"
+
+      def by_id(id)
+        where(id: id)
+      end
+    end
+  end
+
+end # shared examples

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# 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 "rom-cassandra"
+
+# Configures RSpec
+require "config/reset_cluster"
+require "config/rom"
+require "config/test_module"

data/spec/unit/commands/batch_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Commands::Batch do
+
+  let(:command)  { described_class.new relation }
+  let(:relation) { double :relation, batch_query: batch }
+  let(:batch)    { double :batch, foo: :updated_relation }
+
+  describe ".new" do
+    subject { command }
+
+    it { is_expected.to be_kind_of ROM::Command }
+  end # describe .new
+
+  describe "#relation" do
+    subject { command.relation }
+
+    it "restricts dataset by UPDATE statements" do
+      expect(subject).to eql batch
+    end
+  end # describe #relation
+
+  describe "#method_missing" do
+    subject { command.foo :bar }
+
+    it "returns a command" do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it "updates the relation" do
+      expect(batch).to receive(:foo).with(:bar)
+      expect(subject.relation).to eql :updated_relation
+    end
+  end # describe #method_missing
+
+  describe "#respond_to_missing?" do
+    subject { command.respond_to? name }
+
+    context "method of #relation" do
+      let(:name) { :foo }
+
+      it { is_expected.to eql true }
+    end
+
+    context "method not defined for #relation" do
+      let(:name) { :bar }
+
+      it { is_expected.to eql false }
+    end
+  end # describe #respond_to_missing?
+
+  describe "#execute" do
+    let(:updated) { double :updated, to_a: result }
+    let(:result)  { double :result }
+
+    context "without a block" do
+      subject { command.execute(1) }
+
+      it "applies #to_a" do
+        allow(command).to receive(:to_a) { result }
+
+        expect(subject).to eql(result)
+      end
+    end
+
+    context "with a block" do
+      subject { command.execute { foo } }
+
+      it "updates and finalizes the command" do
+        allow(command).to receive(:foo) { updated }
+
+        expect(subject).to eql(result)
+      end
+    end
+  end # describe #execute
+
+  describe "#keyspace" do
+    subject { command.keyspace(:foo) }
+
+    it "returns query" do
+      expect(subject).to be_kind_of ROM::Cassandra::Query
+      expect(subject.use.to_s).to eql "USE foo;"
+    end
+  end # describe #keyspace
+
+end # describe ROM::Cassandra::Commands::Batch

data/spec/unit/commands/create_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Commands::Create do
+
+  let(:command)  { described_class.new relation }
+  let(:relation) { double :relation, insert_query: insert }
+  let(:insert)   { double :insert, foo: :updated_relation }
+
+  describe ".new" do
+    subject { command }
+
+    it { is_expected.to be_kind_of ROM::Commands::Create }
+  end # describe .new
+
+  describe "#relation" do
+    subject { command.relation }
+
+    it "restricts dataset by INSERT statements" do
+      expect(subject).to eql insert
+    end
+  end # describe #relation
+
+  describe "#method_missing" do
+    subject { command.foo :bar }
+
+    it "returns a command" do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it "updates the relation" do
+      expect(insert).to receive(:foo).with(:bar)
+      expect(subject.relation).to eql :updated_relation
+    end
+  end # describe #method_missing
+
+  describe "#respond_to_missing?" do
+    subject { command.respond_to? name }
+
+    context "method of #relation" do
+      let(:name) { :foo }
+
+      it { is_expected.to eql true }
+    end
+
+    context "method not defined for #relation" do
+      let(:name) { :bar }
+
+      it { is_expected.to eql false }
+    end
+  end # describe #respond_to_missing?
+
+  describe "#execute" do
+    let(:updated) { double :updated, to_a: result }
+    let(:result)  { double :result }
+
+    context "without a block" do
+      subject { command.execute(1) }
+
+      it "applies #to_a" do
+        allow(command).to receive(:to_a) { result }
+
+        expect(subject).to eql(result)
+      end
+    end
+
+    context "with a block" do
+      subject { command.execute { foo } }
+
+      it "updates and finalizes the command" do
+        allow(command).to receive(:foo) { updated }
+
+        expect(subject).to eql(result)
+      end
+    end
+  end # describe #execute
+
+end # describe ROM::Cassandra::Commands::Create

data/spec/unit/commands/delete_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Commands::Delete do
+
+  let(:command)  { described_class.new relation }
+  let(:relation) { double :relation, delete_query: delete }
+  let(:delete)   { double :delete, foo: :updated_relation }
+
+  describe ".new" do
+    subject { command }
+
+    it { is_expected.to be_kind_of ROM::Commands::Delete }
+  end # describe .new
+
+  describe "#relation" do
+    subject { command.relation }
+
+    it "restricts dataset by DELETE statements" do
+      expect(subject).to eql delete
+    end
+  end # describe #relation
+
+  describe "#method_missing" do
+    subject { command.foo :bar }
+
+    it "returns a command" do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it "updates the relation" do
+      expect(delete).to receive(:foo).with(:bar)
+      expect(subject.relation).to eql :updated_relation
+    end
+  end # describe #method_missing
+
+  describe "#respond_to_missing?" do
+    subject { command.respond_to? name }
+
+    context "method of #relation" do
+      let(:name) { :foo }
+
+      it { is_expected.to eql true }
+    end
+
+    context "method not defined for #relation" do
+      let(:name) { :bar }
+
+      it { is_expected.to eql false }
+    end
+  end # describe #respond_to_missing?
+
+  describe "#execute" do
+    let(:updated) { double :updated, to_a: result }
+    let(:result)  { double :result }
+
+    context "without a block" do
+      subject { command.execute(1) }
+
+      it "applies #to_a" do
+        allow(command).to receive(:to_a) { result }
+
+        expect(subject).to eql(result)
+      end
+    end
+
+    context "with a block" do
+      subject { command.execute { foo } }
+
+      it "updates and finalizes the command" do
+        allow(command).to receive(:foo) { updated }
+
+        expect(subject).to eql(result)
+      end
+    end
+  end # describe #execute
+
+end # describe ROM::Cassandra::Commands::Delete

data/spec/unit/commands/update_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Commands::Update do
+
+  let(:command)  { described_class.new relation }
+  let(:relation) { double :relation, update_query: update }
+  let(:update)   { double :update, foo: :updated_relation }
+
+  describe ".new" do
+    subject { command }
+
+    it { is_expected.to be_kind_of ROM::Commands::Update }
+  end # describe .new
+
+  describe "#relation" do
+    subject { command.relation }
+
+    it "restricts dataset by UPDATE statements" do
+      expect(subject).to eql update
+    end
+  end # describe #relation
+
+  describe "#method_missing" do
+    subject { command.foo :bar }
+
+    it "returns a command" do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it "updates the relation" do
+      expect(update).to receive(:foo).with(:bar)
+      expect(subject.relation).to eql :updated_relation
+    end
+  end # describe #method_missing
+
+  describe "#respond_to_missing?" do
+    subject { command.respond_to? name }
+
+    context "method of #relation" do
+      let(:name) { :foo }
+
+      it { is_expected.to eql true }
+    end
+
+    context "method not defined for #relation" do
+      let(:name) { :bar }
+
+      it { is_expected.to eql false }
+    end
+  end # describe #respond_to_missing?
+
+  describe "#execute" do
+    let(:updated) { double :updated, to_a: result }
+    let(:result)  { double :result }
+
+    context "without a block" do
+      subject { command.execute(1) }
+
+      it "applies #to_a" do
+        allow(command).to receive(:to_a) { result }
+
+        expect(subject).to eql(result)
+      end
+    end
+
+    context "with a block" do
+      subject { command.execute { foo } }
+
+      it "updates and finalizes the command" do
+        allow(command).to receive(:foo) { updated }
+
+        expect(subject).to eql(result)
+      end
+    end
+  end # describe #execute
+
+end # describe ROM::Cassandra::Commands::Update

data/spec/unit/dataset_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+describe ROM::Cassandra::Dataset do
+
+  let(:dataset)  { described_class.new(session, keyspace, table, query) }
+
+  let(:session)  { double :session }
+  let(:keyspace) { "foo" }
+  let(:table)    { "bar" }
+  let(:query)    { double :query }
+
+  describe "#session" do
+    subject { dataset.session }
+
+    it { is_expected.to eql session }
+  end # describe #session
+
+  describe "#keyspace" do
+    subject { dataset.keyspace }
+
+    it { is_expected.to eql :foo }
+  end # describe #keyspace
+
+  describe "#table" do
+    subject { dataset.table }
+
+    it { is_expected.to eql :bar }
+  end # describe #table
+
+  describe "#query" do
+    subject { dataset.query }
+
+    context "when it is set" do
+      it { is_expected.to eql query }
+    end
+
+    context "when it isn't set" do
+      let(:dataset)  { described_class.new(session, keyspace, table) }
+
+      it "returns the context of table" do
+        expect(subject.select.to_s).to eql "SELECT * FROM foo.bar;"
+      end
+    end
+  end # describe #query
+
+  describe "#get" do
+    subject { dataset.get(:bar, :baz) }
+
+    let(:select) { double :select }
+    before { allow(query).to receive(:select).and_return(select) }
+
+    it "forwards calls to the #query" do
+      expect(query).to receive(:select).with(:bar, :baz)
+      subject
+    end
+
+    it "returns the dataset with updated query" do
+      expect(subject)
+        .to eql described_class.new(session, keyspace, table, select)
+    end
+  end # describe #get
+
+  describe "#batch" do
+    subject { dataset.batch }
+
+    let(:batch)   { double :batch }
+    let(:builder) { double :builder, batch: batch }
+    before { allow(ROM::Cassandra::Query).to receive(:new) { builder } }
+
+    it "returns the dataset with updated query" do
+      expect(subject)
+        .to eql described_class.new(session, nil, nil, batch)
+    end
+  end # describe #batch
+
+  describe "#each" do
+    let(:result) { [:foo, :bar] }
+    before { allow(session).to receive(:call) { result } }
+
+    context "with a block" do
+      subject { dataset.map { |item| item } }
+
+      it "sends #query to #session and iterates through the result" do
+        expect(session).to receive(:call).with(query)
+        expect(subject).to eql result
+      end
+    end
+
+    context "without a block" do
+      subject { dataset.each }
+
+      it "sends #query to #session and returns #result's enumerator" do
+        expect(subject).to be_kind_of Enumerator
+        expect(subject.to_a).to eql result
+      end
+    end
+  end # describe #each
+
+  describe "#respond_to?" do
+    subject { dataset.respond_to? :foo }
+
+    context "method defined for #query" do
+      before { allow(query).to receive(:foo) }
+
+      it { is_expected.to eql true }
+    end
+
+    context "method missing for #query" do
+      it { is_expected.to eql false }
+    end
+  end # describe #respond_to?
+
+  describe "#method_missing" do
+    subject { dataset.foo(:bar) }
+
+    let(:updated_query) { double :updated_query }
+    before { allow(query).to receive(:foo) { updated_query } }
+
+    it "forwards calls to the #query" do
+      expect(query).to receive(:foo).with(:bar)
+      subject
+    end
+
+    it "returns the dataset with updated query" do
+      expect(subject)
+        .to eql described_class.new(session, keyspace, table, updated_query)
+    end
+  end # describe #method_missing
+
+end # describe ROM::Cassandra::Dataset