babik 0.1.0

data/test/select/filter_from_object_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of filter method when being called from an ActiveRecord object
+class FilterFromObjectTest < 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)
+
+    @pelayo = User.create!(first_name: 'Pelayo', zone: @cangas_de_onis)
+    User.create!(first_name: 'Favila', zone: @cangas_de_onis)
+    User.create!(first_name: 'Alfonso I', last_name: 'Católico', zone: @cantabria)
+    User.create!(first_name: 'Fruela I', zone: @cangas_de_onis)
+
+    battle = Tag.create!(name: 'battle')
+    asturias = Tag.create!(name: 'asturias')
+    victory = Tag.create!(name: 'victory')
+    Tag.create!(name: 'chronicle')
+
+    @main_category = Category.create!(name: 'Dialogues')
+    @other_category = Category.create!(name: 'My reign')
+
+    @first_post = Post.create!(author: @pelayo, title: 'I\'m not an ass', category: @main_category)
+    @second_post = Post.create!(author: @pelayo, title: 'Come and get my land', category: @main_category)
+    @third_post = Post.create!(author: @pelayo, title: 'Will keep my kingdom', category: @other_category)
+
+    @first_post.tags << battle
+    @first_post.tags << asturias
+    @first_post.tags << victory
+    @second_post.tags << asturias
+    @second_post.tags << victory
+  end
+
+  def teardown
+    User.destroy_all
+    GeoZone.destroy_all
+    Post.destroy_all
+    Tag.destroy_all
+    Category.destroy_all
+  end
+
+  def test_belongs_to_or_has_one
+    # Returns an ActiveRecord object
+    pelayo_zone = @pelayo.objects(:zone)
+    assert_equal @cangas_de_onis.class, pelayo_zone.class
+    assert_equal @cangas_de_onis.id, pelayo_zone.id
+  end
+
+  def test_direct_has_many_explicit_foreign_key
+    # Direct has_many relationship with an explicit foreign_key
+    users_from_cangas_de_onis = @cangas_de_onis.objects(:users).order_by(first_name: :ASC)
+    assert_equal @cangas_de_onis.users.count, users_from_cangas_de_onis.count
+    first_names = ['Favila', 'Fruela I', 'Pelayo']
+    users_count = 0
+    users_from_cangas_de_onis.each_with_index do |user, user_index|
+      assert_equal first_names[user_index], user.first_name
+      users_count += 1
+    end
+    assert_equal first_names.count, users_count
+  end
+
+  def test_deep_has_many
+    # Deep has_many relationship
+    tags_from_cangas_de_onis = @cangas_de_onis
+                               .objects(:'users::posts::tags')
+                               .distinct
+                               .exclude(name: 'asturias')
+                               .order_by(name: :ASC)
+    tag_names = %w[battle victory]
+    tags_count = 0
+    tags_from_cangas_de_onis.each_with_index do |tag, tag_index|
+      assert_equal tag_names[tag_index], tag.name
+      tags_count += 1
+    end
+    assert_equal tag_names.count, tags_count
+  end
+
+  def test_direct_has_many
+    # Direct has_many relationship
+    main_category_posts = @main_category.objects(:posts).order_by(created_at: :ASC)
+    posts = @main_category.posts
+    assert_equal posts.count, main_category_posts.count
+    post_titles = [@first_post.title, @second_post.title]
+    post_count = 0
+    main_category_posts.each_with_index do |post, post_index|
+      assert_equal post_titles[post_index], post.title
+      post_count += 1
+    end
+    assert_equal post_titles.count, post_count
+  end
+
+  def test_through_has_many_1
+    # has_many through relationship
+    assert_equal 5, @pelayo.objects('posts::tags').count
+    assert_equal 3, @pelayo.objects('posts::tags').distinct.count
+    tag_names = %w[asturias battle victory]
+    tag_count = 0
+    @pelayo.objects('posts::tags').distinct.order_by(name: :ASC).each_with_index do |tag, tag_index|
+      assert_equal tag_names[tag_index], tag.name
+      tag_count += 1
+    end
+    assert_equal tag_names.count, tag_count
+  end
+
+  def test_through_has_many_2
+    main_distinct_tags = @main_category.objects('posts::tags').distinct.order_by(name: :ASC)
+    main_tags = @main_category.objects('posts::tags').order_by(name: :ASC)
+
+    assert_equal 3, main_distinct_tags.count
+    assert_equal 5, main_tags.count
+
+    tag_names = %w[asturias battle victory]
+    tag_count = 0
+    main_distinct_tags.each_with_index do |tag, tag_index|
+      assert_equal tag_names[tag_index], tag.name
+      tag_count += 1
+    end
+    assert_equal main_distinct_tags.count, tag_count
+  end
+
+end

