babik 0.1.0

data/test/config/models/post_tag.rb

@@ -0,0 +1,5 @@
+
+class PostTag < ActiveRecord::Base
+  belongs_to :post, inverse_of: :post_tags
+  belongs_to :tag, inverse_of: :post_tags
+end

data/test/config/models/tag.rb

@@ -0,0 +1,5 @@
+
+class Tag < ActiveRecord::Base
+  has_many :post_tags
+  has_many :posts, through: :post_tags, inverse_of: :tags
+end

data/test/config/models/user.rb

@@ -0,0 +1,6 @@
+
+class User < ActiveRecord::Base
+  belongs_to :zone, foreign_key: 'zone_id', class_name: 'GeoZone', optional: true, inverse_of: :users
+  has_many :posts, foreign_key: 'author_id', class_name: 'Post', inverse_of: :author
+  has_many :groups, through: :group_users, inverse_of: :users
+end

data/test/delete/delete_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Abstract class for Tests of delete method
+class DeleteTest < Minitest::Test
+
+  def setup
+    war_tag = Tag.create!(name: 'war')
+    tribes_tag = Tag.create!(name: 'tribes')
+    gallic_tag = Tag.create!(name: 'gallic')
+    victory_tag = Tag.create!(name: 'victory')
+    campaign_tag = Tag.create!(name: 'campaign')
+    book_tag = Tag.create!(name: 'book')
+    last_book_tag = Tag.create!(name: 'last_book')
+
+    @caesar = User.create!(first_name: 'Julius', last_name: 'Caesar', email: 'backstabbed@example.com')
+    (1..7).each do |book_i|
+      post = Post.create!(title: "Commentarii de Bello Gallico #{book_i}", author: @caesar, stars: [book_i, 5].min)
+      post.add_tag(war_tag)
+      post.add_tag(gallic_tag)
+      post.add_tag(tribes_tag)
+      post.add_tag(victory_tag)
+      post.add_tag(book_tag)
+      post.add_tag(campaign_tag)
+    end
+
+    @aulus = User.create!(first_name: 'Aulus', last_name: 'Hirtius', email: 'aulushirtius@example.com')
+    last_post = Post.create!(title: 'Commentarii de Bello Gallico 8', author: @aulus)
+    last_post.add_tag(war_tag)
+    last_post.add_tag(book_tag)
+    last_post.add_tag(last_book_tag)
+  end
+
+  def teardown
+    Tag.destroy_all
+    Post.destroy_all
+    User.destroy_all
+  end
+
+  def test_delete_by_local_selection
+    User.objects.filter(first_name: 'Julius').delete
+    assert_nil User.objects.filter(first_name: 'Julius').first
+    assert_equal User.all.count, User.objects.count
+  end
+
+  def test_delete_by_foreign_selection
+    Post.objects.filter('author::first_name': 'Julius', title: 'Commentarii de Bello Gallico 2').delete
+    assert_nil Post.objects.filter('author::first_name': 'Julius', title: 'Commentarii de Bello Gallico 2').first
+    assert_equal 6, @caesar.objects(:posts).count
+  end
+
+  def test_delete_by_instance_foreign_selection
+    @caesar.objects(:posts).filter(title: 'Commentarii de Bello Gallico 2').delete
+    assert_nil @caesar.objects(:posts).filter(title: 'Commentarii de Bello Gallico 2').first
+    assert_equal 6, @caesar.objects(:posts).count
+  end
+
+end

