babik 0.1.0

data/test/other/escape_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Check the quotes and strings ar correctly escaped.
+class EscapeTest < Minitest::Test
+
+  def setup
+    User.create!(first_name: 'Athos')
+    User.create!(first_name: 'Porthos')
+    User.create!(first_name: 'Aramis')
+    User.create!(first_name: "D'Artagnan")
+  end
+
+  def test_escape_value
+    users = User.objects.filter(first_name: "D'Artagnan")
+    assert_equal 1, users.count
+  end
+
+end

data/test/other/inverse_of_required_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Check that inverse_of is required in all associations
+class InverseOfRequiredTest < Minitest::Test
+
+  def setup
+    main_category = Category.create!(name: 'Category not used')
+    bad_post = BadPost.create!(title: 'This is a bad post', category: main_category)
+    BadTag.create!(name: 'bad tag 1', bad_post: bad_post)
+    BadTag.create!(name: 'bad tag 2', bad_post: bad_post)
+  end
+
+  def teardown
+    BadTag.delete_all
+    BadPost.delete_all
+    Category.delete_all
+  end
+
+  def test_association_without_inverse
+    exception = assert_raises RuntimeError do
+      bad_post = BadPost.all.first
+      bad_post.objects(:bad_tags)
+    end
+    assert_equal(
+      'Relationship bad_tags of model BadPost has no inverse_of option.',
+      exception.message
+    )
+  end
+
+end