data/test/select/filter_test.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of filter method
+class FilterTest < 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)
+
+    @pelayo = User.create!(first_name: 'Pelayo', zone: @cangas_de_onis)
+    User.create!(first_name: 'Favila', zone: @cangas_de_onis)
+    User.create!(first_name: 'Alfonso I', last_name: 'Católico', zone: @cantabria)
+    User.create!(first_name: 'Fruela I', zone: @cangas_de_onis)
+
+    battle = Tag.create!(name: 'battle')
+    asturias = Tag.create!(name: 'asturias')
+    victory = Tag.create!(name: 'victory')
+    Tag.create!(name: 'chronicle')
+
+    @main_category = Category.create!(name: 'Dialogues')
+
+    first_post = Post.create!(author: @pelayo, title: 'I\'m not an ass', category: @main_category)
+    second_post = Post.create!(author: @pelayo, title: 'Come and get my land', category: @main_category)
+
+    first_post.tags << battle
+    first_post.tags << asturias
+    first_post.tags << victory
+
+    second_post.tags << asturias
+    second_post.tags << victory
+  end
+
+  def teardown
+    User.destroy_all
+    GeoZone.destroy_all
+    Post.destroy_all
+    BadPost.destroy_all
+    Tag.destroy_all
+    Category.destroy_all
+  end
+
+  def test_local_filter
+    kings = User.objects.filter(first_name__endswith: 'I').order_by(%i[first_name ASC])
+    asturian_kings = ['Alfonso I', 'Fruela I']
+    user_count = 0
+    kings.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+      user_count += 1
+    end
+    assert_equal asturian_kings.count, user_count
+  end
+
+  def test_local_or_filter
+    kings = User.objects
+                .filter([{ first_name: 'Pelayo' }, {'last_name': 'Católico'}])
+                .order_by(%i[first_name ASC])
+    asturian_kings = ['Alfonso I', 'Pelayo']
+    user_count = 0
+    kings.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+      user_count += 1
+    end
+    assert_equal asturian_kings.count, user_count
+  end
+
+  def test_foreign_filter
+    kings = User.objects
+                .filter('zone::parent_zone::name': 'Asturias')
+                .order_by(%i[first_name ASC])
+    asturian_kings = ['Favila', 'Fruela I', 'Pelayo']
+    user_count = 0
+    kings.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+      user_count += 1
+    end
+    assert_equal asturian_kings.count, user_count
+  end
+
+  def test_foreign_filter_by_active_record_object
+    kings = User.objects
+                .filter('zone::parent_zone': @asturias)
+                .order_by(%i[first_name ASC])
+    asturian_kings = ['Favila', 'Fruela I', 'Pelayo']
+    user_count = 0
+    kings.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+      user_count += 1
+    end
+    assert_equal asturian_kings.count, user_count
+  end
+
+  def test_foreign_or_filter
+    kings = User.objects
+                .filter([{first_name: 'Pelayo'}, {'zone::name': 'Cantabria'}])
+                .order_by(%i[first_name ASC])
+    asturian_kings = ['Alfonso I', 'Pelayo']
+    user_count = 0
+    kings.each_with_index do |king, king_i|
+      assert_equal asturian_kings[king_i], king.first_name
+      user_count += 1
+    end
+    assert_equal asturian_kings.count, user_count
+  end
+
+  # Different ways of querying with in lookup
+  def test_foreign_in
+    first_users = [
+      User.objects.filter(zone: [@cangas_de_onis, @cantabria]).order_by(created_at: :ASC)[0],
+      User.objects.filter(zone_id__in: [@cangas_de_onis, @cantabria]).order_by(created_at: :ASC)[0],
+      User.objects.filter(zone__in: [@cangas_de_onis, @cantabria]).order_by(created_at: :ASC)[0],
+      User.objects.filter(zone: [@cangas_de_onis.id, @cantabria.id]).order_by(created_at: :ASC)[0],
+      User.objects.filter(zone__in: [@cangas_de_onis.id, @cantabria.id]).order_by(created_at: :ASC)[0],
+    ]
+    different_user_ids = Set.new(first_users.map(&:id))
+    assert_equal 1, different_user_ids.length
+  end
+
+  def test_many_to_many_foreign_filter
+    tags = Tag.objects.distinct.filter('posts::title__contains': 'an ass').order_by(%i[name ASC])
+    tag_names = ['asturias', 'battle', 'victory']
+    tag_count = 0
+    tags.each_with_index do |tag, tag_index|
+      assert_equal tag_names[tag_index], tag.name
+      tag_count += 1
+    end
+    assert_equal tag_names.count, tag_count
+  end
+
+  def test_deep_many_to_many_foreign_filter
+    tags = Tag.objects.distinct.filter('posts::category::name': 'Dialogues').order_by(%i[name ASC])
+    tag_names = ['asturias', 'battle', 'victory']
+    tag_count = 0
+    tags.each_with_index do |tag, tag_index|
+      assert_equal tag_names[tag_index], tag.name
+      tag_count += 1
+    end
+    assert_equal tag_names.count, tag_count
+  end
+
+  def test_several_foreign_filters
+    cangueses_called_pelayo = User.objects.distinct.filter(
+      first_name: 'Pelayo', 'zone::name': @cangas_de_onis.name, 'posts::tags::name': 'asturias'
+    )
+    assert_equal 1, cangueses_called_pelayo.count
+    assert_equal @pelayo.id, cangueses_called_pelayo.first.id
+  end
+
+  def test_foreign_filter_by_object
+    cangueses = User.objects.distinct.filter('zone': @cangas_de_onis).order_by(%i[first_name ASC])
+    names = ['Favila', 'Fruela I', 'Pelayo']
+    cangueses.each_with_index do |cangues, cangues_index|
+      assert_equal names[cangues_index], cangues.first_name
+    end
+    assert_equal names.length, cangueses.count
+  end
+
+  def test_wrong_local_filter
+    exception = assert_raises RuntimeError do
+      User.objects.filter(this_local_field_does_not_exists: 'whatever').all
+    end
+    assert_equal(
+      'Unrecognized field this_local_field_does_not_exists for model User in filter/exclude', exception.message
+    )
+  end
+
+  def test_wrong_many_to_many_foreign_filter
+    exception = assert_raises RuntimeError do
+      BadTag.objects.distinct.filter('posts::category::name': 'Dialogues').order_by(%i[name ASC])
+    end
+    assert_equal('Relationship posts is has_and_belongs_to_many. Convert it to has_many-through', exception.message)
+  end
+
+  def test_wrong_association_in_foreign_filter
+    exception = assert_raises RuntimeError do
+      Tag.objects.filter('posts::bad_association::name': 'Dialogues').order_by(%i[name ASC])
+    end
+    assert_equal(
+      'Bad selection path: posts::bad_association::name. bad_association not found in model Post when filtering Tag objects',
+      exception.message
+    )
+  end
+
+  def test_wrong_field_name_of_foreign_model
+    exception = assert_raises RuntimeError do
+      Tag.objects.filter('posts::category::xxx': 'Dialogues').order_by(%i[name ASC])
+    end
+    assert_equal(
+      'Unrecognized field xxx for model Category in filter/exclude',
+      exception.message
+    )
+  end
+
+  def test_wrong_parameter_passed_to_filter
+    exception = assert_raises RuntimeError do
+      Tag.objects.filter('INVALID VALUE').order_by(%i[name ASC])
+    end
+    assert_equal(
+      '`filter\' parameter must be an Array for OR-based AND-conditions or a hash for a lone AND-condition',
+      exception.message
+    )
+  end
+
+end