data/test/delete/foreign_conditions_delete_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+require_relative 'delete_test'
+
+# Tests of delete with foreign conditions method
+class ForeignConditionsDeleteTest < DeleteTest
+
+  def test_delete_from_model
+    Post.objects.filter('author::first_name': 'Aulus').delete
+    assert_equal 0, Post.objects.filter('author::first_name': 'Aulus').count
+    assert_equal false, Post.objects.filter('author::first_name': 'Aulus').exists?
+    assert_equal 0, @aulus.objects(:posts).count
+    assert_equal false, @aulus.objects(:posts).exists?
+  end
+
+  def test_delete_from_instance
+    @aulus.objects(:posts).delete
+    assert_equal 0, Post.objects.filter('author::first_name': 'Aulus').count
+    assert_equal false, Post.objects.filter('author::first_name': 'Aulus').exists?
+    assert_equal 0, @aulus.objects(:posts).count
+    assert_equal false, @aulus.objects(:posts).exists?
+  end
+
+  def test_delete_from_model_deep_conditions
+    Tag.objects.filter('posts::author::first_name': 'Aulus').delete
+    assert_equal 0, Tag.objects.filter('posts::author::first_name': 'Aulus').count
+    assert_equal false, Tag.objects.filter('posts::author::first_name': 'Aulus').exists?
+    assert_equal 0, @aulus.objects('posts::tags').count
+    assert_equal false, @aulus.objects('posts::tags').exists?
+  end
+
+  def test_delete_from_instance_deep_condition_not_matched
+    @aulus.objects('posts::tags').filter(name: 'not existing tag').delete
+    assert_equal 3, Tag.objects.filter('posts::author::first_name': 'Aulus').count
+    assert_equal true, Tag.objects.filter('posts::author::first_name': 'Aulus').exists?
+    assert_equal 3, @aulus.objects('posts::tags').count
+    assert_equal true, @aulus.objects('posts::tags').exists?
+  end
+
+  def test_delete_from_instance_deep_conditions
+    tag_to_delete = 'last_book'
+    @aulus.objects('posts::tags').filter(name: tag_to_delete).delete
+    assert_equal 2, Tag.objects.filter('posts::author::first_name': 'Aulus').count
+    assert_equal true, Tag.objects.filter('posts::author::first_name': 'Aulus').exists?
+    Tag.objects.filter('posts::author::first_name': 'Aulus').each do |aulus_tag|
+      refute_equal tag_to_delete, aulus_tag.name
+    end
+    assert_equal 2, @aulus.objects('posts::tags').count
+    assert_equal true, @aulus.objects('posts::tags').exists?
+    @aulus.objects('posts::tags').each do |aulus_tag|
+      refute_equal tag_to_delete, aulus_tag.name
+    end
+  end
+
+end

data/test/delete/local_conditions_delete_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+require_relative 'delete_test'
+
+# Tests of delete with local conditions method
+class LocalConditionsDeleteTest < DeleteTest
+
+  def test_deletion_from_model
+    User.objects.filter(first_name: 'Aulus').delete
+    assert_operator 0, :<, User.objects.count
+    User.objects.each do |user|
+      refute_equal 'Aulus', user.first_name
+    end
+    assert_equal 0, User.objects.filter(first_name: 'Aulus').count
+    assert_equal false, User.objects.filter(first_name: 'Aulus').exists?
+  end
+
+end

data/test/enable_coverage.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+require 'simplecov-console'
+
+SimpleCov.formatter = SimpleCov.formatter = SimpleCov::Formatter::Console
+SimpleCov.start do
+  add_filter '/doc/'
+  add_filter '/test/'
+  add_filter '/features/'
+  add_filter '/spec/'
+  add_filter '/autotest/'
+  add_group 'Binaries', '/bin/'
+  add_group 'Libraries', '/lib/'
+  add_group 'Extensions', '/ext/'
+  add_group 'Vendor Libraries', '/vendor/'
+end

data/test/lib/selection/operation/log/test-queries.log

@@ -0,0 +1 @@
+# Logfile created on 2018-08-03 20:29:14 +0200 by logger.rb/61378

