cassanity 0.1.0

data/spec/integration/cassanity/keyspace_spec.rb

@@ -0,0 +1,64 @@
+require 'helper'
+require 'cassanity/keyspace'
+require 'cassanity/executors/cassandra_cql'
+
+describe Cassanity::Keyspace do
+  let(:keyspace_name)              { 'cassanity_test' }
+  let(:self_created_keyspace_name) { 'self_created' }
+  let(:column_family_name)         { 'apps' }
+
+  let(:client) {
+    CassandraCQL::Database.new('127.0.0.1:9160', {
+      cql_version: '3.0.0',
+    })
+  }
+
+  let(:executor) {
+    Cassanity::Executors::CassandraCql.new({
+      client: client,
+    })
+  }
+
+  let(:required_arguments) {
+    {
+      name: keyspace_name,
+      executor: executor,
+    }
+  }
+
+  subject {
+    described_class.new(required_arguments)
+  }
+
+  before do
+    client_drop_keyspace(client, keyspace_name)
+    client_create_keyspace(client, keyspace_name)
+  end
+
+  after do
+    client_drop_keyspace(client, keyspace_name)
+    client_drop_keyspace(client, self_created_keyspace_name)
+  end
+
+  it "can create" do
+    client_keyspace?(client, self_created_keyspace_name).should be_false
+    instance = described_class.new(required_arguments.merge({
+      name: self_created_keyspace_name,
+    }))
+    instance.create
+    client_keyspace?(client, self_created_keyspace_name).should be_true
+  end
+
+  it "can use" do
+    client.execute("USE system")
+    client.keyspace.should_not eq(keyspace_name)
+    subject.use
+    client.keyspace.should eq(keyspace_name)
+  end
+
+  it "can drop" do
+    client_keyspace?(client, keyspace_name).should be_true
+    subject.drop
+    client_keyspace?(client, keyspace_name).should be_false
+  end
+end

data/spec/support/cassanity_helpers.rb

@@ -0,0 +1,35 @@
+module CassanityHelpers
+  def client_keyspace?(client, name)
+    client.keyspaces.map(&:name).include?(name.to_s)
+  end
+
+  def client_create_keyspace(client, name)
+    unless client_keyspace?(client, name)
+      client.execute("CREATE KEYSPACE #{name} WITH strategy_class = 'SimpleStrategy' AND strategy_options:replication_factor = 1")
+    end
+    client.execute("USE #{name}")
+  end
+
+  def client_drop_keyspace(client, name)
+    if client_keyspace?(client, name)
+      client.execute("DROP KEYSPACE #{name}")
+    end
+  end
+
+  def client_column_family?(client, name)
+    client.schema.column_family_names.include?(name.to_s)
+  end
+
+  def client_create_column_family(client, name, columns = nil)
+    columns ||= "id text PRIMARY KEY, name text"
+    unless client_column_family?(client, name)
+      client.execute("CREATE COLUMNFAMILY #{name} (#{columns})")
+    end
+  end
+
+  def client_drop_column_family(client, name)
+    if client_column_family?(client, name)
+      client.execute("DROP COLUMNFAMILY #{name}")
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/batch_spec.rb

@@ -0,0 +1,36 @@
+require 'helper'
+require 'cassanity/argument_generators/batch'
+
+describe Cassanity::ArgumentGenerators::Batch do
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "BEGIN BATCH INSERT INTO users (id) VALUES (?) UPDATE users SET name = ? WHERE id = ? DELETE FROM users WHERE id = ? APPLY BATCH"
+      subject.call({
+        modifications: [
+          [:insert, name: :users, data: {id: '1'}],
+          [:update, name: :users, set: {name: 'GitHub'}, where: {id: '1'}],
+          [:delete, name: :users, where: {id: '1'}],
+        ],
+      }).should eq([cql, '1', 'GitHub', '1', '1'])
+    end
+
+    context "with :using key" do
+      subject {
+        described_class.new({
+          using_clause: lambda { |args|
+            [" USING TIMESTAMP = #{args.fetch(:using).fetch(:timestamp)}"]
+          }
+        })
+      }
+
+      it "uses using clause to get additional cql and bound variables" do
+        cql = "BEGIN BATCH USING TIMESTAMP = 500 APPLY BATCH"
+        subject.call({
+          using: {
+            timestamp: 500,
+          },
+        }).should eq([cql])
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_alter_spec.rb

