visual_query 0.3.0

data/test/functional/routes_test.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RoutesTest < ActionController::TestCase
+  def setup
+    super
+    @routes = VisualQuery::Engine.routes
+  end
+
+  def test_root
+    assert_routing({:method => :get, :path => ''},
+                   {:controller=>"queries", :action=>"index"})
+  end
+
+  def test_new
+    assert_routing({:method => :get, :path => '/new'},
+                   {:controller=>"queries", :action=>"new"})
+  end
+
+  def test_create
+    assert_routing({:method => :post, :path => ''},
+                   {:controller=>"queries", :action=>"create"})
+  end
+
+  def test_show
+    assert_routing({:method => :get, :path => '/some_query'},
+                   {:controller=>"queries", :action=>"show", :name=>'some_query'})
+  end
+
+  def test_delete
+    assert_routing({:method => :delete, :path => '/some_query'},
+                   {:controller=>"queries", :action=>"destroy", :name=>'some_query'})
+  end
+
+  # Rails routing does not escape percent character %
+  #
+  # def test_show_with_special_characters
+  #   assert_routing({:method => :get, :path => '/show/Long%20name%20with%20spaces,%20dot.%20and%25'},
+  #                  {:controller=>"queries", :action=>"show", :name=>"Long name with spaces, dot. and%"})
+  # end
+  #
+  # def test_delete_with_special_characters
+  #   assert_routing({:method => :delete, :path => '/delete/Long%20name%20with%20spaces,%20dot.%20and%25'},
+  #                  {:controller=>"queries", :action=>"destroy", :name=>"Long name with spaces, dot. and%"})
+  # end
+  #
+  # def test_edit_sql_with_special_characters
+  #   assert_routing({:method => :get, :path => '/edit_sql/Long%20name%20with%20spaces%20and%20dot.'},
+  #                  {:controller=>"queries", :action=>"edit_sql", :name=>"Long name with spaces and dot."})
+  # end
+  #
+  # def test_update_sql_with_special_characters
+  #   assert_routing({:method => :put, :path => '/update_sql/Long%20name%20with%20spaces%20and%20dot.'},
+  #                  {:controller=>"queries", :action=>"update_sql", :name=>"Long name with spaces and dot."})
+  # end
+
+  def test_columns
+    assert_routing({:method => :get, :path => '/columns/Person'},
+                   {:controller => "queries", :action => 'columns', :klass => 'Person'})
+  end
+
+  def test_list_joinable
+    assert_routing({:method => :get, :path => '/list_joinable/Person'},
+                   {:controller => "queries", :action => 'list_joinable', :klass => 'Person'})
+  end
+
+  def test_join_data
+    assert_routing({:method => :get, :path => '/join_data/Person'},
+                   {:controller => "queries", :action => 'join_data', :klass => 'Person'})
+  end
+
+  def test_filter
+    assert_routing({:method => :get, :path => '/filter'},
+                   {:controller => "queries", :action => 'filter'})
+  end
+
+  def test_remove_filter
+    assert_routing({:method => :get, :path => '/remove_filter'},
+                   {:controller => "queries", :action => 'remove_filter'})
+  end
+
+  def test_sort_condition
+    assert_routing({:method => :get, :path => '/sort_condition'},
+                   {:controller => "queries", :action => 'sort_condition'})
+  end
+
+  def test_new_sql
+    assert_routing({:method => :get, :path => '/new_sql'},
+                   {:controller=>"queries", :action=>"new_sql"})
+  end
+
+  def test_edit_sql
+    assert_routing({:method => :get, :path => '/edit_sql/some_query'},
+                   {:controller=>"queries", :action=>"edit_sql", :name => 'some_query'})
+  end
+
+  def test_update_sql
+    assert_routing({:method => :put, :path => '/update_sql/some_query'},
+                   {:controller=>"queries", :action=>"update_sql", :name => 'some_query'})
+  end
+
+  def test_results_get
+    assert_routing({:method => :get, :path => '/results/some_query'},
+                   {:controller=>"queries", :action=>"results", :name => 'some_query'})
+  end
+
+  def test_results_post
+    assert_routing({:method => :post, :path => '/results/some_query'},
+                   {:controller=>"queries", :action=>"results", :name => 'some_query'})
+  end
+end

data/test/integration/navigation_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class NavigationTest < ActionDispatch::IntegrationTest
+  fixtures :all
+
+  # test "the truth" do
+  #   assert true
+  # end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+
+# Load test data into the database
+
+require File.expand_path("../fixtures/saved_queries.rb",  __FILE__) if ActiveRecord::Base.connection.select_one("SELECT count(id) FROM tutuf_visual_query_metadata")['count'].to_i == 0
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.expand_path("../fixtures", __FILE__)
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+
+  fixtures :all
+end