data/test/select/for_update_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Tests of for_update method
+class ForUpdateTest < Minitest::Test
+
+  def test_for_update_sql
+    queryset = User.objects.for_update.filter(first_name: 'Marcus')
+    assert queryset.sql.select.match?('FOR UPDATE'), queryset.sql.select
+  end
+
+  def test_lock_sql
+    queryset = User.objects.lock.filter(first_name: 'Marcus')
+    assert queryset.sql.select.match?('FOR UPDATE'), queryset.sql.select
+  end
+
+end

data/test/select/foreign_selection_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+class ForeignSelectionTest < Minitest::Test
+
+  def test_equal_in_belongs_to_relationship
+    foreign_selection = Babik::Selection::ForeignSelection.new(User, 'zone::name', 'Rome')
+    assert_equal foreign_selection.model, User
+    assert_equal foreign_selection.associations, [User.reflect_on_association(:zone)]
+    assert_equal foreign_selection.selection_path, 'zone::name'
+    assert_equal foreign_selection.selected_field, 'name'
+    assert_equal foreign_selection.value, 'Rome'
+    assert_equal foreign_selection.operator, 'equal'
+    assert_equal foreign_selection.sql_where_condition.to_s, 'users__zone_0.name = \'Rome\''
+  end
+
+  def test_equal_in_belongs_to_deep_relationship
+    foreign_selection = Babik::Selection::ForeignSelection.new(User, 'zone::parent_zone::name', 'Rome')
+    assert_equal foreign_selection.model, User
+
+    user_to_zone_association = User.reflect_on_association(:zone)
+    _associations_are_equal(foreign_selection.associations[0], user_to_zone_association)
+
+    zone_to_parent_zone_association = GeoZone.reflect_on_association(:parent_zone)
+    _associations_are_equal(foreign_selection.associations[1], zone_to_parent_zone_association)
+
+    assert_equal foreign_selection.selection_path, 'zone::parent_zone::name'
+    assert_equal foreign_selection.selected_field, 'name'
+    assert_equal foreign_selection.value, 'Rome'
+    assert_equal foreign_selection.operator, 'equal'
+    assert_equal foreign_selection.sql_where_condition.to_s, 'geo_zones__parent_zone_1.name = \'Rome\''
+  end
+
+  def test_equal_in_has_many_relationship
+    foreign_selection = Babik::Selection::ForeignSelection.new(User, 'posts::tags::name', 'Funny')
+    assert_equal foreign_selection.model, User
+    assert_equal foreign_selection.selection_path, 'posts::tags::name'
+    assert_equal foreign_selection.selected_field, 'name'
+    assert_equal foreign_selection.value, 'Funny'
+    assert_equal foreign_selection.operator, 'equal'
+
+    assert_equal foreign_selection.sql_where_condition.to_s, 'post_tags__tag_2.name = \'Funny\''
+  end
+
+  def _associations_are_equal(association1, association2)
+    assert_equal association1.active_record, association2.active_record
+    assert_equal association1.name, association2.name
+    %w[foreign_key class_name optional].each do |option_key|
+      if association1.options[option_key].nil? || association2.options[option_key].nil?
+        assert_nil association1.options[option_key]
+        assert_nil association2.options[option_key]
+      else
+        assert_equal association1.options[option_key], association2.options[option_key]
+      end
+    end
+  end
+
+end

data/test/select/get_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Test for get method of QuerySet
+class GetTest < Minitest::Test
+
+  def setup
+    User.create!(first_name: 'Rollo', last_name: 'Lothbrok')
+    User.create!(first_name: 'Ragnar', last_name: 'Lothbrok')
+    User.create!(first_name: 'Sigurd', last_name: 'Ring')
+    User.create!(first_name: 'Freydis', last_name: 'Eriksdottir')
+    User.create!(first_name: 'Harald', last_name: 'Hardrada')
+  end
+
+  def teardown
+    User.delete_all
+  end
+
+  def test_get_ok
+    freydis = User.objects.get(last_name: 'Eriksdottir')
+    assert_equal 'Freydis', freydis.first_name
+    assert_equal 'Eriksdottir', freydis.last_name
+  end
+
+  def test_get_not_found
+    exception = assert_raises RuntimeError do
+      User.objects.get(last_name: 'Last name that does not exist')
+    end
+    assert_equal('Does not exist', exception.message)
+  end
+
+  def test_get_not_several_objects_returned
+    exception = assert_raises RuntimeError do
+      User.objects.get(last_name: 'Lothbrok')
+    end
+    assert_equal('Multiple objects returned', exception.message)
+  end
+end