veritas-sql-generator 0.0.3

data/spec/unit/veritas/sql/generator/literal/visit_enumerable_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_enumerable' do
+  subject { object.visit_enumerable(enumerable) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:enumerable)      { [ 1, 2 ].freeze                                                        }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('(1, 2)') }
+end

data/spec/unit/veritas/sql/generator/literal/visit_false_class_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_false_class' do
+  subject { object.visit_false_class(false) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('FALSE') }
+end

data/spec/unit/veritas/sql/generator/literal/visit_nil_class_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_nil_class' do
+  subject { object.visit_nil_class(nil) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('NULL') }
+end

data/spec/unit/veritas/sql/generator/literal/visit_numeric_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_numeric' do
+  subject { object.visit_numeric(numeric) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  context 'with an Integer' do
+    let(:numeric) { 1 }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1') }
+  end
+
+  context 'with a Float' do
+    let(:numeric) { 1.0 }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1.0') }
+  end
+
+  context 'with a BigDecimal' do
+    let(:numeric) { BigDecimal('1.0') }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('0.1E1') }
+  end
+end

data/spec/unit/veritas/sql/generator/literal/visit_string_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_string' do
+  subject { object.visit_string(string) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  context 'with a string containing no quotes' do
+    let(:string) { 'string'.freeze }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql("'string'") }
+  end
+
+  context 'with a string containing quotes' do
+    let(:string) { "string'name".freeze }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql("'string''name'") }
+  end
+end