data/test/unit/metadata_test.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MetadataTest < ActiveSupport::TestCase
+  def test_params_serialize_to_json_without_escaping_utf8
+    Tutuf::VisualQuery::Base.new('sql' => %{SELECT AVG(age) AS "възраст" FROM people}, 'query' => {'name' => "params_serialization"}).save
+    assert_equal %q!{"sql":"SELECT AVG(age) AS \"възраст\" FROM people","query":{"name":"params_serialization"}}!,
+                 ActiveRecord::Base.connection.select_all(%{SELECT params FROM tutuf_visual_query_metadata WHERE name='params_serialization'}).first['params']
+  end
+end

data/test/unit/sql_test.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../test_helper'
+
+class VisualQueryTest < ActiveSupport::TestCase
+  def test_save_valid_sql_query
+    vqb = Tutuf::VisualQuery::Base.new('sql' => "SELECT AVG(age) AS average_age FROM people", 'query' => {'name' => "new raw sql query"})
+    assert vqb.valid?, "Metadata in test not valid - fix the test"
+    assert vqb.save, "Could not save valid raw sql query"
+    assert_equal ["average_age"], ActiveRecord::Base.connection.columns(%("#{Tutuf::VisualQuery::Base.schema}"."new raw sql query")).map(&:name)
+  end
+
+  def test_filters
+    vqb = Tutuf::VisualQuery::Base.find_by_name("raw_sql")
+    assert_equal [], vqb.filters
+  end
+
+  def test_results
+    vqb = Tutuf::VisualQuery::Base.new('sql' => "SELECT AVG(age) AS average_age FROM people", 'query' => {'name' => "new raw sql query"})
+    assert !vqb.to_a.empty?, "Results should not be empty"
+  end
+
+  def test_update_sql_valid_when_original_is_sql
+    vqb = Tutuf::VisualQuery::Base.find_by_name('raw_sql')
+    assert vqb.update_sql('sql' => "SELECT MAX(age) AS max_age FROM people")
+  end
+
+  def test_update_sql_valid_when_original_is_visual
+    vqb = Tutuf::VisualQuery::Base.find_by_name('first')
+    assert vqb.update_sql('sql' => "SELECT MAX(age) AS max_age FROM people")
+  end
+
+  def test_update_sql_invalid
+    vqb = Tutuf::VisualQuery::Base.find_by_name('raw_sql')
+    assert !vqb.update_sql('sql' => "SELECT age FROM")
+    assert !vqb.errors.blank?
+  end
+end

data/test/unit/visual_query_test.rb