data/test/select/aggregate_test.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of aggregate method
+class AggregateTest < Minitest::Test
+
+  def setup
+    @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_by_name('war')
+      post.add_tag_by_name('gallic')
+      post.add_tag_by_name('tribes')
+      post.add_tag_by_name('victory')
+      post.add_tag_by_name('campaign')
+      post.add_tag_by_name('biography')
+    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_by_name('war')
+    last_post.add_tag_by_name('last_book')
+  end
+
+  def teardown
+    Tag.destroy_all
+    Post.destroy_all
+    User.destroy_all
+  end
+
+  def test_local_avg
+    stars = @caesar.objects(:posts).map(&:stars)
+    avg_stars = stars.reduce(:+) / stars.length.to_f
+    avg_starts_aggregation = @caesar
+                             .objects(:posts)
+                             .aggregate(avg_stars: Babik::QuerySet.agg(:avg, 'stars'))
+    assert_equal avg_stars.round(4), avg_starts_aggregation[:avg_stars].round(4)
+  end
+
+  def test_foreign_avg
+    stars = @caesar.objects(:posts).map(&:stars)
+    avg_stars = stars.reduce(:+) / stars.length.to_f
+    avg_starts_aggregation = User
+                             .objects
+                             .filter(id: @caesar.id)
+                             .aggregate(avg_stars: Babik::QuerySet.agg(:avg, 'posts::stars'))
+    assert_equal avg_stars.round(4), avg_starts_aggregation[:avg_stars].round(4)
+  end
+
+  def test_simplified_foreign_avg
+    stars = @caesar.objects(:posts).map(&:stars)
+    avg_stars = stars.reduce(:+) / stars.length.to_f
+    avg_starts_aggregation = @caesar
+                             .objects
+                             .aggregate(avg_stars: Babik::QuerySet.agg(:avg, 'posts::stars'))
+    assert_equal avg_stars.round(4), avg_starts_aggregation[:avg_stars].round(4)
+  end
+
+  def test_local_distinct_count
+    # Julius Caesar has all types of value of stars
+    # As he has posts with all stars, it should be 5
+    count_aggregation = @caesar
+                        .objects
+                        .project(:stars)
+                        .aggregate(
+                          caesar_count_distinct_stars:
+                            Babik::QuerySet.agg(:count_distinct, 'posts::stars')
+                        )
+    assert_equal 5, count_aggregation[:caesar_count_distinct_stars]
+  end
+
+  def test_foreign_distinct_count
+    # Julius Caesar has 6 tags in his posts, it should be 6
+    count_aggregation = @caesar
+                        .objects
+                        .aggregate(
+                          caesar_count_distinct_tags:
+                            Babik::QuerySet.agg(:count_distinct, 'posts::tags::id')
+                        )
+    assert_equal 6, count_aggregation[:caesar_count_distinct_tags]
+  end
+
+  def test_foreign_count
+    # Julius Caesar has 6 tags in his posts, it should be 6
+    count_aggregation = @caesar
+                        .objects
+                        .aggregate(
+                          caesar_count_tags:
+                            Babik::QuerySet.agg(:count, 'posts::tags::id')
+                        )
+    assert_equal @caesar.objects(:posts).count * 6, count_aggregation[:caesar_count_tags]
+  end
+
+  def test_max
+    max_stars = @caesar.objects(:posts).map(&:stars).max
+    max_stars_agg = @caesar.objects(:posts)
+                           .aggregate(max_stars: Babik::QuerySet.agg(:max, 'stars'))[:max_stars]
+    assert_equal max_stars, max_stars_agg
+  end
+
+  def test_min
+    min_stars = @caesar.objects(:posts).map(&:stars).min
+    min_stars_agg = @caesar.objects(:posts)
+                           .aggregate(min_stars: Babik::QuerySet::Min.new('stars'))[:min_stars]
+    assert_equal min_stars, min_stars_agg
+  end
+
+  def test_sum
+    sum_stars = @caesar.objects(:posts).map(&:stars).inject(:+)
+    sum_stars_agg = @caesar.objects(:posts)
+                           .aggregate(sum_stars: Babik::QuerySet::Sum.new('stars'))[:sum_stars]
+    assert_equal sum_stars, sum_stars_agg
+  end
+
+  def test_sum_max_min
+    sum_stars = @caesar.objects(:posts).map(&:stars).inject(:+)
+    max_stars = @caesar.objects(:posts).map(&:stars).max
+    min_stars = @caesar.objects(:posts).map(&:stars).min
+
+
+    max_min_stars_agg = @caesar.objects(:posts)
+                               .aggregate(
+                                 sum_stars: Babik::QuerySet::Sum.new('stars'),
+                                 max_stars: Babik::QuerySet::Max.new('stars'),
+                                 min_stars: Babik::QuerySet::Min.new('stars')
+                               )
+    assert_equal sum_stars, max_min_stars_agg[:sum_stars]
+    assert_equal max_stars, max_min_stars_agg[:max_stars]
+    assert_equal min_stars, max_min_stars_agg[:min_stars]
+  end
+
+  def test_std_dev
+    if %w[postgres, mysql2].include?(Babik::Database.config[:adapter])
+      std_dev_var_agg = @caesar.objects(:posts)
+                               .aggregate(
+                                 std_dev_stars: Babik::QuerySet::StdDev.new('stars'),
+                                 std_dev_sample_stars: Babik::QuerySet::StdDevSample.new('stars'),
+                                 var_stars: Babik::QuerySet::Var.new('stars'),
+                                 var_sample_stars: Babik::QuerySet::VarSample.new('stars'),
+                               )
+
+      assert_in_delta 1.4982983545287878, std_dev_var_agg[:std_dev_stars]
+      assert_in_delta 1.618347187425374, std_dev_var_agg[:std_dev_sample_stars]
+      assert_in_delta 2.2448979591836733, std_dev_var_agg[:var_stars]
+      assert_in_delta 2.244897959183673, std_dev_var_agg[:var_sample_stars]
+    end
+  end
+
+end