@@ -0,0 +1,85 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_alter'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyAlter do
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "ALTER COLUMNFAMILY apps"
+      expected = [cql]
+      subject.call({
+        name: :apps,
+      }).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments including keyspace name" do
+        cql = "ALTER COLUMNFAMILY foo.apps"
+        expected = [cql]
+        subject.call({
+          name: :apps,
+          keyspace_name: 'foo',
+        }).should eq(expected)
+      end
+    end
+
+    context "altering a column type" do
+      it "returns array of arguments" do
+        cql = "ALTER COLUMNFAMILY apps ALTER created_at TYPE timestamp"
+        expected = [cql]
+        subject.call({
+          name: :apps,
+          alter: {
+            created_at: :timestamp,
+          },
+        }).should eq(expected)
+      end
+    end
+
+    context "adding a column" do
+      it "returns array of arguments" do
+        cql = "ALTER COLUMNFAMILY apps ADD created_at timestamp"
+        expected = [cql]
+        subject.call({
+          name: :apps,
+          add: {
+            created_at: :timestamp,
+          },
+        }).should eq(expected)
+      end
+    end
+
+    context "dropping a column" do
+      it "returns array of arguments" do
+        cql = "ALTER COLUMNFAMILY apps DROP created_at"
+        expected = [cql]
+        subject.call({
+          name: :apps,
+          drop: :created_at,
+        }).should eq(expected)
+      end
+    end
+
+    context "altering column family WITH options" do
+      let(:with_clause) {
+        lambda { |args| [" WITH comment = ?", 'Testing']}
+      }
+
+      subject {
+        described_class.new({
+          with_clause: with_clause,
+        })
+      }
+
+      it "returns array of arguments with help from the with_clause" do
+        cql = "ALTER COLUMNFAMILY apps WITH comment = ?"
+        expected = [cql, 'Testing']
+        subject.call({
+          name: :apps,
+          with: {
+            comment: 'Testing',
+          }
+        }).should eq(expected)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_create_spec.rb

@@ -0,0 +1,107 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_create'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyCreate do
+  let(:column_family_name) { 'tracks' }
+
+  let(:schema) {
+    Cassanity::Schema.new({
+      primary_key: :id,
+      columns: {
+        id: :text,
+        name: :text
+      },
+    })
+  }
+
+  describe "#call" do
+    context "when missing required argument key" do
+      let(:required_arguments) {
+        {
+          name: 'tracks',
+          schema: schema,
+        }
+      }
+
+      [:name, :schema].each do |key|
+        it "raises error if missing :#{key} key" do
+          args = required_arguments.reject { |k, v| k == key }
+          expect { subject.call(args) }.to raise_error(KeyError)
+        end
+      end
+    end
+
+    context "when using single primary key" do
+      it "returns array of arguments" do
+        cql = "CREATE COLUMNFAMILY #{column_family_name} (id text, name text, PRIMARY KEY (id))"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          schema: schema,
+        }).should eq(expected)
+      end
+    end
+
+    context "when including :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "CREATE COLUMNFAMILY foo.#{column_family_name} (id text, name text, PRIMARY KEY (id))"
+        expected = [cql]
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name,
+          schema: schema,
+        }).should eq(expected)
+      end
+    end
+
+    context "when using composite primary key" do
+      it "returns array of arguments" do
+        schema = Cassanity::Schema.new({
+          primary_key: [:segment, :track_id],
+          columns: {
+            segment: :text,
+            track_id: :timeuuid,
+            page: :text,
+          },
+        })
+        cql = "CREATE COLUMNFAMILY #{column_family_name} (segment text, track_id timeuuid, page text, PRIMARY KEY (segment, track_id))"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          schema: schema,
+        }).should eq(expected)
+      end
+    end
+
+    context "when using WITH options" do
+      let(:with_clause) {
+        lambda { |args| [" WITH comment = ?", 'Testing']}
+      }
+
+      subject {
+        described_class.new({
+          with_clause: with_clause,
+        })
+      }
+
+      it "returns array of arguments with help from the with_clause" do
+        schema = Cassanity::Schema.new({
+          primary_key: :id,
+          columns: {
+            id: :text,
+            name: :text,
+          },
+          with: {
+            comment: "Testing",
+          }
+        })
+        cql = "CREATE COLUMNFAMILY apps (id text, name text, PRIMARY KEY (id)) WITH comment = ?"
+        expected = [cql, 'Testing']
+        subject.call({
+          name: :apps,
+          schema: schema,
+        }).should eq(expected)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_delete_spec.rb

