babik 0.1.0

data/test/select/limit_test.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Limit method tests
+class LimitTest < Minitest::Test
+
+  def setup
+    i = 0
+    while i < 100
+      User.create!(first_name: "User #{i + 1}", last_name: 'LimitTest user')
+      i += 1
+    end
+  end
+
+  def teardown
+    User.delete_all
+  end
+
+  def test_limit
+    page_size = 5
+
+    # Check the first page of users
+    first_page = User.objects.filter(last_name: 'LimitTest user').limit(page_size)
+    # Check with each
+    loops = 0
+    first_page.each do |user|
+      assert_equal "User #{loops + 1}", user.first_name
+      loops += 1
+    end
+    assert_equal page_size, loops
+
+    # Check the second page of users
+    second_page_offset = page_size
+    second_page = User.objects.filter(last_name: 'LimitTest user').limit(page_size, second_page_offset)
+    assert_equal 5, second_page.count
+    second_page.each_with_index do |user, user_index|
+      assert_equal "User #{user_index + second_page_offset + 1}", user.first_name
+    end
+  end
+
+  def test_limit_brackets
+    page_size = 5
+    first_page = User.objects.filter(last_name: 'LimitTest user').limit(page_size)
+    first_page_with_brackets = User.objects.filter(last_name: 'LimitTest user')[0..page_size]
+    limit_test_user = User.objects.filter(last_name: 'LimitTest user')[page_size]
+    assert_equal 'No user', User.objects.filter(last_name: 'LimitTest user').fetch(10_000, 'No user')
+
+    non_existent_index = User.objects.count + 100
+    exception = assert_raises IndexError do
+      User.objects.filter(last_name: 'LimitTest user').fetch(non_existent_index)
+    end
+    limit_test_count = User.objects.filter(last_name: 'LimitTest user').count
+
+    assert_equal("Index #{non_existent_index} outside of QuerySet bounds", exception.message)
+    assert_equal User, limit_test_user.class
+    assert_equal 'LimitTest user', limit_test_user.last_name
+    assert_equal first_page.count, first_page_with_brackets.count
+
+    second_page_offset = page_size
+    second_page = User.objects.filter(last_name: 'LimitTest user').limit(page_size, second_page_offset)
+    second_page_with_brackets = User.objects.filter(last_name: 'LimitTest user')[second_page_offset..(second_page_offset+page_size)]
+    assert_equal page_size, second_page.count
+    assert_equal second_page.count, second_page_with_brackets.count
+  end
+
+  def test_limit_brackets_index
+    first_user = User.objects.filter(last_name: 'LimitTest user').order_by(created_at: :ASC)[0]
+    expected_first_user = User.where(last_name: 'LimitTest user').order('created_at ASC').first
+    assert_equal expected_first_user.id, first_user.id
+    assert_equal expected_first_user.first_name, first_user.first_name
+  end
+
+  def test_is_limited
+    assert User.objects.filter!(last_name: 'LimitTest user').limit!(5, 10).limit?
+  end
+
+  def test_unlimit
+    refute User.objects.filter!(last_name: 'LimitTest user').limit!(5, 10).unlimit!.limit?
+  end
+
+  def test_exists
+    assert User.objects.filter(last_name: 'LimitTest user').exists?
+    assert User.objects.filter(last_name: 'LimitTest user').exist?
+
+    refute User.objects.filter(last_name: 'This user does not exist').exists?
+    refute User.objects.filter(last_name: 'This user does not exist').exist?
+  end
+
+  def test_brackets_index_out_of_range
+    assert_nil User.objects.filter(last_name: 'LimitTest user').order_by(created_at: :ASC)[1000]
+  end
+
+  def test_brackets_invalid_value
+    exception = assert_raises RuntimeError do
+      assert_raises User.objects.filter(last_name: 'LimitTest user').order_by(created_at: :ASC)['INVALID VALUE']
+    end
+    assert_equal('Invalid limit passed to query: INVALID VALUE', exception.message)
+  end
+
+  def test_fetch_index_out_of_range
+    exception = assert_raises IndexError do
+      assert_raises User.objects.filter(last_name: 'LimitTest user').order_by(created_at: :ASC).fetch(1000)
+    end
+    assert_equal('Index 1000 outside of QuerySet bounds', exception.message)
+  end
+
+end