data/test/select/bounds_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of first, last, earliest and latest methods
+class BoundsTest < Minitest::Test
+
+  def setup
+    @cervantes = User.create!(first_name: 'Miguel', last_name: 'De Cervantes y Saavedra')
+    Post.create!(title: 'La Galatea', author: @cervantes, stars: 3)
+    Post.create!(title: 'La gitanilla', author: @cervantes, stars: 3)
+    Post.create!(title: 'El ingenioso hidalgo Don Quijote de La Mancha', author: @cervantes, stars: 5)
+    Post.create!(title: 'Rinconete y Cortadillo', author: @cervantes, stars: 4)
+  end
+
+  def teardown
+    Post.destroy_all
+    User.destroy_all
+  end
+
+  def test_first_and_earliest
+    first_with_less_stars = Post.objects.order_by('stars').first
+    earliest_with_less_stars = Post.objects.earliest('stars')
+    latest_with_more_stars = Post.objects.latest('-stars')
+    assert_equal latest_with_more_stars.id, first_with_less_stars.id
+    assert_equal earliest_with_less_stars.id, first_with_less_stars.id
+    assert_equal 'La Galatea', first_with_less_stars.title
+    assert_equal 'La Galatea', earliest_with_less_stars.title
+    assert_equal 3, first_with_less_stars.stars
+    assert_equal 3, earliest_with_less_stars.stars
+  end
+
+  def test_last_and_latest
+    last_with_less_stars = Post.objects.order_by('stars').last
+    latest_with_less_stars = Post.objects.latest('stars')
+    earliest_with_more_stars = Post.objects.earliest('-stars')
+    assert_equal earliest_with_more_stars.id, last_with_less_stars.id
+    assert_equal latest_with_less_stars.id, last_with_less_stars.id
+    assert_equal 'El ingenioso hidalgo Don Quijote de La Mancha', last_with_less_stars.title
+    assert_equal 'El ingenioso hidalgo Don Quijote de La Mancha', latest_with_less_stars.title
+    assert_equal 5, last_with_less_stars.stars
+    assert_equal 5, latest_with_less_stars.stars
+  end
+
+end

