cassanity 0.1.0

data/spec/unit/cassanity/column_family_spec.rb

@@ -0,0 +1,250 @@
+require 'helper'
+require 'cassanity/column_family'
+
+describe Cassanity::ColumnFamily do
+  let(:column_family_name) { 'analytics' }
+  let(:keyspace_name) { 'foo' }
+
+  let(:keyspace) {
+    double('Keyspace', {
+      executor: executor,
+      name: keyspace_name,
+    })
+  }
+
+  let(:executor) {
+    lambda { |args| ['GOTTA KEEP EM EXECUTED', args] }
+  }
+
+  let(:schema) { double('Schema') }
+
+  let(:required_arguments) {
+    {
+      name: column_family_name,
+      keyspace: keyspace,
+    }
+  }
+
+  subject { described_class.new(required_arguments) }
+
+  it { should respond_to(:name) }
+  it { should respond_to(:keyspace) }
+
+  describe "#initialize" do
+    it "sets name" do
+      subject.name.should eq(column_family_name)
+    end
+
+    it "sets keyspace" do
+      subject.keyspace.should eq(keyspace)
+    end
+
+    it "defaults executor to keyspace's executor" do
+      subject.executor.should eq(keyspace.executor)
+    end
+
+    it "sets schema if provided" do
+      instance = described_class.new(required_arguments.merge({
+        schema: schema,
+      }))
+      instance.schema.should eq(schema)
+    end
+
+    it "allows overriding executor" do
+      other_executor = lambda { |args| }
+      column_family = described_class.new(required_arguments.merge({
+        executor: other_executor,
+      }))
+      column_family.executor.should eq(other_executor)
+    end
+
+    [:name, :keyspace].each do |key|
+      it "raises error without :#{key} key" do
+        args = required_arguments.reject { |k, v| k == key }
+        expect { described_class.new(args) }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe "#schema" do
+    it "returns schema if set" do
+      described_class.new(required_arguments.merge({
+        schema: schema,
+      })).schema.should eq(schema)
+    end
+
+    it "raises error if not set" do
+      expect {
+        subject.schema
+      }.to raise_error(Cassanity::Error, "No schema found to create #{column_family_name} column family. Please set :schema during initialization or include it as a key in #create call.")
+    end
+  end
+
+  describe "#create" do
+    context "with schema set during initialization" do
+      subject {
+        described_class.new(required_arguments.merge({
+          schema: schema,
+        }))
+      }
+
+      it "sends command and arguments, including schema, to executor" do
+        args = {something: 'else'}
+        executor.should_receive(:call).with({
+          command: :column_family_create,
+          arguments: args.merge({
+            name: column_family_name,
+            keyspace_name: keyspace_name,
+            schema: schema,
+          }),
+        })
+        subject.create(args)
+      end
+
+      it "uses passed in :schema if present" do
+        schema_argument = double('Schema')
+        args = {schema: schema_argument}
+        executor.should_receive(:call).with({
+          command: :column_family_create,
+          arguments: args.merge({
+            name: column_family_name,
+            keyspace_name: keyspace_name,
+            schema: schema_argument,
+          }),
+        })
+        subject.create(args)
+      end
+    end
+
+    context "with no schema" do
+      it "raises error" do
+        expect {
+          subject.create
+        }.to raise_error(Cassanity::Error, "No schema found to create #{column_family_name} column family. Please set :schema during initialization or include it as a key in #create call.")
+      end
+
+      it "sends passed in schema if present" do
+        args = {schema: schema}
+        command_arguments = args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+          schema: schema,
+        })
+        executor.should_receive(:call).with({
+          command: :column_family_create,
+          arguments: command_arguments,
+        })
+        subject.create(args)
+      end
+    end
+  end
+
+  describe "#truncate" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else'}
+      executor.should_receive(:call).with({
+        command: :column_family_truncate,
+        arguments: args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.truncate(args)
+    end
+  end
+
+  describe "#drop" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else'}
+      executor.should_receive(:call).with({
+        command: :column_family_drop,
+        arguments: args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.drop(args)
+    end
+  end
+
+  describe "#alter" do
+    it "sends command and arguments, including :name and :keyspace_name, to executor" do
+      args = {drop: :name, something: 'else'}
+      executor.should_receive(:call).with({
+        command: :column_family_alter,
+        arguments: args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.alter(args)
+    end
+  end
+
+  describe "#create_index" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else'}
+      executor.should_receive(:call).with({
+        command: :index_create,
+        arguments: args.merge({
+          column_family_name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.create_index(args)
+    end
+  end
+
+  describe "#drop_index" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else', name: 'users_state_idx'}
+      executor.should_receive(:call).with({
+        command: :index_drop,
+        arguments: args,
+      })
+      subject.drop_index(args)
+    end
+  end
+
+  describe "#insert" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {data: {id: '1', name: 'GitHub'}}
+      executor.should_receive(:call).with({
+        command: :column_family_insert,
+        arguments: args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.insert(args)
+    end
+  end
+
+  describe "#update" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {set: {name: 'GitHub'}, where: {id: '1'}}
+      executor.should_receive(:call).with({
+        command: :column_family_update,
+        arguments: args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.update(args)
+    end
+  end
+
+  describe "#delete" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {where: {id: '1'}}
+      executor.should_receive(:call).with({
+        command: :column_family_delete,
+        arguments: args.merge({
+          name: column_family_name,
+          keyspace_name: keyspace_name,
+        }),
+      })
+      subject.delete(args)
+    end
+  end
+end

data/spec/unit/cassanity/connection_spec.rb

@@ -0,0 +1,75 @@
+require 'helper'
+require 'cassanity/connection'
+
+describe Cassanity::Connection do
+  let(:keyspace_name) { 'analytics' }
+  let(:executor) {
+    double('Executor', {
+      call: nil,
+    })
+  }
+
+  let(:required_arguments) {
+    {
+      executor: executor,
+    }
+  }
+
+  subject { described_class.new(required_arguments) }
+
+  it { should respond_to(:executor) }
+
+  [:executor].each do |key|
+    it "raises error if initialized without :#{key} key" do
+      args = required_arguments.reject { |k, v| k == key }
+      expect { described_class.new(args) }.to raise_error(KeyError)
+    end
+  end
+
+  describe "#batch" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {modifications: [[:insert, data: {id: '1', name: 'GitHub'}]]}
+      executor.should_receive(:call).with({
+        command: :batch,
+        arguments: args,
+      })
+      subject.batch(args)
+    end
+  end
+
+  describe "#keyspace" do
+    before do
+      @return_value = subject.keyspace(keyspace_name)
+    end
+
+    it "returns instance of keyspace" do
+      @return_value.should be_instance_of(Cassanity::Keyspace)
+    end
+
+    context "with args" do
+      before do
+        @return_value = subject.keyspace(keyspace_name, {
+          strategy_class: 'NetworkTopologyStrategy',
+        })
+      end
+
+      it "passes args to initialization" do
+        @return_value.strategy_class.should eq('NetworkTopologyStrategy')
+      end
+
+      it "returns instance of keyspace" do
+        @return_value.should be_instance_of(Cassanity::Keyspace)
+      end
+    end
+  end
+
+  describe "#[]" do
+    before do
+      @return_value = subject[keyspace_name]
+    end
+
+    it "returns instance of keyspace" do
+      @return_value.should be_instance_of(Cassanity::Keyspace)
+    end
+  end
+end

data/spec/unit/cassanity/error_spec.rb

@@ -0,0 +1,35 @@
+require 'helper'
+require 'cassanity/error'
+
+describe Cassanity::Error do
+  HorribleBadThing = Class.new(Exception)
+
+  it "can wrap original error" do
+    original = HorribleBadThing.new
+    error = described_class.new(original: original)
+    error.original.should eq(original)
+  end
+
+  it "defaults original to last raised exception" do
+    begin
+      begin
+        raise HorribleBadThing, 'Yep, really bad'
+      rescue Exception => e
+        raise described_class
+      end
+    rescue described_class => e
+      e.original.should be_instance_of(HorribleBadThing)
+      e.message.should eq("Original Exception: HorribleBadThing: Yep, really bad")
+    end
+  end
+
+  it "does not require original error" do
+    error = described_class.new(:message => 'Is this thing on?')
+    error.message.should eq('Is this thing on?')
+  end
+
+  it "does not require any arguments" do
+    error = described_class.new
+    error.message.should eq("Something truly horrible went wrong")
+  end
+end

data/spec/unit/cassanity/executors/cassandra_cql_spec.rb

@@ -0,0 +1,178 @@
+require 'helper'
+require 'cassanity/executors/cassandra_cql'
+
+describe Cassanity::Executors::CassandraCql do
+  let(:client) { double('Client', :execute => nil) }
+
+  let(:required_arguments) {
+    {
+      client: client,
+    }
+  }
+
+  let(:argument_generators) {
+    {
+      :foo => lambda { |args| ['mapped', args] },
+    }
+  }
+
+  let(:result_transformers) {
+    {
+      :foo => lambda { |args| ['transformed', args] }
+    }
+  }
+
+  subject { described_class.new(required_arguments) }
+
+  describe "#initialize" do
+    [:client].each do |key|
+      it "raises error without :#{key} key" do
+        args = required_arguments.reject { |k, v| k == key }
+        expect { described_class.new(args) }.to raise_error(KeyError)
+      end
+    end
+
+    it "sets client" do
+      subject.client.should eq(client)
+    end
+
+    it "defaults :argument_generators" do
+      subject.argument_generators.should eq(described_class::ArgumentGenerators)
+    end
+
+    it "defaults :result_transformers" do
+      subject.result_transformers.should eq(described_class::ResultTransformers)
+    end
+
+    it "allows overriding :argument_generators" do
+      instance = described_class.new(required_arguments.merge({
+        argument_generators: argument_generators
+      }))
+
+      instance.argument_generators.should eq(argument_generators)
+    end
+
+    it "allows overriding :result_transformers" do
+      instance = described_class.new(required_arguments.merge({
+        result_transformers: result_transformers
+      }))
+
+      instance.result_transformers.should eq(result_transformers)
+    end
+  end
+
+  KnownCommands = [
+    :keyspaces,
+    :keyspace_create,
+    :keyspace_drop,
+    :keyspace_use,
+    :column_family_create,
+    :column_family_drop,
+    :column_family_truncate,
+    :column_family_select,
+    :column_family_insert,
+    :column_family_update,
+    :column_family_delete,
+    :column_family_alter,
+    :index_create,
+    :index_drop,
+    :batch,
+  ]
+
+  KnownCommands.each do |key|
+    it "responds to #{key} command by default" do
+      subject.argument_generators.should have_key(key)
+    end
+  end
+
+  describe "#call" do
+    subject {
+      described_class.new(required_arguments.merge({
+        argument_generators: argument_generators,
+      }))
+    }
+
+    context "for known command" do
+      it "generates arguments based on command to argument map and passes generated arguments client execute method" do
+        args = {
+          command: :foo,
+          arguments: {
+            something: 'else',
+          },
+        }
+
+        client.should_receive(:execute).with('mapped', args[:arguments])
+        subject.call(args)
+      end
+
+      context "with result transformer" do
+        subject {
+          described_class.new(required_arguments.merge({
+            argument_generators: argument_generators,
+            result_transformers: result_transformers,
+          }))
+        }
+
+        it "returns result transformed" do
+          result = double('Result')
+          client.stub(:execute => result)
+          tranformer = result_transformers[:foo]
+
+          args = {
+            command: :foo,
+            arguments: {
+              something: 'else',
+            },
+          }
+
+          subject.call(args).should eq(['transformed', result])
+        end
+      end
+
+      context "without result transformer" do
+        subject {
+          described_class.new(required_arguments.merge({
+            argument_generators: argument_generators,
+            result_transformers: {},
+          }))
+        }
+
+        it "returns result transformed" do
+          result = double('Result')
+          client.stub(:execute => result)
+          tranformer = result_transformers[:foo]
+
+          args = {
+            command: :foo,
+            arguments: {
+              something: 'else',
+            },
+          }
+
+          subject.call(args).should eq(result)
+        end
+      end
+    end
+
+    context "for unknown command" do
+      it "generates arguments based on command to argument map and passes generated arguments client execute method" do
+        expect {
+          subject.call({
+            command: :surprise,
+          })
+        }.to raise_error(Cassanity::UnknownCommand, 'Original Exception: KeyError: key not found: :surprise')
+      end
+    end
+
+    context "when client raises exception" do
+      it "raises Cassanity::Error" do
+        client.should_receive(:execute).and_raise(Exception.new)
+        expect {
+          subject.call({
+            command: :foo,
+          })
+        }.to raise_error(Cassanity::Error, /Exception: Exception/)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/keyspace_spec.rb

@@ -0,0 +1,137 @@
+require 'helper'
+require 'cassanity/keyspace'
+
+describe Cassanity::Keyspace do
+  let(:keyspace_name) { 'analytics' }
+
+  let(:executor) {
+    lambda { |args| ['GOTTA KEEP EM EXECUTED', args] }
+  }
+
+  let(:required_arguments) {
+    {
+      name: keyspace_name,
+      executor: executor,
+    }
+  }
+
+  subject { described_class.new(required_arguments) }
+
+  it { should respond_to(:name) }
+  it { should respond_to(:executor) }
+
+  describe "#initialize" do
+    it "sets name" do
+      subject.name.should eq(keyspace_name)
+    end
+
+    it "sets executor" do
+      subject.executor.should eq(executor)
+    end
+
+    [:name, :executor].each do |key|
+      it "raises error without :#{key} key" do
+        args = required_arguments.reject { |k, v| k == key }
+        expect { described_class.new(args) }.to raise_error(KeyError)
+      end
+    end
+
+    it "sets strategy_class if provided" do
+      instance = described_class.new(required_arguments.merge({
+        strategy_class: 'NetworkTopologyStrategy',
+      }))
+
+      instance.strategy_class.should eq('NetworkTopologyStrategy')
+    end
+
+    it "sets strategy_options if provided" do
+      instance = described_class.new(required_arguments.merge({
+        strategy_options: {
+          dc1: 3,
+          dc2: 5,
+        },
+      }))
+
+      instance.strategy_options.should eq({
+        dc1: 3,
+        dc2: 5,
+      })
+    end
+  end
+
+  describe "#column_family" do
+    let(:column_family_name) { 'apps' }
+
+    before do
+      @return_value = subject.column_family(column_family_name)
+    end
+
+    it "returns instance of column family" do
+      @return_value.should be_instance_of(Cassanity::ColumnFamily)
+    end
+
+    context "with args" do
+      let(:schema) { double('Schema') }
+
+      before do
+        @return_value = subject.column_family(column_family_name, {
+          schema: schema,
+        })
+      end
+
+      it "passes args to initialization" do
+        @return_value.schema.should eq(schema)
+      end
+
+      it "returns instance of column family" do
+        @return_value.should be_instance_of(Cassanity::ColumnFamily)
+      end
+    end
+  end
+
+  describe "#table" do
+    let(:column_family_name) { 'apps' }
+
+    before do
+      @return_value = subject.table(column_family_name)
+    end
+
+    it "returns instance of column family" do
+      @return_value.should be_instance_of(Cassanity::ColumnFamily)
+    end
+  end
+
+  describe "#[]" do
+    let(:column_family_name) { 'apps' }
+
+    before do
+      @return_value = subject[column_family_name]
+    end
+
+    it "returns instance of column family" do
+      @return_value.should be_instance_of(Cassanity::ColumnFamily)
+    end
+  end
+
+  describe "#use" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else'}
+      executor.should_receive(:call).with({
+        command: :keyspace_use,
+        arguments: args.merge(name: keyspace_name),
+      })
+      subject.use(args)
+    end
+  end
+
+  describe "#drop" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else'}
+      executor.should_receive(:call).with({
+        command: :keyspace_drop,
+        arguments: args.merge(name: keyspace_name),
+      })
+      subject.drop(args)
+    end
+  end
+end

data/spec/unit/cassanity/result_transformers/mirror_spec.rb

@@ -0,0 +1,12 @@
+require 'helper'
+require 'cassanity/result_transformers/mirror'
+
+describe Cassanity::ResultTransformers::Mirror do
+  describe "#call" do
+    it "returns whatever is passed it" do
+      [1, '2', ['something'], {something: 'else'}].each do |result|
+        subject.call(result).should be(result)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/schema_spec.rb

@@ -0,0 +1,23 @@
+require 'helper'
+require 'cassanity/schema'
+
+describe Cassanity::Schema do
+  let(:required_arguments) {
+    {
+      primary_key: :id,
+      columns: {
+        id: :text,
+        name: :text,
+      }
+    }
+  }
+
+  describe "#initialize" do
+    [:primary_key, :columns].each do |key|
+      it "raises error without :#{key} key" do
+        args = required_arguments.reject { |k, v| k == key }
+        expect { described_class.new(args) }.to raise_error(KeyError)
+      end
+    end
+  end
+end