data/spec/unit/veritas/sql/generator/literal/visit_time_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_time' do
+  subject { object.visit_time(time) }
+
+  # Time#iso8601 is currently broken in JRuby 1.6.1 when fractional seconds are not 0
+  def self.time_iso8601_broken?
+    RUBY_PLATFORM =~ /java/ && JRUBY_VERSION <= '1.6.1' && RUBY_VERSION >= '1.9.2'
+  end
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  before :all do
+    @original_tz = ENV['TZ']
+  end
+
+  after :all do
+    ENV['TZ'] = @original_tz
+  end
+
+  context 'when the Time is UTC' do
+    context 'and the microseconds are equal to 0' do
+      let(:usec) { 0                                               }
+      let(:time) { Time.utc(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000Z'") }
+    end
+
+    context 'and the microseconds are greater than 0' do
+      let(:usec) { 1                                               }
+      let(:time) { Time.utc(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      unless time_iso8601_broken?
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000001000Z'") }
+      end
+    end
+  end
+
+  context 'when the Time is local, and the local time zone is UTC' do
+    before :all do
+      ENV['TZ'] = 'UTC'
+    end
+
+    context 'and the microseconds are equal to 0' do
+      let(:usec) { 0                                                 }
+      let(:time) { Time.local(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000Z'") }
+    end
+
+    context 'and the microseconds are greater than 0' do
+      let(:usec) { 1                                                 }
+      let(:time) { Time.local(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      unless time_iso8601_broken?
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000001000Z'") }
+      end
+    end
+  end
+
+  context 'when the Time is local, and the local time zone is not UTC' do
+    before :all do
+      ENV['TZ'] = 'America/Vancouver'
+    end
+
+    context 'and the microseconds are equal to 0' do
+      let(:usec) { 0                                                 }
+      let(:time) { Time.local(2010, 12, 31, 15, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000Z'") }
+    end
+
+    context 'and the microseconds are greater than 0' do
+      let(:usec) { 1                                                 }
+      let(:time) { Time.local(2010, 12, 31, 15, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      unless time_iso8601_broken?
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000001000Z'") }
+      end
+    end
+  end
+end

data/spec/unit/veritas/sql/generator/literal/visit_true_class_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_true_class' do
+  subject { object.visit_true_class(true) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('TRUE') }
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_connective_conjunction_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_connective_conjunction' do
+  subject { object.visit_veritas_logic_connective_conjunction(conjunction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                          }
+  let(:conjunction)     { attribute.eq(1).and(attribute.ne(2))                                 }
+  let(:object)          { described_class.new                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("id" = 1 AND "id" <> 2)') }
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_connective_disjunction_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_connective_disjunction' do
+  subject { object.visit_veritas_logic_connective_disjunction(disjunction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                          }
+  let(:disjunction)     { attribute.eq(1).or(attribute.eq(2))                                  }
+  let(:object)          { described_class.new                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("id" = 1 OR "id" = 2)') }
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_connective_negation_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_connective_negation' do
+  subject { object.visit_veritas_logic_connective_negation(negation) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                          }
+  let(:negation)        { Logic::Connective::Negation.new(attribute.eq(1))                     }
+  let(:object)          { described_class.new                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('NOT "id" = 1') }
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_equality_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_equality' do
+  subject { object.visit_veritas_logic_predicate_equality(equality) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                          }
+  let(:object)          { described_class.new                                                  }
+
+  context 'when the right operand is not nil' do
+    let(:equality) { attribute.eq(1) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" = 1') }
+  end
+
+  context 'when the right operand is nil' do
+    let(:equality) { attribute.eq(nil) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" IS NULL') }
+  end
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_exclusion_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_exclusion' do
+  subject { object.visit_veritas_logic_predicate_exclusion(exclusion) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                          }
+  let(:object)          { described_class.new                                                  }
+
+  context 'when right operand is an inclusive Range' do
+    let(:exclusion) { attribute.exclude(1..10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" NOT BETWEEN 1 AND 10') }
+  end
+
+  context 'when right operand is an exclusive Range' do
+    let(:exclusion) { attribute.exclude(1...10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('("id" < 1 OR "id" >= 10)') }
+  end
+
+  context 'when right operand is an Array' do
+    let(:exclusion) { attribute.exclude([ 1, 2 ]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" NOT IN (1, 2)') }
+  end
+
+  context 'when right operand is an empty Array' do
+    let(:exclusion) { attribute.exclude([]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1 = 1') }
+  end
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_greater_than_or_equal_to_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_greater_than_or_equal_to' do
+  subject { object.visit_veritas_logic_predicate_greater_than_or_equal_to(greater_than_or_equal_to) }
+
+  let(:described_class)          { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:greater_than_or_equal_to) { Attribute::Integer.new(:id).gte(1)                                   }
+  let(:object)                   { described_class.new                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" >= 1') }
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_greater_than_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_greater_than' do
+  subject { object.visit_veritas_logic_predicate_greater_than(greater_than) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:greater_than)    { Attribute::Integer.new(:id).gt(1)                                    }
+  let(:object)          { described_class.new                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" > 1') }
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_inclusion_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inclusion' do
+  subject { object.visit_veritas_logic_predicate_inclusion(inclusion) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                          }
+  let(:object)          { described_class.new                                                  }
+
+  context 'when right operand is an inclusive Range' do
+    let(:inclusion) { attribute.include(1..10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" BETWEEN 1 AND 10') }
+  end
+
+  context 'when right operand is an exclusive Range' do
+    let(:inclusion) { attribute.include(1...10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('("id" >= 1 AND "id" < 10)') }
+  end
+
+  context 'when right operand is an Array' do
+    let(:inclusion) { attribute.include([ 1, 2 ]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" IN (1, 2)') }
+  end
+
+  context 'when right operand is an empty Array' do
+    let(:inclusion) { attribute.include([]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1 = 0') }
+  end
+end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_inequality_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inequality' do
+  subject { object.visit_veritas_logic_predicate_inequality(inequality) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
+  let(:object)          { described_class.new                                                  }
+
+  context 'and the left attribute is optional' do
+    let(:attribute)  { Attribute::Integer.new(:age, :required => false) }
+    let(:inequality) { attribute.ne(1)                                  }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('("age" <> 1 OR "age" IS NULL)') }
+  end
+
+  context 'and the right attribute is optional' do
+    let(:attribute)  { Attribute::Integer.new(:age, :required => false) }
+    let(:inequality) { Logic::Predicate::Inequality.new(1, attribute)   }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(1 <> "age" OR "age" IS NULL)') }
+  end
+
+  context 'and the left is a value' do
+    let(:attribute)  { Attribute::Integer.new(:id)                    }
+    let(:inequality) { Logic::Predicate::Inequality.new(1, attribute) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1 <> "id"') }
+  end
+
+  context 'and the right is a value' do
+    let(:attribute)  { Attribute::Integer.new(:id) }
+    let(:inequality) { attribute.ne(1)             }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" <> 1') }
+  end
+
+  context 'and the right is a nil value' do
+    let(:attribute)  { Attribute::Integer.new(:id) }
+    let(:inequality) { attribute.ne(nil)           }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" IS NOT NULL') }
+  end
+end