data/test/select/count_test.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of count method
+class CountTest < Minitest::Test
+
+  def setup
+    @parthian_empire = GeoZone.create!(name: 'Parthian Empire')
+    @syria = GeoZone.create!(name: 'Syria', parent_zone: @parthian_empire)
+    @antioch = GeoZone.create!(name: 'Antioch', parent_zone: @syria)
+    @seleucus = User.create!(first_name: 'Seleucus', email: 'seleucus@example.com', zone: @antioch)
+
+    @roman_empire = GeoZone.create!(name: 'Roman Empire')
+
+    @italia = GeoZone.create!(name: 'Italia', parent_zone: @roman_empire)
+    @rome = GeoZone.create!(name: 'Rome', parent_zone: @italia)
+
+    @judea = GeoZone.create!(name: 'Judea', parent_zone: @roman_empire)
+    @jerusalem = GeoZone.create!(name: 'Jerusalem', parent_zone: @judea)
+
+    @tiberius = User.create!(first_name: 'Tiberius', email: 'tiberius@example.com', zone: @rome)
+    @pilate = User.create!(first_name: 'Pontius', last_name: 'Pilate', email: 'pontious@example.com', zone: @jerusalem)
+    @flavio = User.create!(first_name: 'Flavio', last_name: 'Josefo', email: 'flaviojosefo@example.com', zone: @jerusalem)
+
+    @noah = User.create!(first_name: 'Noah')
+    @noah.created_at = Time.now - 1000.days
+    @noah.save!
+  end
+
+  def teardown
+    @parthian_empire.destroy
+    @seleucus.destroy
+    @roman_empire.destroy
+    @tiberius.destroy
+    @pilate.destroy
+    @flavio.destroy
+    @noah.destroy
+  end
+
+  # Test the count is well implemented when the returned value is 0
+  def test_count_0
+    zone_non_existant_description = 'This description does not appear in any zone'
+    queryset = User.objects.filter(
+      first_name: 'Flavio',
+      last_name: 'Josefo',
+      "zone::name__different": 'Rome',
+      "zone::description": zone_non_existant_description
+    )
+    active_record_set = User
+                        .joins(:zone)
+                        .where(first_name: 'Flavio', last_name: 'Josefo', "geo_zones.description": zone_non_existant_description)
+                        .where.not("geo_zones.name": 'Rome')
+    assert_equal active_record_set.count, queryset.count
+    assert_equal queryset.length,queryset.count
+    assert_equal queryset.length,queryset.size
+    assert queryset.empty?
+    assert_equal false, queryset.exists?
+  end
+
+  # Test the count is well implemented when the returned value is 1
+  def test_count_1
+    queryset = User.objects.filter(
+      first_name: 'Flavio',
+      last_name: 'Josefo',
+      "zone::name__different": 'Madrid'
+    )
+    active_record_set = User
+                        .joins(:zone)
+                        .where(first_name: 'Flavio', last_name: 'Josefo')
+                        .where.not("geo_zones.name": 'Madrid')
+    assert_equal active_record_set.count, queryset.count
+    assert_equal queryset.length, queryset.count
+    assert_equal queryset.length, queryset.size
+    assert_equal false, queryset.empty?
+    assert_equal true, queryset.exists?
+  end
+
+  # Test the count from a deep belongs to relationship
+  def test_from_deep_belongs_to
+    queryset = User.objects.filter(
+      "zone::parent_zone::parent_zone::name__equals": 'Roman Empire'
+    )
+    assert_equal 3, queryset.count
+    assert_equal 3, queryset.size
+  end
+
+  # Test the count from a deep belongs to relationship
+  def test_or
+    queryset = User.objects.filter(
+      [
+        { "zone::parent_zone::parent_zone::name__equals": 'Roman Empire' },
+        { "zone::parent_zone::parent_zone::name__equals": 'Parthian Empire' }
+      ]
+    )
+    number_of_users = 0
+    queryset.each do |user|
+      assert ['Roman Empire', 'Parthian Empire'].include?(user.zone.parent_zone.parent_zone.name)
+      number_of_users += 1
+    end
+    assert_equal 4, queryset.count
+    assert_equal 4, number_of_users
+  end
+
+  # Count the objects using contains
+  def test_lookups
+    assert_equal User.where('first_name LIKE ?', '%avi%').length, User.objects.filter(first_name__contains: 'avi').length
+    assert_equal User.where('first_name LIKE ?', 'Fla%').length, User.objects.filter(first_name__startswith: 'Fla').length
+    assert_equal User.where('first_name LIKE ?', '%vio').length, User.objects.filter(first_name__startswith: 'Fla').length
+    assert_equal User.where(first_name: 'Flavio').length, User.objects.filter(first_name: 'Flavio').length
+    assert_equal User.where(first_name: 'Flavio').length, User.objects.filter(first_name__exact: 'Flavio').length
+    assert_equal User.where(first_name: 'Flavio').length, User.objects.filter(first_name__equal: 'Flavio').length
+  end
+
+  def test_lookup_isnull
+    assert_equal 0, User.objects.filter('zone::name': 'Rome', email__isnull: true).count
+    assert_equal 0, User.objects.filter('zone::name': 'Rome', email__exact: nil).count
+    assert_equal 1, User.objects.filter('zone::name': 'Rome', email__isnull: false).count
+    assert_equal 2, User.objects.filter('zone::name': 'Jerusalem', email__isnull: false).count
+    assert_equal 2, User.objects.filter('zone::name': 'Jerusalem').exclude(email__exact: nil).count
+  end
+
+  def test_lookup_in
+    assert_equal 2, User.objects.filter(first_name__in: %w[Tiberius Pontius Julius Marcus]).length
+  end
+
+  def test_date
+    today_start = Time.now.beginning_of_day
+    today_end = Time.now.end_of_day
+    today = Date.today
+
+    number_of_users = User.where('created_at >= ?', today_start).where('created_at <= ?', today_end).count
+
+    assert_equal number_of_users, User.objects.filter(created_at__gte: today_start, created_at__lte: today_end).count
+    assert_equal number_of_users, User.objects.filter(created_at__between: [today_start, today_end]).count
+    assert_equal number_of_users, User.objects.filter(created_at__date: today).count
+
+    assert_equal(
+      2, User
+             .objects
+             .filter(created_at__date: today)
+             .filter([{ first_name: 'Tiberius' }, { first_name: 'Pontius' }]).count
+    )
+  end
+
+end

data/test/select/distinct_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of distinct method
+class DistinctTest < Minitest::Test
+
+  def setup
+    User.create!(first_name: 'Diego', last_name: 'de Siloé')
+    User.create!(first_name: 'Diego', last_name: 'Velazquez')
+  end
+
+  def teardown
+    User.delete_all
+  end
+
+  def test_local_distinct
+    assert_equal 2, User.objects.filter(first_name: 'Diego').project(:first_name).count
+    assert_equal 1, User.objects.distinct.filter(first_name: 'Diego').project(:first_name).count
+    assert User.objects.distinct.filter(first_name: 'Diego').distinct?
+  end
+
+  def test_local_distinct_from_queryset
+    diegos = User.objects.filter(first_name: 'Diego').project(:first_name).distinct
+    assert diegos.distinct?
+    refute diegos.undistinct.distinct?
+    assert_equal 1, diegos.count
+  end
+
+  def test_local_undistinct
+    diegos = User.objects.filter(first_name: 'Diego').project(:first_name)
+    refute diegos.distinct?
+    assert_equal 2, diegos.count
+    assert_equal diegos.count, diegos.distinct.undistinct.count
+  end
+
+end