data/test/lib/selection/operation/test_date.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../../../test/test_helper'
+
+# Class for testing date lookups
+class DateLookupTest < Minitest::Test
+
+  def test_abstract_date_operation
+    assert_raises NotImplementedError do
+      Babik::Selection::Operation::DateOperation.new('my_field', 'equal', 'my_value')
+    end
+  end
+
+  def test_year_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'YEAR(#field)',
+      postgresql: 'EXTRACT(YEAR FROM #field)',
+      sqlite3: 'strftime(\'%Y\', #field)'
+    }
+    _test_date_operation('Year', sql_by_db_adapter)
+  end
+
+  def test_quarter_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'QUARTER(#field)',
+      postgresql: 'EXTRACT(QUARTER FROM #field)',
+      sqlite3: '(CAST(strftime(\'%m\', #field) AS INTEGER) + 2) / 3'
+    }
+    _test_date_operation('Quarter', sql_by_db_adapter)
+  end
+
+  def test_month_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'MONTH(#field)',
+      postgresql: 'EXTRACT(MONTH FROM #field)',
+      sqlite3: 'strftime(\'%m\', #field)'
+    }
+    _test_date_operation('Month', sql_by_db_adapter)
+  end
+
+  def test_day_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'DAYOFMONTH(#field)',
+      postgresql: 'EXTRACT(DAY FROM #field)',
+      sqlite3: 'strftime(\'%d\', #field)'
+    }
+    _test_date_operation('Day', sql_by_db_adapter)
+  end
+
+  def test_weekday_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'DAYOFWEEK(#field) -  1',
+      postgresql: 'EXTRACT(DOW FROM #field)',
+      sqlite3: 'strftime(\'%w\', #field)'
+    }
+    _test_date_operation('WeekDay', sql_by_db_adapter)
+  end
+
+  def test_week_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'WEEK(#field, 3)',
+      postgresql: 'EXTRACT(WEEK FROM #field)',
+      sqlite3: '(strftime(\'%j\', date(#field, \'-3 days\', \'weekday 4\')) - 1) / 7 + 1'
+    }
+    _test_date_operation('Week', sql_by_db_adapter)
+  end
+
+  def test_hour_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'HOUR(#field)',
+      postgresql: 'EXTRACT(HOUR FROM #field)',
+      sqlite3: 'CAST(strftime(\'%H\', #field) AS INTEGER)'
+    }
+    _test_date_operation('Hour', sql_by_db_adapter)
+  end
+
+  def test_minute_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'MINUTE(#field)',
+      postgresql: 'EXTRACT(MINUTE FROM #field)',
+      sqlite3: 'CAST(strftime(\'%M\', #field) AS INTEGER)'
+    }
+    _test_date_operation('Minute', sql_by_db_adapter)
+  end
+
+  def test_second_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'SECOND(#field)',
+      postgresql: 'FLOOR(EXTRACT(SECOND FROM #field))',
+      sqlite3: 'CAST(strftime(\'%S\', #field) AS INTEGER)'
+    }
+    _test_date_operation('Second', sql_by_db_adapter)
+  end
+
+  def test_time_date_operation
+    sql_by_db_adapter = {
+      mysql2: 'DATE_FORMAT(#field, \'%H:%i:%s\')',
+      postgresql: 'date_trunc(\'second\', #field::time)',
+      sqlite3: 'strftime(\'%H:%M:%S\', #field)'
+    }
+    _test_date_operation('Time', sql_by_db_adapter)
+  end
+
+  def _test_date_operation(date_operation_name, sql_by_adapter, unimplemented_db_adapters = %w[mssql, oracle])
+    date_operation_class = Object.const_get("Babik::Selection::Operation::#{date_operation_name.camelize}")
+    _test_date_operation_sql(date_operation_class, sql_by_adapter)
+    _test_date_operation_not_implemented(date_operation_class, unimplemented_db_adapters)
+  end
+
+  def _test_date_operation_sql(klass, date_operation_sql_by_db_adapter)
+    date_operation = klass.new('my_field', 'equal', 6)
+    date_operation_sql_by_db_adapter.each do |db_adapter, date_operation_sql|
+      date_operation.stub :db_engine, -> { db_adapter.to_s } do
+        assert_equal date_operation_sql, date_operation.sql_function
+      end
+    end
+  end
+
+  def _test_date_operation_not_implemented(klass, unimplemented_db_adapters)
+    date_operation = klass.new('my_field', 'equal', 6)
+    unimplemented_db_adapters.each do |unimplemented_db_adapter|
+      date_operation.stub :db_engine, -> { unimplemented_db_adapter.to_s } do
+        assert_raises NotImplementedError do
+          date_operation.sql_function
+        end
+      end
+    end
+  end
+
+end

