veritas-sql-generator 0.0.3 → 0.0.4

data/spec/unit/date_time/iso_8601_spec.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe DateTime, '#iso8601' do
+
+  # ruby 1.9.3 has problems with fractional nanoseconds
+  def self.it_supports_nanoseconds(message = 'returns the expected date-time', &block)
+    if RUBY_VERSION >= '1.9.3'
+      it(message) { pending('Fix rounding error in 1.9.3', &block) }
+    else
+      it(message, &block)
+    end
+  end
+
+  let(:object)          { described_class.new(2010, 12, 31, 23, 59, 59 + nsec_in_seconds) }
+  let(:nsec_in_seconds) { 1 - Rational(1, 10**9)                                          }
+
+  # rubinius 1.2.3 has problems with fractional seconds above 59
+  unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx' && Rubinius::VERSION <= '1.2.3'
+    context 'with no arguments' do
+      subject { object.iso8601 }
+
+      context 'when the datetime is frozen' do
+        before do
+          object.freeze
+        end
+
+        it { should respond_to(:to_s) }
+
+        it_supports_nanoseconds do
+          should == '2010-12-31T23:59:59+00:00'
+        end
+      end
+
+      context 'when the datetime is not frozen' do
+        it { should respond_to(:to_s) }
+
+        it { should == '2010-12-31T23:59:59+00:00' }
+      end
+    end
+
+    context 'with a time scale of 0' do
+      subject { object.iso8601(time_scale) }
+
+      let(:time_scale) { 0 }
+
+      context 'when the datetime is frozen' do
+        before do
+          object.freeze
+        end
+
+        it { should respond_to(:to_s) }
+
+        it_supports_nanoseconds do
+          should == '2010-12-31T23:59:59+00:00'
+        end
+      end
+
+      context 'when the datetime is not frozen' do
+        it { should respond_to(:to_s) }
+
+        it { should == '2010-12-31T23:59:59+00:00' }
+      end
+    end
+
+    context 'with a time scale of 1' do
+      subject { object.iso8601(time_scale) }
+
+      let(:time_scale) { 1 }
+
+      context 'when the datetime is frozen' do
+        before do
+          object.freeze
+        end
+
+        it { should respond_to(:to_s) }
+
+        it_supports_nanoseconds do
+          should == '2010-12-31T23:59:59.9+00:00'
+        end
+      end
+
+      context 'when the datetime is not frozen' do
+        it { should respond_to(:to_s) }
+
+        it { should == '2010-12-31T23:59:59.9+00:00' }
+      end
+    end
+
+    context 'with a time scale of 9' do
+      subject { object.iso8601(time_scale) }
+
+      let(:time_scale) { 9 }
+
+      context 'when the datetime is frozen' do
+        before do
+          object.freeze
+        end
+
+        it { should respond_to(:to_s) }
+
+        it_supports_nanoseconds do
+          should == '2010-12-31T23:59:59.999999999+00:00'
+        end
+      end
+
+      context 'when the datetime is not frozen' do
+        it { should respond_to(:to_s) }
+
+        it { should == '2010-12-31T23:59:59.999999999+00:00' }
+      end
+    end
+  end
+end

data/spec/unit/veritas/sql/generator/class_methods/parenthesize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator, '.parenthesize!' do
+  subject { object.parenthesize!(string) }
+
+  let(:string) { '1 + 1'                   }
+  let(:object) { self.class.described_type }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  it 'modifies the string inline' do
+    should equal(string)
+  end
+
+  its(:to_s) { should == '(1 + 1)' }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_count_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_count' do
+  subject { object.visit_veritas_aggregate_count(count) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:count)           { attribute.count                                                                    }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('COUNT ("id")') }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_maximum_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_maximum' do
+  subject { object.visit_veritas_aggregate_maximum(maximum) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:maximum)         { attribute.maximum                                                                  }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('MAX ("id")') }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_mean_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_mean' do
+  subject { object.visit_veritas_aggregate_mean(mean) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:mean)            { attribute.mean                                                                     }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('AVG ("id")') }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_minimum_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_minimum' do
+  subject { object.visit_veritas_aggregate_minimum(minimum) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:minimum)         { attribute.minimum                                                                  }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('MIN ("id")') }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_standard_deviation_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_standard_deviation' do
+  subject { object.visit_veritas_aggregate_standard_deviation(standard_deviation) }
+
+  let(:described_class)    { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)          { Attribute::Integer.new(:id)                                                        }
+  let(:standard_deviation) { attribute.standard_deviation                                                       }
+  let(:object)             { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('STDDEV_POP ("id")') }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_sum_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_sum' do
+  subject { object.visit_veritas_aggregate_sum(sum) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:sum)             { attribute.sum                                                                      }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('COALESCE (SUM ("id"), 0)') }
+end

data/spec/unit/veritas/sql/generator/function/aggregate/visit_veritas_aggregate_variance_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Aggregate, '#visit_veritas_aggregate_variance' do
+  subject { object.visit_veritas_aggregate_variance(variance) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Aggregate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:variance)        { attribute.variance                                                                 }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('VAR_POP ("id")') }
+end

data/spec/unit/veritas/sql/generator/function/connective/visit_veritas_function_connective_conjunction_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Connective, '#visit_veritas_function_connective_conjunction' do
+  subject { object.visit_veritas_function_connective_conjunction(conjunction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Connective } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:conjunction)     { attribute.eq(1).and(attribute.ne(2))                                                }
+  let(:object)          { described_class.new                                                                 }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Predicate }
+  end
+
+  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/function/connective/visit_veritas_function_connective_disjunction_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Connective, '#visit_veritas_function_connective_disjunction' do
+  subject { object.visit_veritas_function_connective_disjunction(disjunction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Connective } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:disjunction)     { attribute.eq(1).or(attribute.eq(2))                                                 }
+  let(:object)          { described_class.new                                                                 }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Predicate }
+  end
+
+  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/function/connective/visit_veritas_function_connective_negation_spec.rb

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

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_absolute_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_absolute' do
+  subject { object.visit_veritas_function_numeric_absolute(absolute) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:absolute)        { Attribute::Integer.new(:number).abs                                              }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('ABS ("number")') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_addition_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_addition' do
+  subject { object.visit_veritas_function_numeric_addition(addition) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:addition)        { Attribute::Integer.new(:number).add(1)                                           }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" + 1)') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_division_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_division' do
+  subject { object.visit_veritas_function_numeric_division(division) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:division)        { Attribute::Integer.new(:number).divide(1)                                        }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" / 1)') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_exponentiation_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_exponentiation' do
+  subject { object.visit_veritas_function_numeric_exponentiation(exponentiation) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:exponentiation)  { Attribute::Integer.new(:number).exponent(1)                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('POWER ("number", 1)') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_modulo_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_modulo' do
+  subject { object.visit_veritas_function_numeric_modulo(modulo) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:modulo)          { Attribute::Integer.new(:number).modulo(1)                                        }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('MOD ("number", 1)') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_multiplication_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_multiplication' do
+  subject { object.visit_veritas_function_numeric_multiplication(multiplication) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:multiplication)  { Attribute::Integer.new(:number).multiply(1)                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" * 1)') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_square_root_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_square_root' do
+  subject { object.visit_veritas_function_numeric_square_root(square_root) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:square_root)     { Attribute::Integer.new(:number).square_root                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('SQRT ("number")') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_subtraction_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_subtraction' do
+  subject { object.visit_veritas_function_numeric_subtraction(subtraction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:subtraction)     { Attribute::Integer.new(:number).subtract(1)                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" - 1)') }
+end