google_data_source 0.7.6

data/test/units/sql_parser_test.rb

@@ -0,0 +1,111 @@
+# coding: utf-8
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class SqlParserTest < ActiveSupport::TestCase
+  include GoogleDataSource::DataSource
+  
+  test "quoting with ticks" do
+    result = SqlParser.parse("where `foo bar`=3")
+    assert_equal 'foo bar', result.where.left.to_s
+  end
+  
+  test "quoting with single quotes" do
+    result = SqlParser.parse("where bar='foo bar'")
+    assert_equal 'foo bar', result.where.right.to_s
+  end
+  
+  test "allow escaped quotes in qutoed strings" do
+    result = SqlParser.parse("where bar='test\\''")
+    assert_equal "test'", result.where.right.to_s
+  end
+  
+  test "allow escaped backslash" do
+    result = SqlParser.parse("where bar='te\\\\st'")
+    assert_equal "te\\st", result.where.right.to_s
+  end
+  
+  test "allow escaped backslash as last character" do
+    result = SqlParser.parse("where bar='test\\\\'")
+    assert_equal "test\\", result.where.right.to_s
+  end
+  
+  test "parsing of empty single quoted string ('')" do
+    result = SqlParser.parse("where foo=''")
+    assert_equal "", result.where.right.to_s
+  end
+  
+  test "the 'in' statement in where conditions" do
+    result = SqlParser.parse("where foo in ('1','2')")
+    assert_equal "foo", result.where.expr.to_s
+    assert_equal 2, result.where.vals.size
+    assert_equal '1', result.where.vals[0].to_s
+    assert_equal '2', result.where.vals[1].to_s
+  end
+  
+  ###############################
+  # Test the simple parser
+  ###############################
+  test "simple parser" do
+    result = SqlParser.simple_parse("select id,name where age = 18 group by attr1, attr2 order by age asc limit 10 offset 5")
+    assert_equal ['id', 'name'], result.select
+    assert_equal 10, result.limit
+    assert_equal 5, result.offset
+    assert_equal ['attr1', 'attr2'], result.groupby
+    assert_equal ['age', :asc], result.orderby
+    assert_equal({'age' => '18'}, result.conditions)
+  end
+  
+  test "simple order parser should only accept a single ordering" do
+    assert_raises GoogleDataSource::DataSource::SimpleSqlException do
+      SqlParser.simple_parse("order by name,date")
+    end
+  end
+  
+  test "simple groupby parser should return empty array if no group by statement is given" do
+    assert_equal [], SqlParser.simple_parse("").groupby
+  end
+  
+  test "simple where parser" do
+    conditions = SqlParser.simple_parse("where id = 1 and name = `foo bar` and `foo bar` = 123").conditions
+  
+    assert_equal '1', conditions['id']
+    assert_equal 'foo bar', conditions['name']
+    assert_equal '123', conditions['foo bar']
+  end
+  
+  test "simple where parser should only accept and operators" do
+    assert_raises GoogleDataSource::DataSource::SimpleSqlException do
+      SqlParser.simple_parse("where id = 1 or name = `foo bar`")
+    end
+  end
+  
+  test "where parser should convert other operators than = to array" do
+    conditions = SqlParser.simple_parse("where date > '2010-01-01' and date < '2010-02-01'").conditions
+    assert_kind_of Array, conditions['date']
+    assert_equal '>', conditions['date'].first.op
+    assert_equal '2010-01-01', conditions['date'].first.value
+    assert_equal '<', conditions['date'].last.op
+    assert_equal '2010-02-01', conditions['date'].last.value
+  end
+  
+  test "limit should be nil if empty in query" do
+    assert_nil SqlParser.simple_parse("").limit
+  end
+  
+  test "offset should be nil if empty in query" do
+    assert_nil SqlParser.simple_parse("").offset
+  end
+  
+  test "raise exception if operator = is used besides of other operators in where clause" do
+    assert_raise GoogleDataSource::DataSource::SimpleSqlException do
+      SqlParser.simple_parse("where foo = '1' and foo >= 2")
+    end
+  end
+  
+  test "parsing in( ) expressions in where clause" do
+    conditions = SqlParser.simple_parse("where foo in ('1','2')").conditions
+    assert_equal 1, conditions['foo'].size
+    assert_equal 'in', conditions['foo'].first.op
+    assert_equal %w(1 2), conditions['foo'].first.value
+  end
+end

data/test/units/sql_reporting_test.rb