data/test/select/local_selection_test.rb

@@ -0,0 +1,24 @@
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+class LocalSelectionTest < Minitest::Test
+
+  def test_equal_selection
+    local_selection = Babik::Selection::LocalSelection.new(User, 'first_name', 'Pepe')
+    assert_equal local_selection.model, User
+    assert_equal local_selection.selection_path, 'first_name'
+    assert_equal local_selection.selected_field, 'first_name'
+    assert_equal local_selection.value, 'Pepe'
+    assert_equal local_selection.operator, 'equal'
+  end
+
+  def test_selection_icontains
+    local_selection = Babik::Selection::LocalSelection.new(User, 'firstname__icontains', 'Pepe')
+    assert_equal local_selection.model, User
+    assert_equal local_selection.selection_path, 'firstname__icontains'
+    assert_equal local_selection.selected_field, 'firstname'
+    assert_equal local_selection.value, 'Pepe'
+    assert_equal local_selection.operator, 'icontains'
+  end
+
+end

data/test/select/lookup_test.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of different lookups available in both methods filter and exclude
+class LookupTest < Minitest::Test
+
+  def setup
+    Post.create!(title: 'This other post of 5 stars', stars: 5)
+    Post.create!(title: 'This a post of 5 stars', stars: 5)
+    Post.create!(title: 'This a post of 4 stars', stars: 4)
+    Post.create!(title: 'This a post of 3 stars', stars: 3)
+    Post.create!(title: 'This other post with 3 stars', stars: 3)
+
+    Post.create!(title: 'Old post 1', stars: 0, created_at: Time.now - 1.month)
+    Post.create!(title: 'Old post 2', stars: 0, created_at: Time.now - 10.months)
+
+    Post.create!(title: 'Yesteryear post 1', created_at: Time.now - 1.year)
+    Post.create!(title: 'Yesteryear post 2', created_at: Time.now - 10.year)
+  end
+
+  def teardown
+    Post.destroy_all
+  end
+
+  def test_gt
+    posts_with_more_than_4_starts = Post.objects.filter(stars__gt: 4).order_by(created_at: :ASC)
+    assert_equal 2, posts_with_more_than_4_starts.count
+    assert_equal 'This other post of 5 stars', posts_with_more_than_4_starts[0].title
+    assert_equal 'This a post of 5 stars', posts_with_more_than_4_starts[1].title
+  end
+
+  def test_gte
+    posts_with_more_or_equal_than_4_starts = Post.objects.filter(stars__gte: 4).order_by(created_at: :ASC)
+    assert_equal 3, posts_with_more_or_equal_than_4_starts.count
+    assert_equal 'This other post of 5 stars', posts_with_more_or_equal_than_4_starts[0].title
+
+    assert_nil posts_with_more_or_equal_than_4_starts[100]
+  end
+
+  def test_lt
+    posts_with_less_than_4_starts = Post.objects.filter(stars__lt: 4).order_by(created_at: :ASC)
+    assert_equal 4, posts_with_less_than_4_starts.count
+    assert_equal 'Old post 2', posts_with_less_than_4_starts[0].title
+    assert_equal 'Old post 1', posts_with_less_than_4_starts[1].title
+  end
+
+  def test_lte
+    posts_with_less_or_equal_than_4_starts = Post.objects.filter(stars__lte: 4).order_by(created_at: :ASC)
+    assert_equal 5, posts_with_less_or_equal_than_4_starts.count
+    assert_equal 'Old post 2', posts_with_less_or_equal_than_4_starts[0].title
+    assert_equal 'Old post 1', posts_with_less_or_equal_than_4_starts[1].title
+    assert_equal 'This a post of 4 stars', posts_with_less_or_equal_than_4_starts[2].title
+    assert_equal 'This a post of 3 stars', posts_with_less_or_equal_than_4_starts[3].title
+    assert_equal 'This a post of 3 stars', posts_with_less_or_equal_than_4_starts[3].title
+  end
+
+  def test_in
+    posts_with_odd_stars = Post.objects.filter(stars__in: [5, 3, 1])
+    posts_with_5_stars = Post.objects.filter(stars: 5)
+    posts_with_3_stars = Post.objects.filter(stars: 3)
+    posts_with_1_star = Post.objects.filter(stars: 1)
+
+    assert_equal 2, posts_with_5_stars.count
+    assert_equal 2, posts_with_3_stars.count
+    assert_equal 0, posts_with_1_star.count
+    assert_equal 4, posts_with_odd_stars.count
+  end
+
+  def test_in_and_equal
+    assert_equal Post.objects.filter(stars: 3).count, Post.objects.filter(stars__in: 3).count
+  end
+
+  def test_between
+    posts_3_4_stars = Post.objects.filter(stars__between: [3, 4]).order_by(created_at: :ASC)
+    posts_3_4_stars_range = Post.objects.filter(stars__range: [3, 4]).order_by(created_at: :ASC)
+    assert_equal 3, posts_3_4_stars.count
+    assert_equal 3, posts_3_4_stars_range.count
+    assert_equal 'This a post of 4 stars', posts_3_4_stars[0].title
+    assert_equal 'This a post of 3 stars', posts_3_4_stars[1].title
+    assert_equal 'This other post with 3 stars', posts_3_4_stars[2].title
+  end
+
+  def test_between_dates
+    old_posts = Post.objects.filter(created_at__between: [Time.now - 2.months, Time.now - 1.day])
+    old_posts_range = Post.objects.filter(created_at__range: [Time.now - 2.months, Time.now - 1.day])
+    assert_equal 1, old_posts.count
+    assert_equal 1, old_posts_range.count
+    assert_equal 'Old post 1', old_posts[0].title
+    assert_equal 'Old post 1', old_posts_range[0].title
+  end
+
+  def test_date
+    today_posts = Post.objects.filter(created_at__date: Date.today)
+    assert_equal 5, today_posts.count
+  end
+
+  def test_year
+    younger_than_1998_year_posts = Post.objects.filter(created_at__year__gt: 1998)
+    assert_equal Post.objects.count, younger_than_1998_year_posts.count
+    assert_equal 0, Post.objects.filter(created_at__year: 1998).count
+  end
+
+  def test_quarter
+    # Get a quarter with posts
+    quarters = Post.objects.map { |post| (post.created_at.strftime('%m').to_i + 2) / 3 }
+    grouped_quarters = quarters.group_by(&:itself)
+    quarter = grouped_quarters.keys[0]
+    first_quarter = quarter.to_i
+    this_quarter_posts = Post.objects.filter(created_at__quarter: first_quarter)
+    assert_equal grouped_quarters[quarter].length, this_quarter_posts.count
+  end
+
+  def test_month
+    this_month_posts = Post.objects.filter(created_at__month: Time.now.utc.month)
+    assert_equal 7, this_month_posts.count
+  end
+
+  def test_day
+    this_day_posts = Post.objects.filter(created_at__day: Time.now.utc.day)
+    assert_equal 9, this_day_posts.count
+  end
+
+  def test_hour
+    this_hour_posts = Post.objects.filter(created_at__hour: Time.now.utc.hour)
+    assert_equal 9, this_hour_posts.count
+  end
+
+  def test_hour_wrong_lookup
+    exception = assert_raises RuntimeError do
+      Post.objects.filter(created_at__hour__xx: Time.now.utc.hour)[0]
+    end
+    assert_equal('Unknown lookup xx', exception.message)
+  end
+
+  def test_minute
+    this_minute_posts = Post.objects.filter(created_at__minute: Time.now.utc.strftime('%M'))
+    assert_equal 9, this_minute_posts.count
+  end
+
+  def test_second
+    # Get a second with posts
+    seconds = Post.objects.map { |post| post.created_at.strftime('%S') }
+    grouped_seconds = seconds.group_by(&:itself)
+    second = grouped_seconds.keys[0]
+    first_second = second.to_i
+    this_second_posts = Post.objects.filter(created_at__second: first_second)
+    assert_equal grouped_seconds[second].length, this_second_posts.count
+  end
+
+  # Check ISO week
+  def test_week
+    weeks = Post.objects.map { |post| post.created_at.strftime('%V').to_i }
+    grouped_weeks = weeks.group_by(&:itself)
+    first_week = grouped_weeks.keys[0]
+    first_week_int = first_week.to_i
+    this_week_posts = Post.objects.filter(created_at__week: first_week_int)
+    assert_equal grouped_weeks[first_week].length, this_week_posts.count
+  end
+
+  # Check 0-6 (sunday to monday) week day
+  def test_weekday
+    # Get a week day (0-6, sunday to monday) with posts
+    week_days = Post.objects.map { |post| post.created_at.strftime('%w') }
+    grouped_week_days = week_days.group_by(&:itself)
+    first_week_day = grouped_week_days.keys[0]
+    first_week_day_int = first_week_day.to_i
+    this_week_day_posts = Post.objects.filter(created_at__week_day: first_week_day_int)
+    assert_equal grouped_week_days[first_week_day].length, this_week_day_posts.count
+  end
+
+  def test_time
+    # Get a time (HH:MM:SS) with posts
+    times = Post.objects.map { |post| post.created_at.strftime('%H:%M:%S') }
+    grouped_times = times.group_by(&:itself)
+    first_time = grouped_times.keys[0]
+    this_time_posts = Post.objects.filter(created_at__time: first_time)
+    assert_equal grouped_times[first_time].length, this_time_posts.count
+  end
+
+  def test_regex
+    other_posts = Post.objects.filter(title__regex: /This a post of \d+ stars/).order_by(stars: :ASC)
+    if Babik::Database.config[:adapter] == 'sqlite3'
+      assert other_posts.sql.select.include?("posts.title REGEXP 'This a post of \\d+ stars'")
+      return
+    end
+    assert_equal 3, other_posts.count
+    assert_equal 'This a post of 3 stars', other_posts[0].title
+    assert_equal 'This a post of 4 stars', other_posts[1].title
+    assert_equal 'This a post of 5 stars', other_posts[2].title
+    assert_equal 3, other_posts.count
+  end
+
+  def test_iregex
+    other_posts = Post.objects.filter(title__iregex: /This a post of \d+ stars/).order_by(stars: :ASC)
+    if Babik::Database.config[:adapter] == 'sqlite3'
+      assert other_posts.sql.select.include?("posts.title REGEXP '(?i)This a post of \\d+ stars'")
+      return
+    end
+    assert_equal 3, other_posts.count
+    assert_equal 'This a post of 3 stars', other_posts[0].title
+    assert_equal 'This a post of 4 stars', other_posts[1].title
+    assert_equal 'This a post of 5 stars', other_posts[2].title
+    assert_equal 3, other_posts.count
+  end
+
+end