data/test/select/exclude_test.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of exclude method
+class ExcludeTest < Minitest::Test
+
+  def setup
+    @asturias = GeoZone.new(name: 'Asturias')
+    @cantabria = GeoZone.new(name: 'Cantabria')
+    @cangas_de_onis = GeoZone.new(name: 'Cangas de Onís', parent_zone: @asturias)
+    @oviedo = GeoZone.new(name: 'Oviedo', parent_zone: @asturias)
+
+    User.create!(first_name: 'Pelayo', biography: 'Unknown origin', zone: @cangas_de_onis)
+    User.create!(first_name: 'Favila', biography: 'Short reign of two years, seven months and ten days', zone: @cangas_de_onis)
+    User.create!(first_name: 'Alfonso I', last_name: 'El Católico', biography: 'Son-in-law of Don Pelayo', zone: @cantabria)
+    User.create!(first_name: 'Fruela I', last_name: 'Hombre de Hierro', biography: 'Killed by conspirators', zone: @cangas_de_onis)
+    User.create!(first_name: 'Aurelio', biography: 'Chosen by Asturian nobility', zone: @asturias)
+    User.create!(first_name: 'Silo', biography: 'Peace period', zone: @asturias)
+    User.create!(first_name: 'Alfonso II', last_name: 'El Casto', biography: 'Discovered Saint James tomb', zone: @oviedo)
+    User.create!(first_name: 'Mauregato', biography: 'Paid the 100 maidens tribute to Cordova Emirate', zone: @asturias)
+    User.create!(first_name: 'Bermudo I', last_name: 'El Diácono', biography: 'Cultured, magnanimous and illustrated man')
+    User.create!(first_name: 'Nepociano', last_name: 'El usurpador')
+    User.create!(first_name: 'Ramiro I', last_name: 'Vara de la Justicia', zone: @oviedo)
+    User.create!(first_name: 'Ordoño I', biography: 'Failed first attemp to reconquer the kingdom', zone: @oviedo)
+    User.create!(first_name: 'Alfonso III', last_name: 'El Magno', biography: 'Last king of Independent Asturian kingdom')
+    User.create!(first_name: 'Fruela II', last_name: 'El leproso', biography: 'Last king of Asturian kingdom')
+  end
+
+  def teardown
+    User.delete_all
+  end
+
+  def test_local_exclude
+    kings_with_bio_out_without_ordinal = User.objects
+                                             .filter(biography__isnull: false)
+                                             .exclude(first_name__endswith: 'I')
+                                             .order_by([:first_name, :ASC])
+    asturian_kings = ['Aurelio', 'Favila', 'Mauregato', 'Pelayo', 'Silo']
+    kings_with_bio_out_without_ordinal.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+    end
+  end
+
+  def test_foreign_exclude
+    kings_with_bio_not_from_oviedo = User.objects
+                                         .filter(biography__isnull: false)
+                                         .exclude('zone::name': 'Oviedo')
+                                         .order_by([:first_name, :ASC])
+    asturian_kings = ['Alfonso I', 'Aurelio', 'Favila', 'Fruela I', 'Mauregato', 'Pelayo', 'Silo']
+    kings_with_bio_not_from_oviedo.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+    end
+  end
+
+  def test_foreign_complex_exclude
+    kings_not_from_oviedo_not_named_alfonso = User.objects
+                                                  .exclude(
+                                                    [
+                                                      { 'zone::name': 'Oviedo' },
+                                                      { first_name__startswith: 'Alfonso' }
+                                                    ]
+                                                  )
+                                                  .order_by([:first_name, :ASC])
+    asturian_kings = ['Aurelio', 'Favila', 'Fruela I', 'Mauregato', 'Pelayo', 'Silo']
+    kings_not_from_oviedo_not_named_alfonso.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+    end
+  end
+
+end