data/test/lib/selection/operation/test_regex.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../../../test/test_helper'
+
+# Class for testing regex lookups
+class RegexLookupTest < Minitest::Test
+
+  def test_regex_operator
+    sql_by_db_adapter = {
+      mysql2: { operator: 'REGEXP', operation: 'my_field REGEXP \'my_value\'' },
+      postgresql: { operator: '~', operation: 'my_field ~ \'my_value\'' },
+      sqlite3: { operator: 'REGEXP', operation: 'my_field REGEXP \'my_value\'' }
+    }
+    _test_regex('Regex', sql_by_db_adapter)
+  end
+
+  def test_iregex_operator
+    sql_by_db_adapter = {
+      mysql2: { operator: 'REGEXP', operation: 'LOWER(my_field) REGEXP \'my_value\'' },
+      postgresql: { operator: '~*', operation: 'my_field ~* \'my_value\'' },
+      sqlite3: { operator: 'REGEXP', operation: 'my_field REGEXP \'(?i)my_value\'' }
+    }
+    _test_regex('IRegex', sql_by_db_adapter)
+  end
+
+  def _test_regex(regex_operation_name, sql_by_adapter, unimplemented_db_adapters = %w[mssql, oracle])
+    regex_class = Object.const_get("Babik::Selection::Operation::#{regex_operation_name.camelize}")
+    _test_regex_sql(regex_class, sql_by_adapter)
+    _test_regex_not_implemented(regex_class, unimplemented_db_adapters)
+  end
+
+  def _test_regex_sql(klass, sql_by_db_adapter)
+    sql_by_db_adapter.each do |db_adapter, sql|
+      Babik::Database.config[:adapter] = db_adapter.to_s
+      regex_operation = klass.new('my_field', 'my_value')
+      assert_equal db_adapter.to_s, regex_operation.db_engine
+      assert_equal sql[:operator], regex_operation.operator, "Failed on checking #{klass} operator on #{db_adapter}"
+      assert_equal sql[:operation], regex_operation.sql_operation, "Failed on checking #{klass} operation on #{db_adapter}"
+    end
+  end
+
+
+  def _test_regex_not_implemented(klass, unimplemented_db_adapters)
+    date_operation = klass.new('my_field', 'my_value')
+    unimplemented_db_adapters.each do |unimplemented_db_adapter|
+      date_operation.stub :db_engine, -> { unimplemented_db_adapter.to_s } do
+        assert_raises NotImplementedError do
+          date_operation.operator
+        end
+      end
+    end
+  end
+
+end