@@ -0,0 +1,307 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+require "lib/empty_reporting"
+
+class SqlReportingTest < ActiveSupport::TestCase
+  class SqlTestReporting < SqlReporting
+    attr_reader :aggregate_calls
+    filter :name,               :sql => true
+    filter :lastname
+    filter :got_no_sql_column
+    filter :building_no,        :type => :number
+    filter :test_integer,       :type => :integer
+    filter :boolean_thing,      :type => :boolean, :sql => true
+
+    table :notneeded,                         :join => 'JOIN notneeded'
+    table :buildings, :depends => :companies, :join => 'JOIN buildings'
+    table :companies,                         :join => 'JOIN companies'
+
+    column :firstname,      :type => :string, :sql => true
+    column :lastname,       :type => :string, :sql => { :column => :name }
+    column :company_name,   :type => :string, :sql => { :table => :companies, :column => :name }
+    column :fullname,       :type => :string
+    column :building_no,    :type => :number, :sql => { :table => :buildings, :column => :number }
+    column :literal_column, :type => :string, :sql => { :table => :companies, :column => 'literal' }
+
+    column :info,           :type => :string, :requires => :firstname
+    column :boolean_thing,  :type => :boolean, :sql => { :table => :companies, :column => :my_boolean }
+    
+    def initialize(*args)
+      @aggregate_calls = 0
+      super(*args)
+    end
+
+    def aggregate
+      @aggregate_calls += 1
+      @rows = []
+    end
+  end
+
+  class SqlTestReportingB < SqlTestReporting
+    filter :name_b
+  end
+
+  class SqlTestReportingC < SqlTestReporting
+    table :dummy
+  end
+
+  class EmptySqlTestReporting < SqlReporting
+
+    # overridden for testability
+    def self.column(name, options = {})
+      @defined_columns ||= {}
+      @defined_columns.merge!({name => options})
+    end
+
+    def self.defined_columns
+      @defined_columns
+    end
+  end
+
+
+  def setup
+    @reporting = SqlTestReporting.new
+  end
+  
+  test 'should mark bind variables as used columns' do
+    reporting = SqlTestReporting.new(:name => 'foo', :lastname => 'bar')
+    assert_equal([], reporting.columns_used)
+    reporting.mark_used_columns
+    assert_equal([ :name ], reporting.columns_used)
+  end
+  
+  test 'should return an array of bind variables for the query' do
+    assert_equal({ :name => 'foo' }, SqlTestReporting.new(:name => 'foo', :lastname => 'bar').sql_bind_variables)
+  end
+  
+  test 'should return an array of sql conditions concatinated by AND, and mark colums as used' do
+    reporting = SqlTestReporting.new(:name => 'foo', :boolean_thing => true)
+    conditions = reporting.sql_conditions
+    assert_equal "(name = 'foo') AND (companies.my_boolean = '1')", conditions
+    assert_equal [:name, :boolean_thing], reporting.columns_used
+  end
+  
+  test 'should return a condition for a boolean field' do
+    assert_equal "(companies.my_boolean = '1')", @reporting.sql_condition_for(:boolean_thing, true)
+    assert_equal "(companies.my_boolean = '0' OR ISNULL(companies.my_boolean))", @reporting.sql_condition_for(:boolean_thing, false)
+  end
+
+  test 'should return a condition for a number field' do
+    assert_equal "(buildings.number = 1 )", @reporting.sql_condition_for(:building_no, 1)
+    assert_equal '(buildings.number = \'1\' )', @reporting.sql_condition_for(:building_no, '1')
+    assert_equal '(buildings.number = \'0\' OR ISNULL(buildings.number))', @reporting.sql_condition_for(:building_no, '0')
+    assert_equal '(buildings.number = 0 OR ISNULL(buildings.number))', @reporting.sql_condition_for(:building_no, 0)
+  end
+
+  test 'should return a condition for an integer field' do
+    assert_equal '(test_integer = 0 OR ISNULL(test_integer))', @reporting.sql_condition_for(:test_integer, 0)
+  end
+  test 'should return a condition for a string field' do
+    assert_equal '(name = \'foobar\')', @reporting.sql_condition_for(:lastname, 'foobar')
+  end
+
+  test 'should safely handle quotes in escaped value' do
+    assert_equal '(name = \'"test"\')', @reporting.sql_condition_for(:lastname, '"test"')
+    assert_equal "(name = '\\'test\\'')", @reporting.sql_condition_for(:lastname, "'test'")
+  end
+  
+  test "should return an array with values as IN match" do
+    assert_equal "(name IN('test','test2'))", @reporting.sql_condition_for(:lastname, %w(test test2))    
+  end
+  
+  test 'should return a condition even if there is no sql column defined for this filter' do
+    assert_equal '(got_no_sql_column = \'foobar\')', @reporting.sql_condition_for(:got_no_sql_column, 'foobar')
+  end
+  
+  test "is_sql_column?" do
+    assert @reporting.is_sql_column?(:firstname), 'should be an sql column'
+    assert @reporting.is_sql_column?('lastname'), 'should be an sql column'
+    assert !@reporting.is_sql_column?(:fullname), 'should be no sql column'
+  end
+
+  test "sql_column_name" do
+    assert !@reporting.sql_column_name(:fullname)
+    assert_equal 'firstname', @reporting.sql_column_name(:firstname)
+    assert_equal 'firstname', @reporting.sql_column_name(:firstname, :with_alias => true)
+    assert_equal 'name', @reporting.sql_column_name(:lastname)
+    assert_equal 'companies.name', @reporting.sql_column_name(:company_name)
+    assert_equal 'companies.name company_name', @reporting.sql_column_name(:company_name, :with_alias => true)
+  end
+
+  test "select should consider mapping" do
+    @reporting.select = %w(firstname)
+    assert_equal 'christian_name firstname', @reporting.sql_select([], 'firstname' => 'christian_name')
+  end
+
+  test "group_by should consider mapping" do
+    @reporting.group_by = %w(firstname)
+    assert_equal 'christian_name', @reporting.sql_group_by([], 'firstname' => 'christian_name')
+  end
+
+  test "select some sql and some ruby columns" do
+    reporting = reporting_from_query("select firstname, fullname")
+    assert_equal "firstname", reporting.sql_select
+  end
+
+  test "use column name mappings in sql_select" do
+    reporting = reporting_from_query("select company_name, fullname")
+    assert_equal "companies.name company_name", reporting.sql_select
+  end
+
+  test "sql_columns" do
+    assert @reporting.sql_columns.include?(:firstname)
+    assert @reporting.sql_columns.include?(:company_name)
+    assert !@reporting.sql_columns.include?(:fullname)
+  end
+
+  test "select *" do
+    reporting = reporting_from_query("select *")
+    sql = reporting.sql_columns.collect { |c| reporting.sql_column_name(c, :with_alias => true) }.join (', ')
+    assert_equal sql, reporting.sql_select
+  end
+
+  test "sql_group_by" do
+    reporting = reporting_from_query("group by firstname, fullname")
+    assert_equal "firstname", reporting.sql_group_by
+  end
+
+  test "sql_group_by should be nil if no grouping exists" do
+    reporting = reporting_from_query("")
+    assert_nil reporting.sql_group_by
+  end
+
+  test "sql_order_by should return nil if the column is a virtual one" do
+    reporting = reporting_from_query("order by fullname")
+    assert_nil reporting.sql_order_by
+  end
+
+  test "sql_order_by" do
+    reporting = reporting_from_query("order by firstname")
+    assert_equal "firstname ASC", reporting.sql_order_by
+  end
+
+  test "sql_order_by shoul consider mapping" do
+    reporting = reporting_from_query("order by firstname")
+    assert_equal "name ASC", reporting.sql_order_by('firstname' => 'name')
+  end
+
+  test "sql_order_by should return nil if order_by is not set" do
+    reporting = reporting_from_query("")
+    assert_nil reporting.sql_order_by
+  end
+
+  test "use column name mappings in sql_group_by" do
+    reporting = reporting_from_query("group by firstname, lastname, fullname")
+    assert_equal "firstname, name", reporting.sql_group_by
+  end
+
+  test "get joins for columns" do
+    assert_equal "", @reporting.sql_joins(%w(firstname))
+    assert_equal "JOIN companies", @reporting.sql_joins(%w(company_name))
+  end
+
+  test "get joins resolving dependencies" do
+    assert_equal "JOIN companies JOIN buildings", @reporting.sql_joins(%w(building_no company_name))
+  end
+
+  test "columns method should return plain columns without sql option" do
+    reporting = reporting_from_query("select *")
+    reporting.columns.each do |column|
+      assert !column.has_key?(:sql)
+    end
+  end
+
+  test "join according to the used columns" do
+    reporting = reporting_from_query("select firstname")
+    assert_equal "", reporting.sql_joins
+
+    reporting = reporting_from_query("select company_name")
+    reporting.sql_select
+    assert_equal "JOIN companies", reporting.sql_joins
+  end
+
+  test "join if columns are added with mark_as_used" do
+    reporting = reporting_from_query("select firstname")
+    assert_equal "", reporting.sql_joins
+    reporting.mark_as_used('company_name')
+    assert_equal "JOIN companies", reporting.sql_joins
+  end
+
+  test "include required columns in sql_select statement" do
+    reporting = reporting_from_query("select firstname")
+    reporting.add_required_columns :company_name
+    select = reporting.sql_select.split(', ')
+    assert_equal 2, select.size
+    assert select.include?('firstname')
+    assert select.include?('companies.name company_name')
+  end
+
+  test "account for columns that require other columns" do
+    reporting = reporting_from_query("select info")
+    select = reporting.sql_select.split(', ')
+    assert_equal 1, select.size
+    assert_equal 'firstname', select.first
+  end
+
+  test "include joins for required columns" do
+    reporting = reporting_from_query("select firstname")
+    reporting.add_required_columns :company_name
+    assert_equal "JOIN companies", reporting.sql_joins
+  end
+
+  test "sql_group_by should recognize the mapping if it's the first parameter" do
+    @reporting.group_by = %w(firstname)
+    assert_equal "christian_name", @reporting.sql_group_by('firstname' => 'christian_name')
+  end
+
+  test "should not append table name if column name is give as string" do
+    assert_equal 'literal', @reporting.sql_column_name(:literal_column)
+  end
+
+  test "subclasses should inherit sql_tables" do
+    assert_equal 3, SqlTestReporting.sql_tables.count
+    assert_equal 3, SqlTestReportingB.sql_tables.count
+    assert_equal 4, SqlTestReportingC.sql_tables.count
+  end
+
+  test "model_columns should find names and types" do
+    assert_equal( {:first_col => :number, :second_col => :string, :third_col => :dummy_type}, 
+      SqlReporting::model_columns(model_mock) )
+  end
+
+  test "add_sql_columns_for should add all columns" do
+    EmptySqlTestReporting::expects(:model_columns).with("dummy_object").
+        returns({:first_col => :string, :second_col => :number})
+
+    EmptySqlTestReporting::add_sql_columns_for("dummy_object")
+
+    assert_equal( {
+      :first_col => {:type => :string, :sql => true, :grouping => true},
+      :second_col => {:type => :number, :sql => {:column=>"SUM(second_col)"}, :grouping => false}
+      }, EmptySqlTestReporting.defined_columns)
+  end
+
+  test "add_sql_columns_for should add all but the excluded columns" do
+    EmptySqlTestReporting::expects(:model_columns).with("dummy_object").
+        returns({:first_col => :string, :second_col => :number})
+        
+    EmptySqlTestReporting::add_sql_columns_for("dummy_object", :except => ["second_col"])
+
+    assert_equal( {
+      :first_col => {:type => :string, :sql => true, :grouping => true}
+      }, EmptySqlTestReporting.defined_columns)
+  end
+
+  protected
+
+  def reporting_from_query(query)
+    SqlTestReporting.from_params({:tq => query})
+  end
+
+  def model_mock
+    number_mock = OpenStruct.new(:number? => true)
+    string_mock = OpenStruct.new(:number? => false, :text? => true)
+    other_mock = OpenStruct.new(:number? => false, :text? => false, :type => :dummy_type)
+    
+    OpenStruct.new(:columns_hash => {:first_col => number_mock, :second_col => string_mock, :third_col => other_mock})
+  end
+end

data/test/units/xml_data_test.rb

@@ -0,0 +1,32 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class XmlDataTest < ActiveSupport::TestCase
+
+  def setup
+    setup_db
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  test "xml rendering" do
+    items = [Item.create(:name => "Item Name 1", :description => "hidden description", :number => 0),
+             Item.create(:name => "Item Name 2", :description => "description", :number => 1)]
+    ds = GoogleDataSource::DataSource::Base.from_params({:tqx => "reqId:0;out:xml"})
+    
+    columns = [
+      {:id => 'name', :label => 'Name', :type => 'string'},
+      {:id => 'number', :label => 'Number', :type => 'number'},
+    ]
+    ds.set(items, columns)
+
+    xml = Nokogiri::XML(ds.response)
+
+    assert xml.xml?
+    assert_equal 2, xml.root.css('item').size
+    assert_equal 'Item Name 1', xml.root.css('item name').first.child.inner_text
+    assert_equal 0, xml.errors.size
+  end
+
+end