cassanity 0.1.0

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

@@ -0,0 +1,109 @@
+require 'helper'
+require 'cassanity/argument_generators/column_family_update'
+
+describe Cassanity::ArgumentGenerators::ColumnFamilyUpdate do
+  let(:column_family_name) { 'apps' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "UPDATE #{column_family_name} SET name = ? WHERE id = ?"
+      expected = [cql, 'New Name', '1']
+      subject.call({
+        name: column_family_name,
+        set: {
+          name: 'New Name',
+        },
+        where: {
+          id: '1',
+        }
+      }).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "UPDATE foo.#{column_family_name} SET name = ? WHERE id = ?"
+        expected = [cql, 'New Name', '1']
+        subject.call({
+          keyspace_name: :foo,
+          name: column_family_name,
+          set: {
+            name: 'New Name',
+          },
+          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 = "UPDATE #{column_family_name} SET name = ? WHERE id = ?"
+        expected = [cql, 'New Name', '4']
+        subject.call({
+          name: column_family_name,
+          set: {
+            name: 'New Name',
+          },
+          where: {
+            id: '4',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with :set key" do
+      subject {
+        described_class.new({
+          set_clause: lambda { |args|
+            [" SET name = ?", args.fetch(:set).fetch(:name)]
+          }
+        })
+      }
+
+      it "uses set clause to get additional cql and bound variables" do
+        cql = "UPDATE #{column_family_name} SET name = ? WHERE id = ?"
+        expected = [cql, 'New Name', '4']
+        subject.call({
+          name: column_family_name,
+          set: {
+            name: 'New Name',
+          },
+          where: {
+            id: '4',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with :using key" do
+      it "returns array of arguments with cql including using" do
+        millis = (Time.mktime(2012, 11, 1, 14, 9, 9).to_f * 1000).to_i
+        cql = "UPDATE #{column_family_name} USING TTL 86400 AND TIMESTAMP #{millis} AND CONSISTENCY quorum SET name = ? WHERE id = ?"
+        expected = [cql, 'New Name', '1']
+        subject.call({
+          name: column_family_name,
+          using: {
+            ttl: 86400,
+            timestamp: millis,
+            consistency: 'quorum',
+          },
+          set: {
+            name: 'New Name',
+          },
+          where: {
+            id: '1',
+          },
+        }).should eq(expected)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'helper'
+require 'cassanity/argument_generators/index_create'
+
+describe Cassanity::ArgumentGenerators::IndexCreate do
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "CREATE INDEX ON mutants (ability_id)"
+      expected = [cql]
+      subject.call({
+        column_family_name: :mutants,
+        column_name: :ability_id,
+      }).should eq(expected)
+    end
+
+    context "with :keyspace_name" do
+      it "returns array of arguments" do
+        cql = "CREATE INDEX ON app.mutants (ability_id)"
+        expected = [cql]
+        subject.call({
+          keyspace_name: :app,
+          column_family_name: :mutants,
+          column_name: :ability_id,
+        }).should eq(expected)
+      end
+    end
+
+    context "with :name" do
+      it "returns array of arguments with name in cql" do
+        cql = "CREATE INDEX ability_index ON mutants (ability_id)"
+        expected = [cql]
+        subject.call({
+          name: :ability_index,
+          column_family_name: :mutants,
+          column_name: :ability_id,
+        }).should eq(expected)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'helper'
+require 'cassanity/argument_generators/index_drop'
+
+describe Cassanity::ArgumentGenerators::IndexDrop do
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "DROP INDEX mutants_ability_id"
+      expected = [cql]
+      subject.call({
+        :name => :mutants_ability_id,
+      }).should eq(expected)
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'helper'
+require 'cassanity/argument_generators/keyspace_create'
+
+describe Cassanity::ArgumentGenerators::KeyspaceCreate do
+  let(:keyspace_name) { 'analytics' }
+
+  describe "#call" do
+    context "only name" do
+      it "returns array of arguments" do
+        cql = "CREATE KEYSPACE #{keyspace_name} WITH strategy_class = ? AND strategy_options:replication_factor = ?"
+        expected = [cql, 'SimpleStrategy', 1]
+        subject.call(name: keyspace_name).should eq(expected)
+      end
+    end
+
+    context "overriding strategy_class" do
+      it "returns array of arguments" do
+        cql = "CREATE KEYSPACE #{keyspace_name} WITH strategy_class = ? AND strategy_options:replication_factor = ?"
+        expected = [cql, 'FooStrategy', 1]
+        subject.call({
+          name: keyspace_name,
+          strategy_class: 'FooStrategy',
+        }).should eq(expected)
+      end
+    end
+
+    context "overriding a default strategy_option" do
+      it "returns array of arguments" do
+        cql = "CREATE KEYSPACE #{keyspace_name} WITH strategy_class = ? AND strategy_options:replication_factor = ?"
+        expected = [cql, 'SimpleStrategy', 3]
+        subject.call({
+          name: keyspace_name,
+          strategy_options: {
+            replication_factor: 3,
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "adding new strategy_option" do
+      it "returns array of arguments" do
+        cql = "CREATE KEYSPACE #{keyspace_name} WITH strategy_class = ? AND strategy_options:replication_factor = ? AND strategy_options:batman = ?"
+        expected = [cql, 'SimpleStrategy', 1, 'robin']
+        subject.call({
+          name: keyspace_name,
+          strategy_options: {
+            batman: 'robin',
+          }
+        }).should eq(expected)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'helper'
+require 'cassanity/argument_generators/keyspace_drop'
+
+describe Cassanity::ArgumentGenerators::KeyspaceDrop do
+  let(:keyspace_name) { 'analytics' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "DROP KEYSPACE #{keyspace_name}"
+      expected = [cql]
+      subject.call(name: keyspace_name).should eq(expected)
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'helper'
+require 'cassanity/argument_generators/keyspace_use'
+
+describe Cassanity::ArgumentGenerators::KeyspaceUse do
+  let(:keyspace_name) { 'analytics' }
+
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "USE #{keyspace_name}"
+      expected = [cql]
+      subject.call(name: keyspace_name).should eq(expected)
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'helper'
+require 'cassanity/argument_generators/keyspaces'
+
+describe Cassanity::ArgumentGenerators::Keyspaces do
+  describe "#call" do
+    it "returns array of arguments" do
+      cql = "SELECT * FROM system.schema_keyspaces"
+      expected = [cql]
+      subject.call.should eq(expected)
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'helper'
+require 'cassanity/argument_generators/set_clause'
+
+describe Cassanity::ArgumentGenerators::SetClause do
+  describe "#call" do
+    it "returns array of arguments" do
+      subject.call({
+        set: {
+          name: 'GitHub',
+        }
+      }).should eq([
+        " SET name = ?",
+        'GitHub',
+      ])
+    end
+
+    context "with multiple :set keys/values" do
+      it "returns array of arguments where each SET is comma separated" do
+        time = Time.now
+
+        subject.call({
+          set: {
+            name: 'GitHub',
+            created_at: time,
+          }
+        }).should eq([
+          " SET name = ?, created_at = ?",
+          'GitHub',
+          time,
+        ])
+      end
+    end
+
+    context "with counter update" do
+      it "returns array of arguments where counter SET is correct" do
+        subject.call(set: {views: 'views + 5'}).
+          should eq([" SET views = views + 5"])
+      end
+
+      it "works with no spaces" do
+        subject.call(set: {views: 'views+5'}).
+          should eq([" SET views = views+5"])
+      end
+
+      it "works with one or more spaces before the operator" do
+        subject.call(set: {views: 'views +5'}).
+          should eq([" SET views = views +5"])
+
+        subject.call(set: {views: 'views  +5'}).
+          should eq([" SET views = views  +5"])
+      end
+
+      it "works with one or more spaces after the operator" do
+        subject.call(set: {views: 'views+ 5'}).
+          should eq([" SET views = views+ 5"])
+
+        subject.call(set: {views: 'views+  5'}).
+          should eq([" SET views = views+  5"])
+      end
+
+      it "works with spaces after before the key" do
+        subject.call(set: {views: ' views + 5'}).
+          should eq([" SET views =  views + 5"])
+      end
+
+      it "works with spaces after the number" do
+        subject.call(set: {views: 'views + 5 '}).
+          should eq([" SET views = views + 5 "])
+
+        subject.call(set: {views: 'views + 5  '}).
+          should eq([" SET views = views + 5  "])
+      end
+
+      it "works with negative operator" do
+        subject.call(set: {views: 'views - 5'}).
+          should eq([" SET views = views - 5"])
+      end
+
+      it "works with multiple digit numbers" do
+        subject.call(set: {views: 'views - 52737237'}).
+          should eq([" SET views = views - 52737237"])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'helper'
+require 'cassanity/argument_generators/using_clause'
+
+describe Cassanity::ArgumentGenerators::UsingClause do
+  describe "#call" do
+    context "with single :using option" do
+      it "returns array of arguments" do
+        subject.call({
+          using: {
+            ttl: 500,
+          }
+        }).should eq([
+          " USING TTL 500",
+        ])
+      end
+    end
+
+    context "with multiple :using option" do
+      it "returns array of arguments" do
+        subject.call({
+          using: {
+            ttl: 500,
+            consistency: 'quorum',
+            timestamp: 1234,
+          }
+        }).should eq([
+          " USING TTL 500 AND CONSISTENCY quorum AND TIMESTAMP 1234",
+        ])
+      end
+    end
+
+    context "with no arguments" do
+      it "returns array of arguments where only item is empty string" do
+        subject.call.should eq([""])
+      end
+    end
+
+    context "with empty arguments" do
+      it "returns array of arguments where only item is empty string" do
+        subject.call({}).should eq([""])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'helper'
+require 'cassanity/argument_generators/where_clause'
+
+describe Cassanity::ArgumentGenerators::WhereClause do
+  describe "#call" do
+    it "returns array of arguments" do
+      subject.call({
+        where: {
+          id: '1',
+        }
+      }).should eq([
+        " WHERE id = ?",
+        '1',
+      ])
+    end
+
+    context "with nil where" do
+      it "returns array with empty string" do
+        subject.call.should eq([""])
+      end
+    end
+
+    context "with empty where" do
+      it "returns array with empty string" do
+        subject.call(where: {}).should eq([""])
+      end
+    end
+
+    context "with array value for a where" do
+      it "returns array of arguments using IN for key with array value" do
+        subject.call({
+          where: {
+            id: ['1', '2', '3'],
+          }
+        }).should eq([
+          " WHERE id IN (?)",
+          ['1', '2', '3'],
+        ])
+      end
+    end
+
+    context "with multiple where values" do
+      it "returns array of arguments with AND separating where keys" do
+        subject.call({
+          where: {
+            bucket: '2012',
+            id: '1',
+          }
+        }).should eq([
+          " WHERE bucket = ? AND id = ?",
+          '2012',
+          '1',
+        ])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'helper'
+require 'cassanity/argument_generators/with_clause'
+
+describe Cassanity::ArgumentGenerators::WithClause do
+  describe "#call" do
+    context "with single :with option" do
+      it "returns array of arguments" do
+        subject.call({
+          with: {
+            comment: 'Just testing',
+          }
+        }).should eq([
+          " WITH comment = ?",
+          'Just testing',
+        ])
+      end
+    end
+
+    context "with multiple :with option" do
+      it "returns array of arguments" do
+        subject.call({
+          with: {
+            comment: 'Just testing',
+            read_repair_chance: 0.2,
+          }
+        }).should eq([
+          " WITH comment = ? AND read_repair_chance = ?",
+          'Just testing',
+          0.2,
+        ])
+      end
+    end
+
+    context "when using :with option that has sub options" do
+      it "returns array of arguments" do
+        subject.call({
+          with: {
+            compaction_strategy_options: {
+              min_compaction_threshold: 6,
+              max_compaction_threshold: 40,
+            },
+          }
+        }).should eq([
+          " WITH compaction_strategy_options:min_compaction_threshold = ? AND compaction_strategy_options:max_compaction_threshold = ?",
+          6,
+          40,
+        ])
+      end
+    end
+
+    context "with no arguments" do
+      it "returns array of arguments where only item is empty string" do
+        subject.call.should eq([""])
+      end
+    end
+
+    context "with empty arguments" do
+      it "returns array of arguments where only item is empty string" do
+        subject.call({}).should eq([""])
+      end
+    end
+  end
+end