data/test/other/clone_test.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Class for Tests of clone method
+class CloneTest < Minitest::Test
+
+  def test_filter
+    filter = { first_name: 'whatever1' }
+    exclusion = { last_name: 'whatever1' }
+
+    original = User.objects.filter(filter).exclude(exclusion)
+    copy = original.clone
+
+    refute_equal original.object_id, copy.object_id
+
+    assert_equal original._where.model, copy._where.model
+
+    refute_equal original._where.inclusion_filters.object_id, copy._where.inclusion_filters.object_id
+    refute_equal original._where.inclusion_filters[0].object_id, copy._where.inclusion_filters[0].object_id
+
+    refute_equal original._where.exclusion_filters.object_id, copy._where.exclusion_filters.object_id
+    refute_equal original._where.exclusion_filters[0].object_id, copy._where.exclusion_filters[0].object_id
+  end
+
+  def test_or_filter
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    exclusion = [{ last_name: 'whatever1' }, { last_name: 'whatever2' }]
+
+    original = User.objects.filter(filter).exclude(exclusion)
+    copy = original.clone
+
+    refute_equal original.object_id, copy.object_id
+
+    assert_equal original._where.model, copy._where.model
+
+    refute_equal original._where.inclusion_filters.object_id, copy._where.inclusion_filters.object_id
+    refute_equal original._where.inclusion_filters[0].object_id, copy._where.inclusion_filters[0].object_id
+
+    refute_equal original._where.exclusion_filters.object_id, copy._where.exclusion_filters.object_id
+    refute_equal original._where.exclusion_filters[0].object_id, copy._where.exclusion_filters[0].object_id
+  end
+
+  def test_distinct
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    exclusion = [{ last_name: 'whatever1' }, { last_name: 'whatever2' }]
+
+    original = User.objects.filter(filter).exclude(exclusion)
+    copy = original.distinct
+    copy_undistinct = original.undistinct
+
+    refute_equal original.object_id, copy.object_id
+    refute_equal original.object_id, copy_undistinct.object_id
+    refute original.distinct?
+    assert copy.distinct?
+    refute copy_undistinct.distinct?
+  end
+
+  def test_limit
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    original = User.objects.filter(filter)
+    copy1 = original.limit(2, 10)
+    copy2 = original[2..10]
+    refute_equal original.object_id, copy1.object_id
+    refute_equal original.object_id, copy2.object_id
+    refute_equal copy1.object_id, copy2.object_id
+  end
+
+  def test_lockable
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    original = User.objects.filter(filter)
+    copy1 = original.lock
+    copy2 = original.for_update
+    refute_equal original.object_id, copy1.object_id
+    refute_equal original.object_id, copy2.object_id
+    refute_equal copy1.object_id, copy2.object_id
+  end
+
+  def test_projectable
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    original = User.objects.filter(filter)
+    copy1 = original.project(:id, :first_name)
+    copy2 = original.project(:id, :first_name, :last_name)
+    copy3 = copy2.unproject
+    refute_equal original.object_id, copy1.object_id
+    refute_equal original.object_id, copy2.object_id
+    refute_equal original.object_id, copy3.object_id
+    refute_equal copy1.object_id, copy2.object_id
+    refute_equal copy1.object_id, copy3.object_id
+    refute_equal copy2.object_id, copy3.object_id
+  end
+
+  def test_sortable
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    original = User.objects.filter(filter)
+    copy1 = original.order_by(first_name: :ASC)
+    copy2 = original.order(id: :ASC)
+    copy3 = copy2.order(%i[last_name DESC])
+    refute_equal original.object_id, copy1.object_id
+    refute_equal original.object_id, copy2.object_id
+    refute_equal original.object_id, copy3.object_id
+    refute_equal copy1.object_id, copy2.object_id
+    refute_equal copy1.object_id, copy3.object_id
+    refute_equal copy2.object_id, copy3.object_id
+  end
+
+  def test_deletable
+    filter = [{ first_name: 'Julius' }, { first_name: 'Marcus' }]
+    names = %w[Julius Marcus Tiberius Pontius Crassus]
+    names.each do |name|
+      User.create(first_name: name)
+    end
+    users = User.objects.filter(filter)
+    users.delete
+
+    assert_equal 0, users.count
+    assert_equal User.all.count, User.objects.count
+
+    User.destroy_all
+  end
+
+  def test_clone
+    filter = [{ first_name: 'whatever1' }, { first_name: 'whatever2' }]
+    original = User.objects.filter(filter)
+    original.clone.clone
+  end
+
+end