@@ -0,0 +1,92 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_delete'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyDelete do
+  let(:column_family_name) { 'apps' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "DELETE FROM #{column_family_name} WHERE id = ?"
+      expected = [cql, '1']
+      subject.call({
+        name: column_family_name,
+        where: {
+          id: '1',
+        }
+      }).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "DELETE FROM foo.#{column_family_name} WHERE id = ?"
+        expected = [cql, '1']
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name,
+          where: {
+            id: '1',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with specific columns" do
+      it "returns array of arguments only deleting specific columns" do
+        cql = "DELETE foo, bar FROM #{column_family_name} WHERE id = ?"
+        expected = [cql, '1']
+        subject.call({
+          name: column_family_name,
+          columns: [:foo, :bar],
+          where: {
+            id: '1',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with :where key" do
+      subject {
+        described_class.new({
+          where_clause: lambda { |args|
+            [" WHERE id = ?", args.fetch(:where).fetch(:id)]
+          }
+        })
+      }
+
+      it "uses where clause to get additional cql and bound variables" do
+        cql = "DELETE FROM #{column_family_name} WHERE id = ?"
+        expected = [cql, '4']
+        subject.call({
+          name: column_family_name,
+          where: {
+            id: '4',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with :using key" do
+      subject {
+        described_class.new({
+          using_clause: lambda { |args|
+            [" USING TTL = #{args.fetch(:using).fetch(:ttl)}"]
+          }
+        })
+      }
+
+      it "uses using clause to get additional cql and bound variables" do
+        cql = "DELETE FROM #{column_family_name} USING TTL = 500 WHERE id = ?"
+        expected = [cql, '4']
+        subject.call({
+          name: column_family_name,
+          using: {
+            ttl: 500,
+          },
+          where: {
+            id: '4',
+          }
+        }).should eq(expected)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_drop_spec.rb

@@ -0,0 +1,25 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_drop'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyDrop do
+  let(:column_family_name) { 'apps' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "DROP COLUMNFAMILY #{column_family_name}"
+      expected = [cql]
+      subject.call(name: column_family_name).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "DROP COLUMNFAMILY foo.#{column_family_name}"
+        expected = [cql]
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name
+        }).should eq(expected)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_insert_spec.rb

@@ -0,0 +1,70 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_insert'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyInsert do
+  let(:column_family_name) { 'apps' }
+
+  describe "#call" do
+    [:name, :data].each do |key|
+      it "raises error if missing :#{key} key" do
+        required_arguments = {
+          name: column_family_name,
+          data: {
+            id: '1',
+            name: 'GitHub',
+          }
+        }
+
+        args = required_arguments.reject { |k, v| k == key }
+        expect { subject.call(args) }.to raise_error(KeyError)
+      end
+    end
+
+    it "returns array of arguments" do
+      cql = "INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)"
+      expected = [cql, '1', 'GitHub']
+      subject.call({
+        name: column_family_name,
+        data: {
+          id: '1',
+          name: 'GitHub',
+        }
+      }).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "INSERT INTO foo.#{column_family_name} (id, name) VALUES (?, ?)"
+        expected = [cql, '1', 'GitHub']
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name,
+          data: {
+            id: '1',
+            name: 'GitHub',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with :using key" do
+      it "returns array of arguments including using in cql string" do
+        millis = (Time.mktime(2012, 11, 1, 14, 9, 9).to_f * 1000).to_i
+        cql = "INSERT INTO #{column_family_name} (id, name) VALUES (?, ?) USING TTL 86400 AND TIMESTAMP #{millis} AND CONSISTENCY quorum"
+        expected = [cql, '1', 'GitHub']
+        subject.call({
+          name: column_family_name,
+          data: {
+            id: '1',
+            name: 'GitHub',
+          },
+          using: {
+            ttl: 86400,
+            timestamp: millis,
+            consistency: 'quorum',
+          }
+        }).should eq(expected)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_select_spec.rb

@@ -0,0 +1,113 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_select'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilySelect do
+  let(:column_family_name) { 'apps' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "SELECT * FROM #{column_family_name}"
+      expected = [cql]
+      subject.call(name: column_family_name).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "SELECT * FROM foo.#{column_family_name}"
+        expected = [cql]
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name
+        }).should eq(expected)
+      end
+    end
+
+    context "with single column" do
+      it "returns array of arguments querying only one column" do
+        cql = "SELECT name FROM #{column_family_name}"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          select: :name,
+        }).should eq(expected)
+      end
+    end
+
+    context "with multiple columns" do
+      it "returns array of arguments querying multiple columns" do
+        cql = "SELECT id, name, created_at FROM #{column_family_name}"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          select: [:id, :name, :created_at],
+        }).should eq(expected)
+      end
+    end
+
+    context "with count *" do
+      it "returns array of arguments querying multiple columns" do
+        cql = "SELECT COUNT(*) FROM #{column_family_name}"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          select: 'COUNT(*)',
+        }).should eq(expected)
+      end
+    end
+
+    context "with count 1" do
+      it "returns array of arguments querying multiple columns" do
+        cql = "SELECT COUNT(1) FROM #{column_family_name}"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          select: 'COUNT(1)',
+        }).should eq(expected)
+      end
+    end
+
+    context "with WRITETIME" do
+      it "returns array of arguments querying multiple columns" do
+        cql = "SELECT WRITETIME(name) FROM #{column_family_name}"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          select: 'WRITETIME(name)',
+        }).should eq(expected)
+      end
+    end
+
+    context "with TTL" do
+      it "returns array of arguments querying multiple columns" do
+        cql = "SELECT TTL(name) FROM #{column_family_name}"
+        expected = [cql]
+        subject.call({
+          name: column_family_name,
+          select: 'TTL(name)',
+        }).should eq(expected)
+      end
+    end
+
+    context "with where option" do
+      let(:where_clause) {
+        lambda { |args| [" WHERE foo = ?", args.fetch(:where).fetch(:foo)]}
+      }
+
+      subject {
+        described_class.new({
+          where_clause: where_clause,
+        })
+      }
+
+      it "returns array of arguments with help from where clause" do
+        where = {foo: 'bar'}
+        cql = "SELECT * FROM #{column_family_name} WHERE foo = ?"
+        expected = [cql, 'bar']
+        subject.call({
+          name: column_family_name,
+          where: where,
+        }).should eq(expected)
+      end
+    end
+  end
+end

data/spec/unit/cassanity/argument_generators/column_family_truncate_spec.rb

@@ -0,0 +1,25 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_truncate'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyTruncate do
+  let(:column_family_name) { 'apps' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "TRUNCATE #{column_family_name}"
+      expected = [cql]
+      subject.call(name: column_family_name).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "TRUNCATE foo.#{column_family_name}"
+        expected = [cql]
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name
+        }).should eq(expected)
+      end
+    end
+  end
+end