@@ -0,0 +1,648 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../test_helper'
+require 'csv'
+
+class VisualQueryTest < ActiveSupport::TestCase
+
+  def test_klasses
+    assert_equal [Account, Address, Category, CompositePk, Customer, Order, Person, Post, Product, ProductIn, ProductOut],
+                 Tutuf::VisualQuery::Base.klasses
+  end
+
+  def test_joinable_relations_belongs_to
+    reflections = Tutuf::VisualQuery::Base.joinable_relations(Order)
+    assert_equal [ActiveRecord::Reflection::AssociationReflection,ActiveRecord::Reflection::AssociationReflection], reflections.collect{|r| r.class}
+    assert_equal [Customer, Customer], reflections.collect{|r| r.klass}
+  end
+
+  def test_joinable_relations_has_many
+    reflection = Tutuf::VisualQuery::Base.joinable_relations(Customer).first
+    assert_equal Order, reflection.klass
+  end
+
+  def test_joinable_relations_has_one
+    reflections = Tutuf::VisualQuery::Base.joinable_relations(Person).select{|r| r.klass == Address}
+    assert !reflections.empty?
+  end
+
+  def test_joinable_relations_has_and_belongs_to_many
+    reflection = Tutuf::VisualQuery::Base.joinable_relations(Post).first
+    assert_equal Category, reflection.klass
+  end
+
+  def test_columns_all_content
+    assert_equal %w(id title body), Tutuf::VisualQuery::Base.columns(Post)
+  end
+
+  def test_columns_not_all_content
+    assert_equal %w(id country city street addressable_type), Tutuf::VisualQuery::Base.columns(Address)
+  end
+
+  def test_columns_with_composite_primary_key
+    assert_equal(%W(first_id second_id name), Tutuf::VisualQuery::Base.columns(CompositePk))
+  end
+
+  def test_join_condition_on_belongs_to
+    assert_equal [[{'rel_name' => 'orders', 'col_name' => 'billing_customer_id'}, {'rel_name' => 'customers', 'col_name' => 'id'}]],
+                 Tutuf::VisualQuery::Base.join_condition(Order.reflect_on_association(:billing_customer))
+    assert_equal [[{'rel_name' => 'orders', 'col_name' => 'shipping_customer_id'}, {'rel_name' => 'customers', 'col_name' => 'id'}]],
+                 Tutuf::VisualQuery::Base.join_condition(Order.reflect_on_association(:shipping_customer))
+  end
+
+  def test_join_condition_on_belongs_to_with_composite_primary_key
+  end
+
+  def test_join_condition_on_has_many
+    assert_equal [[{'rel_name' => 'customers', 'col_name' => 'id'}, {'rel_name' => 'orders', 'col_name' => 'billing_customer_id'}]],
+                 Tutuf::VisualQuery::Base.join_condition(Customer.reflect_on_association(:billing_orders))
+    assert_equal [[{'rel_name' => 'customers', 'col_name' => 'id'}, {'rel_name' => 'orders', 'col_name' => 'shipping_customer_id'}]],
+                 Tutuf::VisualQuery::Base.join_condition(Customer.reflect_on_association(:shipping_orders))
+  end
+
+  def test_join_condition_on_has_many_with_composite_primary_key
+  end
+  def test_join_condition_on_has_many_with_polymorphic_association
+  end
+  def test_join_condition_on_has_many_with_polymorphic_association_and_with_composite_primary_key
+  end
+
+  def test_join_condition_on_has_one
+    assert_equal [[{'rel_name' => 'people', 'col_name' => 'id'}, {'rel_name' => 'accounts', 'col_name' => 'person_id'}]],
+                 Tutuf::VisualQuery::Base.join_condition(Person.reflect_on_association(:account))
+  end
+
+  def test_join_condition_on_has_one_with_composite_primary_key
+  end
+
+  def test_join_condition_on_has_one_with_polymorphic_association
+  end
+
+  def test_join_condition_on_has_one_with_polymorphic_association_and_with_composite_primary_key
+  end
+
+  def test_join_condition_on_has_and_belongs_to_many
+    assert_equal [[{'rel_name' => 'posts', 'col_name' => 'id'}, {'rel_name' => 'categories_posts', 'col_name' => 'post_id'}],
+                  [{'rel_name' => 'categories_posts', 'col_name' => 'category_id'}, {'rel_name' => 'categories', 'col_name' => 'id'}]],
+                 Tutuf::VisualQuery::Base.join_condition(Post.reflect_on_association(:categories))
+  end
+
+  def test_join_condition_on_has_and_belongs_to_many_with_composite_primary_key
+  end
+
+  def test_join_condition_on_has_and_belongs_to_many_with_polymorphic_association
+  end
+
+  def test_join_condition_on_has_and_belongs_to_many_with_polymorphic_association_and_with_composite_primary_key
+  end
+
+  def test_results_one_relation
+    cols = [{'rel_name' => "people", 'col_name' => "id"},
+            {'rel_name' => "people", 'col_name' => "name"},
+            {'rel_name' => "people", 'col_name' => "age"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}]}).to_a
+    person = people(:john)
+    assert results.include?([person.id.to_s, person.name, person.age.to_s])
+  end
+
+  def test_results_two_relations_has_one
+    cols = [{'rel_name' => "people", 'col_name' => "id"},
+            {'rel_name' => "people", 'col_name' => "name"},
+            {'rel_name' => "people", 'col_name' => "age"},
+            {'rel_name' => "accounts", 'col_name' => "id"},
+            {'rel_name' => "accounts", 'col_name' => "name"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}, {'rel_name' => "accounts"}],
+                                            'join_conditions' =>[{'left_rel_name' => "accounts",
+                                                                 'left_col_name' => "person_id",
+                                                                 'right_rel_name' => "people",
+                                                                 'right_col_name' => "id"}]}).to_a
+    person = people(:john)
+    account = accounts(:john)
+    assert_equal [person.id.to_s, person.name, person.age.to_s, account.id.to_s, account.name], results[0]
+  end
+
+  def test_results_two_relations_has_and_belongs_to_many
+    cols = [{'rel_name' => "posts", 'col_name' => "title"},
+            {'rel_name' => "categories", 'col_name' => "name"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "posts"},
+                                                           {'rel_name' => "categories"},
+                                                           {'rel_name' => "categories_posts"}],
+                                            'join_conditions' => [{'left_rel_name' => "posts",
+                                                                  'left_col_name' => "id",
+                                                                  'right_rel_name' => "categories_posts",
+                                                                  'right_col_name' => "post_id"},
+                                                                 {'left_rel_name' => "categories_posts",
+                                                                  'left_col_name' => "category_id",
+                                                                  'right_rel_name' => "categories",
+                                                                  'right_col_name' => "id"}]}).to_a
+   category = categories(:first)
+   post = posts(:first)
+   assert_equal [post.title, category.name], results[0]
+  end
+
+  def test_results_two_relations_has_and_belongs_to_many_join_type_full
+    cols = [{'rel_name' => "posts", 'col_name' => "title"},
+            {'rel_name' => "categories", 'col_name' => "name"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "posts"},
+                                                           {'rel_name' => "categories"},
+                                                           {'rel_name' => "categories_posts"}],
+                                            'join_conditions' => [{'left_rel_name' => "posts",
+                                                                  'left_col_name' => "id",
+                                                                  'right_rel_name' => "categories_posts",
+                                                                  'right_col_name' => "post_id",
+                                                                  'type'   => "FULL"},
+                                                                 {'left_rel_name' => "categories_posts",
+                                                                  'left_col_name' => "category_id",
+                                                                  'right_rel_name' => "categories",
+                                                                  'right_col_name' => "id"}]}).to_a
+   category = categories(:first)
+   post = posts(:first)
+   assert_equal [post.title, category.name], results[0]
+  end
+
+  def test_results_two_relations_has_and_belongs_to_many_join_type_invalid
+    cols = [{'rel_name' => "posts", 'col_name' => "title"},
+            {'rel_name' => "categories", 'col_name' => "name"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "posts"},
+                                                           {'rel_name' => "categories"},
+                                                           {'rel_name' => "categories_posts"}],
+                                            'join_conditions' => [{'left_rel_name' => "posts",
+                                                                  'left_col_name' => "id",
+                                                                  'right_rel_name' => "categories_posts",
+                                                                  'right_col_name' => "post_id",
+                                                                  'type'   => "NO SUCH"},
+                                                                 {'left_rel_name' => "categories_posts",
+                                                                  'left_col_name' => "category_id",
+                                                                  'right_rel_name' => "categories",
+                                                                  'right_col_name' => "id"}]}).to_a
+   category = categories(:first)
+   post = posts(:first)
+   assert_equal [post.title, category.name], results[0]
+  end
+
+  def test_results_one_relation_with_filter
+    cols = [{'rel_name' => "people", 'col_name' => "name"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}],
+                                            'filters' => [{'schema'   => "public",
+                                                          'rel_name' => "people",
+                                                          'col_name' => "id",
+                                                          'op' => "=",
+                                                          'val' => people(:john).id}]}).to_a
+    assert_equal [[people(:john).name]], results
+  end
+
+  def test_results_with_hidden_columns
+    cols = [{'rel_name' => "people", 'col_name' => "name"},
+            {'rel_name' => "people", 'col_name' => "age"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => [{'rel_name' => "people", 'col_name' => "id"}] + cols,
+                                            'relations' => [{'rel_name' => "people"}]}).to_a
+    person = people(:john)
+    assert results.include?([nil, person.name, person.age.to_s])
+  end
+
+  def test_results_balanced_query
+    cols = [{'rel_name' => "products", 'col_name' => "name"},
+            {'rel_name' => "product_ins", 'col_name' => "quantity"},
+            {'rel_name' => "product_outs", 'col_name' => "quantity"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'row' => 0, 'rel_name' => 'products'}, {'row' => 0, 'rel_name' => 'product_ins'},
+                                                           {'row' => 1, 'rel_name' => 'products'}, {'row' => 1, 'rel_name' => 'product_outs'}],
+                                            'join_conditions' =>[{'left_rel_name'  => "products",     'left_col_name' => "id",
+                                                                 'right_rel_name' => "product_ins", 'right_col_name' => "product_id",
+                                                                 'row' => 0},
+                                                                {'left_rel_name'  => "products",     'left_col_name' => "id",
+                                                                 'right_rel_name' => "product_outs", 'right_col_name' => "product_id",
+                                                                 'row' => 1}],
+                                            'rows' => [0, 1]
+                                           }).to_a
+    assert results.include?([products(:pencil).name, product_ins(:red_pencil).quantity.to_s, nil])
+    assert results.include?([products(:pencil).name, nil, product_outs(:red_pencil).quantity.to_s])
+  end
+
+  def test_results_balanced_query_with_hidden_columns
+
+  end
+
+  def query_for_results
+    cols = [{'rel_name' => "people", 'col_name' => "name", 'save_name' => "name"},
+            {'rel_name' => "people", 'col_name' => "age", 'save_name' => "age"}]
+    query = Tutuf::VisualQuery::Base.new('columns' => cols,
+                                         'all_columns' => cols,
+                                         'relations' => [{'rel_name'=>"people", 'row' => 0}],
+                                         'rows' => [0],
+                                         'query' => {'name' => "query for results"},
+                                         'action' => "create")
+     query.save
+     query
+  end
+
+  def test_results_saved_query
+    assert_equal [["John Atanasoff", "34"], ["Джон Атанасов", "34"]],
+                  query_for_results.to_a
+  end
+
+  def test_to_csv
+    assert_equal "name,age\nJohn Atanasoff,34\nДжон Атанасов,34\n",
+                 query_for_results.to_csv
+  end
+
+  def test_to_json_without_escaping
+    assert_equal %q([{"name":"John Atanasoff","age":"34"},{"name":"Джон Атанасов","age":"34"}]),
+                 query_for_results.to_json
+  end
+
+  def test_sort_no_direction
+    cols = [{'rel_name' => "people", 'col_name' => "id"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}],
+                                            'sort_conditions' => {"0"=> cols[0]}}).to_a
+    assert_equal [["1"], ["2"]], results[0..1]
+  end
+
+  def test_sort_ascending
+    cols = [{'rel_name' => "people", 'col_name' => "id"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}],
+                                            'sort_conditions' => {"0" => cols[0].merge('direction' => 'ASC')}}).to_a
+    assert_equal [["1"], ["2"]], results[0..1]
+  end
+
+  def test_sort_descending
+    cols = [{'rel_name' => "people", 'col_name' => "id"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}],
+                                            'sort_conditions' => {"0" => cols[0].merge('direction' => 'DESC')}}).to_a
+    assert_equal [["2"], ["1"]], [results[-2], results[-1]]
+  end
+
+  def test_sort_with_empty_condition
+    cols = [{'rel_name' => "people", 'col_name' => "id"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'rel_name' => "people"}],
+                                            'sort_conditions' => {"0"=> cols[0],
+                                                                 "1"=>{'rel_name' => "", 'col_name' => ""}}}).to_a
+    assert_equal [["1"], ["2"]], results[0..1]
+  end
+
+  def test_sort_sql_injection_in_relation_name
+
+  end
+
+  def test_sort_sql_injection_in_column_name
+
+  end
+
+  def test_sort_sql_injection_in_direction
+
+  end
+
+  def test_sort_balanced_query
+    cols = [{'rel_name' => "products", 'col_name' => "id"},
+            {'rel_name' => "product_ins", 'col_name' => "buy_price"},
+            {'rel_name' => "product_outs", 'col_name' => "sale_price"}]
+    results = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                            'all_columns' => cols,
+                                            'relations' => [{'row' => 0, 'rel_name' => 'products'}, {'row' => 0, "rel_name" => 'product_ins'},
+                                                           {'row' => 1, 'rel_name' => 'products'}, {'row' => 1, 'rel_name' => 'product_outs'}],
+                                            'join_conditions' =>[{'left_rel_name'  => "products",    'left_col_name' => "id",
+                                                                 'right_rel_name' => "product_ins", 'right_col_name' => "product_id",
+                                                                 'row' => 0},
+                                                                {'left_rel_name'  => "products",     'left_col_name' => "id",
+                                                                 'right_rel_name' => "product_outs", 'right_col_name' => "product_id",
+                                                                 'row' => 1}],
+                                            'sort_conditions' => {"0" => {'rel_name' => "products",    'col_name' => "id"},
+                                                                 "1" => {'rel_name' => "product_ins", 'col_name' => "id"}},
+                                            'rows' => [0, 1]
+                                           }).to_a
+    assert_equal [ [products(:pencil).id.to_s, product_ins(:red_pencil).buy_price.to_s,    nil],
+                   [products(:pencil).id.to_s, product_ins(:blue_pencil).buy_price.to_s,   nil],
+                   [products(:bottle).id.to_s, product_ins(:bottle_700_ml).buy_price.to_s, nil],
+                   [products(:pencil).id.to_s, nil,                                        product_outs(:red_pencil).sale_price.to_s ]],
+                  results[0..3]
+  end
+
+  def test_parsed_filters_with_empty_condition
+    assert_equal %("schema"."relation"."column" >= '2008-06-01'),
+                 Tutuf::VisualQuery::Single.new({'filters' => [ { 'schema'   => "schema",
+                                                                 'rel_name' => "relation",
+                                                                 'col_name' => "column",
+                                                                 'op' => "<=",
+                                                                 'val' => ""},
+                                                               { 'schema'   => "schema",
+                                                                 'rel_name' => "relation",
+                                                                 'col_name' => "column",
+                                                                 'op' => ">=",
+                                                                 'val' => "2008-06-01"}]}).parsed_filters
+  end
+
+  def test_parsed_filters_with_all_nonempty_conditions
+    assert_equal %("schema"."relation"."column" <= '2008-07-01' AND "schema"."relation"."column" >= '2008-06-01'),
+                 Tutuf::VisualQuery::Single.new({'filters' => [{'schema' => "schema",
+                                                               'rel_name' => "relation",
+                                                               'col_name' => "column",
+                                                               'op' => "<=",
+                                                               'val' => "2008-07-01"},
+                                                              {'schema' => "schema",
+                                                               'rel_name' => "relation",
+                                                               'col_name' => "column",
+                                                               'op' => ">=",
+                                                               'val' => "2008-06-01"}]}).parsed_filters
+  end
+
+  def test_sql_injection_in_columns_semicolon
+    cols = [{'col_name' => %q(name; DELETE FROM schema_info;), 'rel_name' => "people"}]
+    vqb = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                        'all_columns' => cols,
+                                        'relations' => ['rel_name' => "people"]})
+    assert_equal 'SELECT "people"."name; DELETE FROM schema_info;" FROM "people"', vqb.query
+    assert_raise(ActiveRecord::StatementInvalid){vqb.to_a}
+  end
+
+  def test_sql_injection_in_columns_semicolon_and_double_quote
+    cols = [{'col_name' => %q(name"; DELETE FROM schema_info;), 'rel_name' => "people"}]
+    vqb = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                        'all_columns' => cols,
+                                        'relations' => ['rel_name' => "people"]})
+    assert_equal 'SELECT "people"."name""; DELETE FROM schema_info;" FROM "people"', vqb.query
+    assert_raise(ActiveRecord::StatementInvalid){vqb.to_a}
+  end
+
+  def test_sql_injection_in_columns_semicolon_and_backslashed_double_quote
+    cols = [{'col_name' => %q(name\"; DELETE FROM schema_info;), 'rel_name' => "people"}]
+    vqb = Tutuf::VisualQuery::Base.new({'columns' => cols,
+                                        'all_columns' => cols,
+                                        'relations' => ['rel_name' => "people"]})
+    assert_equal 'SELECT "people"."name\\""; DELETE FROM schema_info;" FROM "people"', vqb.query
+    assert_raise(ActiveRecord::StatementInvalid){vqb.to_a}
+  end
+
+  def test_sql_injection_in_relations_semicolon
+    vqb = Tutuf::VisualQuery::Base.new({'relations' => ['rel_name' => %q(people; DELETE FROM schema_info;)]})
+    assert_equal 'SELECT  FROM "people; DELETE FROM schema_info;"', vqb.query
+    assert_raise(ActiveRecord::StatementInvalid){vqb.to_a}
+  end
+
+  def test_sql_injection_in_relations_semicolon_and_double_quote
+    vqb = Tutuf::VisualQuery::Base.new({'relations' => ['rel_name' => %q(people"; DELETE FROM schema_info;)]})
+    assert_equal 'SELECT  FROM "people""; DELETE FROM schema_info;"', vqb.query
+    assert_raise(ActiveRecord::StatementInvalid){vqb.to_a}
+  end
+
+  def test_sql_injection_in_relations_semicolon_and_backslashed_double_quote
+    vqb = Tutuf::VisualQuery::Base.new({'relations' => ['rel_name' => %q(people\"; DELETE FROM schema_info;)]})
+    assert_equal 'SELECT  FROM "people\\""; DELETE FROM schema_info;"', vqb.query
+    assert_raise(ActiveRecord::StatementInvalid){vqb.to_a}
+  end
+
+  def test_sql_injection_in_join_conditions
+
+  end
+
+  def test_sql_injection_in_filters_schema
+
+  end
+
+  def test_sql_injection_in_filters_relation
+
+  end
+
+  def test_sql_injection_in_filters_column
+
+  end
+
+  def test_sql_injection_in_filters_operator
+
+  end
+
+  def test_sql_injection_in_filters_value
+
+  end
+
+  def test_columns_all_selected
+    assert_equal %q("rel"."col1","rel"."col2"),
+                 Tutuf::VisualQuery::Single.new('columns'     => [{'rel_name' => "rel", 'col_name'=>"col1"}, {'rel_name' => "rel", 'col_name'=>"col2"}],
+                                                'all_columns' => [{'rel_name' => "rel", 'col_name'=>"col1"}, {'rel_name' => "rel", 'col_name'=>"col2"}]).parsed_columns
+  end
+
+  def test_columns_not_all_selected
+    assert_equal %q("rel"."col1",NULL),
+                 Tutuf::VisualQuery::Single.new('columns'     => [{'rel_name' => "rel", 'col_name'=>"col1"}],
+                                                'all_columns' => [{'rel_name' => "rel", 'col_name'=>"col1"}, {'rel_name' => "rel", 'col_name'=>"col2"}]).parsed_columns
+  end
+
+  def test_columns_for_saving_selected_not_empty
+    assert_equal %q("rel"."col1" AS "rel:col1"),
+                 Tutuf::VisualQuery::Single.new('columns'     => [{'rel_name' => "rel", 'col_name'=>"col1", 'save_name' => "rel:col1"}],
+                                                'all_columns' => [{'rel_name' => "rel", 'col_name'=>"col1"}, {'rel_name' => "rel", 'col_name'=>"col2"}],
+                                                'action' => "create").parsed_columns
+  end
+
+  def test_columns_for_saving_selected_empty
+    assert_nil Tutuf::VisualQuery::Single.new('action' => "create").parsed_columns
+    assert_nil Tutuf::VisualQuery::Single.new('columns' => [], 'action' => "create").parsed_columns
+  end
+
+  def test_validate_name_cannot_be_empty_string
+    vqb = Tutuf::VisualQuery::Base.new('query' => {'name' => ""})
+    assert !vqb.valid?
+    assert vqb.errors[:name].any?
+  end
+
+  def test_validate_name_cannot_be_nil
+    vqb = Tutuf::VisualQuery::Base.new({})
+    assert !vqb.valid?
+    assert vqb.errors[:name].any?
+  end
+
+  def test_validate_name_cannot_be_more_than_63_chars
+    vqb = Tutuf::VisualQuery::Base.new('query' => {'name' => "z"*64})
+    assert !vqb.valid?
+    assert vqb.errors[:name].any?
+  end
+
+  def test_validate_name_must_be_unique
+    vqb = Tutuf::VisualQuery::Base.new('query' => {'name' => "first"})
+    assert !vqb.valid?
+    assert vqb.errors[:name].any?, "No errors when name is not unique"
+  end
+
+  def test_name_on_new
+    assert_equal "new query", Tutuf::VisualQuery::Base.new('query' => {'name' => "new query"}).name
+  end
+
+  def test_name_on_loading_from_db
+    assert_equal("first", Tutuf::VisualQuery::Base.find_by_name("first").name)
+  end
+
+  def test_is_new_on_new_object
+    assert Tutuf::VisualQuery::Base.new('query' => {'name' => "new query"}).new?
+  end
+
+  def test_is_new_on_existing_object
+    assert !Tutuf::VisualQuery::Base.find_by_name("first").new?
+  end
+
+  def test_save_valid_visual_query
+    vqb = Tutuf::VisualQuery::Base.new('columns' => [{'rel_name' => "addresses", 'col_name' => "country", 'save_name' => "cntr"}],
+                                       'relations' => [{'rel_name' => "addresses"}],
+                                       'action' => "create",
+                                       'query' => {'name' => "new query"})
+    assert vqb.valid?, "Metadata in test not valid - fix the test"
+    assert vqb.save, "Could not save valid query"
+    assert_equal ["cntr"], ActiveRecord::Base.connection.columns(%("#{Tutuf::VisualQuery::Base.schema}"."new query")).map(&:name)
+  end
+
+  def test_save_invalid_metadata_and_valid_sql_generated
+    vqb = Tutuf::VisualQuery::Base.new('relations' => ["people"])
+    assert !vqb.valid?, "Metadata in test valid - fix the test"
+    assert !vqb.save, "Saved although metadata is invalid"
+  end
+
+  def test_save_invalid_metadata_and_invalid_sql_generated
+    metadata_count = Tutuf::VisualQuery::Metadata.count
+    vqb = Tutuf::VisualQuery::Base.new('query' => {'name' => "new query"})
+    assert vqb.valid?, "Metadata in test not valid - fix the test"
+    assert_raises(ActiveRecord::StatementInvalid){vqb.save}
+    assert_equal metadata_count, Tutuf::VisualQuery::Metadata.count, "Metadata saved when query view not saved"
+  end
+
+  def test_save_balanced_query
+
+  end
+
+  def test_find_by_name_existing
+    assert Tutuf::VisualQuery::Base.find_by_name("first")
+  end
+
+  def test_find_by_name_not_existing
+    assert_nil Tutuf::VisualQuery::Base.find_by_name("new query")
+  end
+
+  def test_find_all
+    all_queries = Tutuf::VisualQuery::Base.find_all
+    assert_equal Tutuf::VisualQuery::Metadata.count, all_queries.size, "Number of queries found differs from number of saved metadata"
+  end
+
+  def test_columns_with_name_of_existing_query
+    columns = Tutuf::VisualQuery::Base.find_by_name("first").columns
+    assert_equal "first", columns.first['rel_name']
+    assert_equal "first", columns.first['rel_name']
+    assert_equal "people:age", columns.first['col_name']
+    assert_equal "people:age", columns.first['col_name']
+  end
+
+  def test_columns_with_name_of_nonexisting_query
+    vqb = Tutuf::VisualQuery::Base.new('query' => {'name' => "non existing"})
+    assert vqb.name
+    assert_raises(ActiveRecord::StatementInvalid){vqb.columns}
+  end
+
+  def test_columns_without_query_name
+    assert_nil Tutuf::VisualQuery::Base.new({}).columns
+  end
+
+  def test_schema
+    assert_equal(Tutuf::VisualQuery::Base.new({}).schema, Tutuf::VisualQuery::Base.schema)
+  end
+
+  def test_data_type_existing_column
+    assert_equal(:date, Tutuf::VisualQuery::Base.data_type('rel_name' => "customers", 'col_name' => "created_at"))
+  end
+
+  def test_data_type_exisitng_relation_nonexisting_column
+    assert_nil Tutuf::VisualQuery::Base.data_type('rel_name' => "people", 'col_name' => "non existing")
+  end
+
+  def test_data_type_nonexisitng_relation_nonexisting_column
+    assert_raise(ActiveRecord::StatementInvalid){Tutuf::VisualQuery::Base.data_type('rel_name' => "non existing", 'col_name' => "non existing")}
+  end
+
+  def test_quote_relation_name_with_schema
+    assert_equal(%q("schema"."relation"), Tutuf::VisualQuery::Base.quote_relation_name('schema' => "schema", 'rel_name' => "relation"))
+  end
+
+  def test_quote_relation_name_with_schema_nil
+    assert_equal(%q("relation"), Tutuf::VisualQuery::Base.quote_relation_name('rel_name' => "relation"))
+  end
+
+  def test_quote_relation_name_with_schema_empty
+    assert_equal(%q("relation"), Tutuf::VisualQuery::Base.quote_relation_name('schema' => "", 'rel_name' => "relation"))
+  end
+
+  def test_join_relations_has_and_belongs_to_many
+    assert_equal(["categories_posts", "categories"], Tutuf::VisualQuery::Base.join_relations(Post.reflect_on_association(:categories)))
+  end
+
+  def test_join_relations_has_many
+    assert_equal(["orders"], Tutuf::VisualQuery::Base.join_relations(Customer.reflect_on_association(:billing_orders)))
+  end
+
+  def test_join_relations_has_one
+     assert_equal(["accounts"], Tutuf::VisualQuery::Base.join_relations(Person.reflect_on_association(:account)))
+  end
+
+  def test_join_relations_belongs_to
+    assert_equal(["people"], Tutuf::VisualQuery::Base.join_relations(Account.reflect_on_association(:person)))
+  end
+
+  def test_large_result_set_really_large
+    vqb = Tutuf::VisualQuery::Base.new({})
+    vqb.instance_variable_set("@results", (1..vqb.max_result_length).map{|i| [1] } << [1] )
+    assert vqb.large_result_set?
+  end
+
+  def test_large_result_set_not_really_large
+    vqb = Tutuf::VisualQuery::Base.new({})
+    vqb.instance_variable_set("@results", (1..(vqb.max_result_length - 1)).map{|i| [1] })
+    assert !vqb.large_result_set?
+  end
+
+  def test_large_result_set_nil_results
+    vqb = Tutuf::VisualQuery::Base.new({})
+    assert !vqb.large_result_set?
+  end
+
+  def test_large_result_set_empty_results
+    vqb = Tutuf::VisualQuery::Base.new({})
+    vqb.instance_variable_set("@results", [])
+    assert !vqb.large_result_set?
+  end
+
+  def test_destroy
+    metadata_count = Tutuf::VisualQuery::Metadata.count
+    vqb = Tutuf::VisualQuery::Base.find_by_name("first")
+    assert vqb.destroy
+    assert_equal(metadata_count - 1, Tutuf::VisualQuery::Metadata.count)
+    assert_nil ActiveRecord::Base.connection.select_one("SELECT 1 FROM information_schema.views WHERE table_name='first' AND table_schema='#{Tutuf::VisualQuery::Base.schema}';")
+  end
+
+  def test_disable
+    metadata_count = Tutuf::VisualQuery::Metadata.count
+    Tutuf::VisualQuery::Base.disable
+    assert_equal metadata_count, Tutuf::VisualQuery::Metadata.count
+    assert_nil ActiveRecord::Base.connection.select_one("SELECT 1 FROM information_schema.views WHERE table_schema='#{Tutuf::VisualQuery::Base.schema}'")
+  end
+
+  def test_enable
+    Tutuf::VisualQuery::Base.disable
+    Tutuf::VisualQuery::Base.enable
+    assert ActiveRecord::Base.connection.select_one("SELECT 1 FROM information_schema.views WHERE table_name='first' AND table_schema='#{Tutuf::VisualQuery::Base.schema}';")
+  end
+end