cassanity 0.6.0.beta5 → 0.6.0

data/lib/cassanity/statement.rb

@@ -1,5 +1,6 @@
 require 'bigdecimal'
 require 'date'
+require 'set'
 require 'time'
 
 module Cassanity
@@ -19,7 +20,9 @@ module Cassanity
     private
     def quote(var)
       if Array === var
-        var.map { |v| quote(v) }.join(',')
+        %([#{var.map { |v| "#{quote(v)}" }.join(',')}])
+      elsif Set === var
+        %({#{var.map { |v| "#{quote(v)}" }.join(',')}})
       elsif Hash === var
         %({#{var.map { |k, v| "#{quote(k)}:#{quote(v)}" }.join(',')}})
       elsif String === var

data/lib/cassanity/version.rb

@@ -1,3 +1,3 @@
 module Cassanity
-  VERSION = "0.6.0.beta5"
+  VERSION = "0.6.0"
 end

data/spec/unit/cassanity/addition_spec.rb

@@ -0,0 +1,80 @@
+require 'helper'
+require 'cassanity/addition'
+
+describe Cassanity::Addition do
+  describe "self named helper method" do
+    it "returns instance" do
+      Cassanity::Addition('foo').should eq(described_class.new('foo'))
+    end
+  end
+
+  describe "#initialize" do
+    context "with value" do
+      before do
+        @instance = described_class.new('foo')
+      end
+
+      it "sets value" do
+        @instance.value.should eq(['foo'])
+      end
+
+      it "sets symbol" do
+        @instance.symbol.should be(:+)
+      end
+    end
+
+    context "with multiples values" do
+      before do
+        @instance = described_class.new('foo', 'bar')
+      end
+
+      it "sets values" do
+        @instance.value.should eq(['foo', 'bar'])
+      end
+    end
+
+    context "without value" do
+      it "raises error" do
+        expect {
+          subject.value
+        }.to raise_error(ArgumentError, "value cannot be nil")
+      end
+    end
+
+    context "with nil" do
+      it "raises error" do
+        expect {
+          described_class.new(nil)
+        }.to raise_error(ArgumentError, "value cannot be nil")
+      end
+    end
+  end
+
+  shared_examples_for "addition equality" do |method_name|
+    it "returns true for same class and value" do
+      instance = described_class.new('foo')
+      other = described_class.new('foo')
+      instance.send(method_name, other).should be_true
+    end
+
+    it "returns false for same class and different value" do
+      instance = described_class.new('foo')
+      other = described_class.new('bar')
+      instance.send(method_name, other).should be_false
+    end
+
+    it "returns false for different class" do
+      instance = described_class.new('foo')
+      other = Object.new
+      instance.send(method_name, other).should be_false
+    end
+  end
+
+  describe "#eql?" do
+    include_examples "addition equality", :eql?
+  end
+
+  describe "#==" do
+    include_examples "addition equality", :==
+  end
+end

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

@@ -80,5 +80,50 @@ describe Cassanity::ArgumentGenerators::Batch do
         }).should eq([cql])
       end
     end
+
+    context "with :type key" do
+      it "supports counter batch" do
+        cql = "BEGIN COUNTER BATCH APPLY BATCH"
+        subject.call({
+          type: 'counter',
+        }).should eq([cql])
+      end
+
+      it "supports unlogged batch" do
+        cql = "BEGIN UNLOGGED BATCH APPLY BATCH"
+        subject.call({
+          type: 'unlogged',
+        }).should eq([cql])
+      end
+
+      it "supports default logged batch" do
+        cql = "BEGIN BATCH APPLY BATCH"
+        subject.call({
+          type: 'logged',
+        }).should eq([cql])
+      end
+
+      it "defaults to logged when type is nil" do
+        cql = "BEGIN BATCH APPLY BATCH"
+        subject.call({
+          type: nil,
+        }).should eq([cql])
+      end
+
+      it "defaults to logged when type an empty string" do
+        cql = "BEGIN BATCH APPLY BATCH"
+        subject.call({
+          type: '',
+        }).should eq([cql])
+      end
+
+      it "raises error when type is invalid" do
+        expect {
+          subject.call({
+            type: 'anothertype',
+          })
+        }.to raise_error(ArgumentError, "invalid batch type")
+      end
+    end
   end
 end

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

@@ -73,6 +73,26 @@ describe Cassanity::ArgumentGenerators::ColumnFamilyCreate do
       end
     end
 
+    context "when using composite partition key" do
+      it "returns array of arguments" do
+        schema = Cassanity::Schema.new({
+          primary_key: [[:segment, :line], :track_id],
+          columns: {
+            segment: :text,
+            line: :int,
+            track_id: :timeuuid,
+            page: :text,
+          },
+        })
+        cql = "CREATE COLUMNFAMILY #{column_family_name} (segment text, line int, track_id timeuuid, page text, PRIMARY KEY ((segment, line), track_id))"
+        expected = [cql]
+        subject.call({
+          column_family_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']}

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

@@ -58,6 +58,48 @@ describe Cassanity::ArgumentGenerators::ColumnFamilyDelete do
       end
     end
 
+    context "with one collection item" do
+      it "returns array of arguments only deleting the collection item" do
+        cql = "DELETE foo[?] FROM #{column_family_name} WHERE \"id\" = ?"
+        expected = [cql, 0, '1']
+        subject.call({
+          column_family_name: column_family_name,
+          columns: Cassanity.item(0, :foo),
+          where: {
+            id: '1',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with multiple collection items" do
+      it "returns array of arguments only deleting the collection items" do
+        cql = "DELETE foo[?], foo[?] FROM #{column_family_name} WHERE \"id\" = ?"
+        expected = [cql, 0, 3, '1']
+        subject.call({
+          column_family_name: column_family_name,
+          columns: [Cassanity.item(0, :foo), Cassanity.item(3, :foo)],
+          where: {
+            id: '1',
+          }
+        }).should eq(expected)
+      end
+    end
+
+    context "with standard columns and collection items" do
+      it "returns array of arguments only deleting given columns" do
+        cql = "DELETE bar, foo[?] FROM #{column_family_name} WHERE \"id\" = ?"
+        expected = [cql, 0, '1']
+        subject.call({
+          column_family_name: column_family_name,
+          columns: [:bar, Cassanity.item(0, :foo)],
+          where: {
+            id: '1',
+          }
+        }).should eq(expected)
+      end
+    end
+
     context "with :where key" do
       subject {
         described_class.new({

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

@@ -24,6 +24,17 @@ describe Cassanity::ArgumentGenerators::KeyspaceCreate do
       end
     end
 
+    context "overriding replication class with NetworkTopologyStrategy" do
+      it "doesn't merge in replication_factor" do
+        cql = "CREATE KEYSPACE #{keyspace_name} WITH replication = ?"
+        expected = [cql, {class: 'NetworkTopologyStrategy', datacenter1: 1}]
+        subject.call({
+          keyspace_name: keyspace_name,
+          replication: {class: 'NetworkTopologyStrategy', datacenter1: 1},
+        }).should eq(expected)
+      end
+    end
+
     context "overriding a default strategy_option" do
       it "returns array of arguments" do
         cql = "CREATE KEYSPACE #{keyspace_name} WITH replication = ?"

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

@@ -44,5 +44,40 @@ describe Cassanity::ArgumentGenerators::SetClause do
           should eq([" SET views = views - ?", 3])
       end
     end
+
+    context "with addition" do
+      it "returns array of arguments with SET including list value" do
+        subject.call(set: {places: Cassanity::Addition.new('mordor')}).
+          should eq([" SET places = places + ?", ['mordor']])
+      end
+    end
+
+    context "with removal" do
+      it "returns array of arguments with SET including list value" do
+        subject.call(set: {places: Cassanity::Removal.new('mordor')}).
+          should eq([" SET places = places - ?", ['mordor']])
+      end
+    end
+
+    context "with set_addition" do
+      it "returns array of arguments with SET including set value" do
+        subject.call(set: {places: Cassanity::SetAddition.new('mordor')}).
+          should eq([" SET places = places + ?", Set['mordor']])
+      end
+    end
+
+    context "with set_removal" do
+      it "returns array of arguments with SET including set value" do
+        subject.call(set: {places: Cassanity::SetRemoval.new('mordor')}).
+          should eq([" SET places = places - ?", Set['mordor']])
+      end
+    end
+
+    context "with collection_item" do
+      it "returns array of arguments with SET including collection item" do
+        subject.call(set: {tags: Cassanity::CollectionItem.new(3,'ruby')}).
+          should eq([" SET tags[?] = ?", 3, 'ruby'])
+      end
+    end
   end
 end

data/spec/unit/cassanity/collection_item_spec.rb

@@ -0,0 +1,84 @@
+require 'helper'
+require 'cassanity/collection_item'
+
+describe Cassanity::CollectionItem do
+  subject {
+    described_class.new(1, 'ruby')
+  }
+
+  describe "self named helper method" do
+    it "returns instance" do
+      Cassanity::CollectionItem(0, 'ruby').should eq(described_class.new(0, 'ruby'))
+    end
+  end
+
+  describe "#initialize" do
+    before do
+      @instance = described_class.new(1, 'ruby')
+    end
+
+    it "sets key" do
+      @instance.key.should eq(1)
+    end
+
+    it "sets value" do
+      @instance.value.should eq('ruby')
+    end
+
+    context "with key nil" do
+      it "raises error" do
+        expect {
+          described_class.new(nil, 3)
+        }.to raise_error(ArgumentError, "key cannot be nil")
+      end
+    end
+
+    context "with value nil" do
+      it "raises error" do
+        expect {
+          described_class.new(3, nil)
+        }.to raise_error(ArgumentError, "value cannot be nil")
+      end
+    end
+  end
+
+  shared_examples_for "operator equality" do |method_name|
+    it "returns true for same class, key and value" do
+      instance = described_class.new(0, 'ruby')
+      other = described_class.new(0, 'ruby')
+      instance.send(method_name, other).should be_true
+    end
+
+    it "returns false for same class/value and different key" do
+      instance = described_class.new(0, 'ruby')
+      other = described_class.new(1, 'ruby')
+      instance.send(method_name, other).should be_false
+    end
+
+    it "returns false for same class/key and different value" do
+      instance = described_class.new(0, 'ruby')
+      other = described_class.new(0, 'go')
+      instance.send(method_name, other).should be_false
+    end
+
+    it "returns false for different class" do
+      instance = described_class.new(1, 'ruby')
+      other = Object.new
+      instance.send(method_name, other).should be_false
+    end
+  end
+
+  describe "#eql?" do
+    include_examples "operator equality", :eql?
+  end
+
+  describe "#==" do
+    include_examples "operator equality", :==
+  end
+
+  describe "#inspect" do
+    it "return representation" do
+      subject.inspect.should eq("#<Cassanity::CollectionItem:#{subject.object_id} key=1, value=\"ruby\">")
+    end
+  end
+end

data/spec/unit/cassanity/removal_spec.rb

@@ -0,0 +1,80 @@
+require 'helper'
+require 'cassanity/removal'
+
+describe Cassanity::Removal do
+  describe "self named helper method" do
+    it "returns instance" do
+      Cassanity::Removal('foo').should eq(described_class.new('foo'))
+    end
+  end
+
+  describe "#initialize" do
+    context "with value" do
+      before do
+        @instance = described_class.new('foo')
+      end
+
+      it "sets value" do
+        @instance.value.should eq(['foo'])
+      end
+
+      it "sets symbol" do
+        @instance.symbol.should be(:-)
+      end
+    end
+
+    context "with multiples values" do
+      before do
+        @instance = described_class.new('foo', 'bar')
+      end
+
+      it "sets values" do
+        @instance.value.should eq(['foo', 'bar'])
+      end
+    end
+
+    context "without value" do
+      it "raises error" do
+        expect {
+          subject.value
+        }.to raise_error(ArgumentError, "value cannot be nil")
+      end
+    end
+
+    context "with nil" do
+      it "raises error" do
+        expect {
+          described_class.new(nil)
+        }.to raise_error(ArgumentError, "value cannot be nil")
+      end
+    end
+  end
+
+  shared_examples_for "removal equality" do |method_name|
+    it "returns true for same class and value" do
+      instance = described_class.new('foo')
+      other = described_class.new('foo')
+      instance.send(method_name, other).should be_true
+    end
+
+    it "returns false for same class and different value" do
+      instance = described_class.new('foo')
+      other = described_class.new('bar')
+      instance.send(method_name, other).should be_false
+    end
+
+    it "returns false for different class" do
+      instance = described_class.new('foo')
+      other = Object.new
+      instance.send(method_name, other).should be_false
+    end
+  end
+
+  describe "#eql?" do
+    include_examples "removal equality", :eql?
+  end
+
+  describe "#==" do
+    include_examples "removal equality", :==
+  end
+end