data/test/select/none_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of none method
+class NoneTest < Minitest::Test
+
+  def setup
+    [1..100].each do |i|
+      Post.create!(title: "Post #{i}", stars: 5)
+    end
+  end
+
+  def teardown
+    Post.destroy_all
+  end
+
+  def test_none
+    no_posts = Post.objects.none
+    assert_equal 0, no_posts.count
+    i = 100
+    no_posts.each do |_post|
+      i -= 1
+    end
+    assert_equal 100, i
+  end
+
+  def test_deep_none_call
+    no_posts = Post.objects.filter(stars: 5).none
+    assert_equal 0, no_posts.count
+    i = 100
+    no_posts.each do |_post|
+      i -= 1
+    end
+    assert_equal 100, i
+  end
+
+
+end

data/test/select/order_test.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Ordering tests
+class OrderTest < Minitest::Test
+
+  def setup
+
+    @frankish_kingdom = GeoZone.create!(name: 'Frankish Kingdom')
+
+    frankish_king_names = [
+      'Merovech',
+      'Childeric I',
+      'Clovis I'
+    ]
+
+    @frankish_kings = []
+    frankish_king_names.each do |frankish_king|
+      @frankish_kings << User.create!(first_name: frankish_king, last_name: 'Merovingian', zone: @frankish_kingdom)
+    end
+
+    @hispania = GeoZone.create!(name: 'Hispania')
+    goth_king_names = ['Alarico I',
+                       'Ataulfo',
+                       'Sigerico',
+                       'Teodorico I',
+                       'Turismundo',
+                       'Teodorico II',
+                       'Eurico',
+                       'Alarico II']
+
+    @goth_kings = []
+    goth_king_names.each do |goth_king|
+      @goth_kings << User.create!(first_name: goth_king, zone: @hispania)
+    end
+
+  end
+
+  def teardown
+    User.destroy_all
+    GeoZone.destroy_all
+  end
+
+  def test_first
+    first_user = User.objects.filter('zone::name': 'Hispania').order_by(%i[first_name ASC]).first
+    assert_equal 'Alarico I', first_user.first_name
+  end
+
+  def test_last_asc
+    last_user = User.objects.filter('zone::name': 'Hispania').order_by(%i[first_name ASC]).last
+    assert_equal 'Turismundo', last_user.first_name
+  end
+
+  def test_last_desc
+    last_user = User.objects.filter('zone::name': 'Hispania').order_by(%i[first_name DESC]).last
+    assert_equal 'Alarico I', last_user.first_name
+  end
+
+  def test_first_last
+    first = User.objects.filter('zone::name': 'Hispania').order_by(%i[first_name ASC]).first
+    inverted_last = User.objects.filter('zone::name': 'Hispania').order_by(%i[first_name DESC]).last
+    assert_equal first.id, inverted_last.id
+    assert_equal first.first_name, inverted_last.first_name
+  end
+
+  def test_basic_order
+    users = User.objects.filter('zone::name': 'Hispania').order_by(%i[first_name ASC])
+    _test_basic_order(users)
+  end
+
+  def test_basic_order_hash
+    users = User.objects.filter('zone::name': 'Hispania').order_by(first_name: :ASC)
+    _test_basic_order(users)
+  end
+
+  def test_basic_order_string
+    users = User.objects.filter('zone::name': 'Hispania').order_by('first_name')
+    _test_basic_order(users)
+  end
+
+  def test_basic_order_symbol
+    users = User.objects.filter('zone::name': 'Hispania').order_by(:first_name)
+    _test_basic_order(users)
+  end
+
+  def _test_basic_order(users)
+    goth_king_names = [
+      'Alarico I', 'Alarico II', 'Ataulfo', 'Eurico', 'Sigerico', 'Teodorico I', 'Teodorico II', 'Turismundo'
+    ]
+    users.each_with_index do |user, user_index|
+      assert_equal goth_king_names[user_index], user.first_name
+    end
+    assert users.ordered?
+  end
+
+  def test_deep_order
+    users = User.objects.order_by(%i[zone::name ASC], %i[first_name ASC])
+    reversed_users = users.reverse
+    king_names = [
+      'Childeric I',
+      'Clovis I',
+      'Merovech',
+      'Alarico I',
+      'Alarico II',
+      'Ataulfo',
+      'Eurico',
+      'Sigerico',
+      'Teodorico I',
+      'Teodorico II',
+      'Turismundo'
+    ]
+    users.each_with_index do |user, user_index|
+      assert_equal king_names[user_index], user.first_name
+    end
+    assert users.ordered?
+
+    reversed_king_names = king_names.reverse
+    reversed_users.each_with_index do |reversed_order_user, user_index|
+      assert_equal reversed_king_names[user_index], reversed_order_user.first_name
+    end
+    assert reversed_users.ordered?
+
+    king_names.each_with_index do |king_name, king_index|
+      assert_equal king_name, users[king_index].first_name
+      assert_equal king_name, reversed_users[king_names.length - king_index - 1].first_name
+    end
+  end
+
+  def test_disorder
+    users = User.objects.order_by(%i[zone::name ASC], %i[first_name ASC])
+    users.disorder!
+    refute users.ordered?
+  end
+
+  def test_order_with_prefixed_direction
+    users = User.objects.order_by('-zone::name', '-first_name')
+    first_user = users.first
+    assert_equal 'Hispania', first_user.zone.name
+    assert_equal 'Turismundo', first_user.first_name
+  end
+
+  def test_wrong_order
+    exception = assert_raises RuntimeError do
+      User.objects.filter('zone::name': 'Hispania').order_by([:first_name, 'XXXX'])
+    end
+    assert_equal('Invalid order type XXXX in first_name: Expecting :ASC or :DESC', exception.message)
+  end
+
+  def test_wrong_order_param_type
+    exception = assert_raises RuntimeError do
+      User.objects.filter('zone::name': 'Hispania').order_by(2222)
+    end
+    assert_equal('Invalid type of order: 2222', exception.message)
+  end
+
+  def test_wrong_field_path
+    exception = assert_raises RuntimeError do
+      User.objects.filter('zone::name': 'Hispania').order_by([1111, :ASC])
+    end
+    assert_equal('field_path of class Integer not valid. A Symbol/String/Babik::Selection::Base expected', exception.message)
+  end
+
+end