babik 0.1.0

data/test/select/project_test.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Project method test
+class ProjectTest < Minitest::Test
+
+  def setup
+    if GeoZone.objects.filter(name: 'Castilla').exists?
+      return
+    end
+    @castille = GeoZone.create!(name: 'Castilla')
+    ['Juan II', 'Isabel I', 'Juana I'].each do |name|
+      User.create!(first_name: name, last_name: 'de Castilla', email: "#{name.downcase.delete(' ')}@example.com", zone: @castille)
+    end
+    @spain = GeoZone.create!(name: 'España')
+    ['Carlos I', 'Felipe II', 'Felipe III'].each do |name|
+      User.create!(first_name: name, last_name: 'de Austria', email: "#{name.downcase.delete(' ')}@example.com", zone: @spain)
+    end
+  end
+
+  def teardown
+    User.destroy_all
+    GeoZone.destroy_all
+  end
+
+  def test_project
+    users_projection = User.objects
+                           .filter('zone::name': 'Castilla')
+                           .order_by('first_name')
+                           .project('first_name', 'email')
+
+    local_projection_expectation = [
+      { first_name: 'Isabel I', email: 'isabeli@example.com' },
+      { first_name: 'Juan II', email: 'juanii@example.com' },
+      { first_name: 'Juana I', email: 'juanai@example.com' }
+    ]
+
+    assert users_projection.projection?
+    users_projection.each_with_index do |user_projection, user_projection_index|
+      assert_equal local_projection_expectation[user_projection_index], user_projection.symbolize_keys
+    end
+  end
+
+  def test_no_projection
+    users_projection = User.objects
+                           .filter('zone::name': 'Castilla')
+                           .order_by('first_name')
+    refute users_projection.projection?
+  end
+
+  def test_foreign_field_project
+    users_projection = User.objects
+                           .filter('zone::name': 'Castilla')
+                           .order_by('first_name')
+                           .project('first_name', 'email', %w[zone::name country])
+    foreign_projection_expectation = [
+      { first_name: 'Isabel I', email: 'isabeli@example.com', country: 'Castilla' },
+      { first_name: 'Juan II', email: 'juanii@example.com', country: 'Castilla' },
+      { first_name: 'Juana I', email: 'juanai@example.com', country: 'Castilla' }
+    ]
+
+    assert users_projection.projection?
+    users_projection.each_with_index do |user_projection, user_projection_index|
+      assert_equal foreign_projection_expectation[user_projection_index], user_projection.symbolize_keys
+    end
+  end
+
+  def test_explicit_transform
+    datetime_format = '%Y-%m-%d %H:%M:%S'
+    datetime_transformer = ->(datetime) { datetime.strftime(datetime_format) }
+    users = User.objects.filter('zone::name': 'Castilla').order_by('first_name')
+    users_projection = users.project(
+      ['first_name', ->(s) { s.upcase }], 'email',
+      ['created_at', 'creation_date', ->(d) { datetime_transformer.call(Time.parse(d.to_s + 'UTC')) }]
+    )
+    users_projection.each_with_index do |user_projection, user_index|
+      assert_equal users[user_index].first_name.upcase, user_projection[:first_name]
+      assert_equal users[user_index].email, user_projection[:email]
+      assert_equal users[user_index].created_at.strftime(datetime_format), user_projection[:creation_date]
+      assert_equal users[user_index].created_at.strftime(datetime_format).class, user_projection[:creation_date].class
+    end
+  end
+
+  def test_wrong_transform_params
+    exception = assert_raises RuntimeError do
+      datetime_format = '%Y-%m-%d %H:%M:%S'
+      datetime_transformer = ->(datetime) { datetime.strftime(datetime_format) }
+      users = User.objects.filter('zone::name': 'Castilla').order_by('first_name')
+      users.project(
+        ['first_name', 2], 'email',
+        ['created_at', 'creation_date', ->(d) { datetime_transformer.call(Time.parse(d.to_s + 'UTC')) }]
+      )
+    end
+    assert_equal('Babik::QuerySet::ProjectedField.new only accepts String/Symbol or Proc. Passed a Integer.', exception.message)
+  end
+
+  def test_wrong_params
+    exception = assert_raises RuntimeError do
+      users = User.objects.filter('zone::name': 'Castilla').order_by('first_name')
+      users.project('first_name', 'email', 2222)
+    end
+    assert_equal('No other parameter type is permitted in Babik::QuerySet::ProjectedField.new than Array, String and Symbol.', exception.message)
+  end
+
+end

data/test/select/select_related_test.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Select related method test
+class SelectRelatedTest < Minitest::Test
+
+  def setup
+    @baetica = GeoZone.create!(name: 'Baetica')
+    @corduba = GeoZone.create!(name: 'Corduba', parent_zone: @baetica)
+    @seneca_sr = User.create!(first_name: 'Marcus Annaeus', last_name: 'Seneca', zone: @corduba)
+    @seneca_jr = User.create!(first_name: 'Lucius Annaeus', last_name: 'Seneca', zone: @corduba)
+
+    @africa = GeoZone.create!(name: 'Africa')
+    @cartago = GeoZone.create!(name: 'Cartago', parent_zone: @africa)
+    @tertullianus = User.create!(first_name: 'Quintus Septimius', last_name: 'Florens Tertullianus', zone: @cartago)
+
+    short_stories = Category.create(name: 'Short stories')
+    legal = Category.create(name: 'Legal texts')
+    oratory = Category.create(name: 'Oratory')
+    Post.create!(title: 'Gesta Romanorum', author: @seneca_sr, category: short_stories)
+    Post.create!(title: 'Controversiae', author: @seneca_sr, category: legal)
+    Post.create!(title: 'Suasoriae', author: @seneca_sr, category: oratory)
+
+    stoic_texts = Category.create(name: 'Stoic texts')
+    Post.create!(title: 'De brevitate vitae', author: @seneca_jr, category: stoic_texts)
+    Post.create!(title: 'Epistulae Morales ad Lucilium', author: @seneca_jr, category: stoic_texts)
+    Post.create!(title: 'De tranquillitate animi', author: @seneca_jr, category: stoic_texts)
+  end
+
+  def teardown
+    GeoZone.destroy_all
+    User.destroy_all
+    Category.destroy_all
+    Post.destroy_all
+  end
+
+  def test_wrong_select_related
+    exception = assert_raises RuntimeError do
+      User
+        .objects
+        .filter(zone__in: [@corduba.id, @cartago.id])
+        .select_related(:xxxxx)[0]
+    end
+    assert_equal(
+      'Bad selection path: xxxxx. xxxxx not found in model User when filtering User objects',
+      exception.message
+    )
+
+  end
+
+  def test_select_related
+    users = User.objects.order_by('first_name')
+    number_of_users = User.objects.count
+    number_of_returned_users = 0
+
+    User
+      .objects
+      .filter(zone__in: [@corduba.id, @cartago.id])
+      .select_related(:zone)
+      .order_by('first_name')
+      .each_with_index do |user_with_related, user_with_related_index|
+      # Loop through each user with his/her related objects
+      user, select_related = user_with_related
+      # User tests
+      expected_user = users[user_with_related_index]
+      assert_equal User, user.class
+      assert_equal expected_user.id, user.id
+      assert_equal expected_user, user
+      # Zone tests
+      expected_zone = expected_user.zone
+      assert_equal GeoZone, select_related[:zone].class
+      assert_equal user.zone_id, select_related[:zone].id
+      assert_equal expected_zone, select_related[:zone]
+      # Users count
+      number_of_returned_users += 1
+    end
+    assert_equal number_of_users, number_of_returned_users
+  end
+
+  def test_select_related_several_associations
+    expected_posts = Post.objects.filter(author: @seneca_sr).order_by(title: :DESC)
+    posts = Post.objects
+                .filter(author: @seneca_sr)
+                .order_by(title: :DESC)
+                .select_related([:author, :category])
+    _test_select_related_posts(expected_posts, posts)
+  end
+
+  def test_select_related_several_associations_from_instance
+    expected_posts = Post.objects.filter(author: @seneca_sr).order_by(title: :DESC)
+    posts = @seneca_sr.objects(:posts)
+                      .order_by(title: :DESC)
+                      .select_related([:author, :category])
+    _test_select_related_posts(expected_posts, posts)
+  end
+
+  def _test_select_related_posts(expected_posts, posts)
+    # Load the posts with 4 or more stars with their author and category
+    posts.each_with_index do |post_with_author_category, index|
+      # Load post and its two associated objects
+      post, foreign_objects = post_with_author_category
+      author = foreign_objects[:author]
+      category = foreign_objects[:category]
+      # Check post
+      expected_post = expected_posts[index]
+      assert_equal Post, post.class
+      assert_equal expected_post.id, post.id
+      assert_equal expected_post, post
+      # Check author (user)
+      assert_equal User, author.class
+      assert_equal post.author_id, author.id
+      assert_equal post.author, author
+      # Check category
+      assert_equal Category, category.class
+      assert_equal post.category_id, category.id
+      assert_equal post.category, category
+    end
+  end
+
+
+
+end

data/test/select/subquery_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Subquery test
+class SubqueryTest < Minitest::Test
+
+  def setup
+    @baetica = GeoZone.create!(name: 'Baetica')
+    @corduba = GeoZone.create!(name: 'Corduba', parent_zone: @baetica)
+    @seneca_sr = User.create!(first_name: 'Marcus Annaeus', last_name: 'Seneca', zone: @corduba)
+    short_stories = Category.create(name: 'Short stories')
+    legal = Category.create(name: 'Legal texts')
+    oratory = Category.create(name: 'Oratory')
+    Post.create!(title: 'Gesta Romanorum', author: @seneca_sr, category: short_stories)
+    Post.create!(title: 'Controversiae', author: @seneca_sr, category: legal)
+    Post.create!(title: 'Suasoriae', author: @seneca_sr, category: oratory)
+  end
+
+  def teardown
+    GeoZone.destroy_all
+    User.destroy_all
+    Category.destroy_all
+    Post.destroy_all
+  end
+
+  def test_subquery_with_equal
+    seneca_sr_posts = Post.objects.filter(id: @seneca_sr.objects(:posts).project(:id))
+    assert_equal @seneca_sr.objects(:posts).count, seneca_sr_posts.count
+    seneca_sr_posts_count = 0
+    seneca_sr_posts.each do |post|
+      assert_equal @seneca_sr.id, post.author_id
+      seneca_sr_posts_count += 1
+    end
+    assert_equal seneca_sr_posts_count, seneca_sr_posts.count
+  end
+
+  def test_subquery_with_in
+    seneca_sr_posts = Post.objects.filter(id__in: @seneca_sr.objects(:posts).project(:id))
+    assert_equal @seneca_sr.objects(:posts).count, seneca_sr_posts.count
+    seneca_sr_posts_count = 0
+    seneca_sr_posts.each do |post|
+      assert_equal @seneca_sr.id, post.author_id
+      seneca_sr_posts_count += 1
+    end
+    assert_equal seneca_sr_posts_count, seneca_sr_posts.count
+  end
+
+end

data/test/set_operations/basic_usage_test.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../test_helper'
+
+# Class for basic set operation tests
+class BasicUsageTest < Minitest::Test
+
+  def setup
+
+    patrician_families = %w[
+      Aebutia Aemilia Aquillia Atilia Claudia Cloelia Cornelia Curtia
+      Fabia Foslia Furia Gegania Genucia Herminia Horatia Julia Lartia
+      Lucretia Manlia Menenia Metilia Minucia Mucia Nautia Numicia Papiria
+      Pinaria Pollia Postumia Potitia Quinctia Quinctilia Romilia
+      Sempronia Sergia Servilia Sestia Siccia Sulpicia Tarpeia Tarquinia
+      Tarquitia Tullia Valeria Verginia Veturia Vitellia Volumnia
+    ]
+    roman_names = %w[
+      Aeliana Albia Antonia Aquilia Argentia Atticus Augusta Augustus Aurelia Aurelius Avita Caesar Camilla
+      Cassia Cassius Cato Cecilia Cicero Claudia Claudius Clemensia Cornelius Crispus Cyprian Decima Decimus
+      Drusilla Dulcia Fabia Faustina Felix Flavia Florentina Fortunata Gaia Galla Hilaria Horatia Julia Julius
+      Junia Justus Laelia Laurentia Livia Lucius Lucretia Magnus Marcella Marcus Marilla Marius Martia Maxima
+      Maximus Mila Nerilla Nero Octavia Octavius Philo Prima Priscilla Quintia Quintus Remus Romulus Rufina
+      Rufus Sabina Seneca Septima Septimus Sergia Tanaquil Tatiana Tauria Tertia Tiberius Tullia Urban Urbana
+      Valentina Varinia Vita
+    ]
+
+    random_generator = Random.new(1234)
+    patrician_families.each do |family_name|
+      roman_names.each do |roman_name|
+        User.create!(first_name: roman_name, last_name: family_name) if random_generator.rand(0..1) == 1
+      end
+    end
+
+  end
+
+  def teardown
+    User.destroy_all
+  end
+
+  def test_union
+    claudia = User.objects.filter(last_name: 'Claudia')
+    verturia = User.objects.filter(last_name: 'Veturia')
+    both_families = claudia.union(verturia).order_by!({ last_name: :DESC }, { first_name: :ASC })
+    both_families_without_union = User.where(last_name: ['Claudia', 'Veturia']).order(last_name: :DESC, first_name: :ASC)
+    _check_set_operation(both_families_without_union, both_families)
+  end
+
+  def test_chained_union
+    families = User.objects.filter(last_name: 'Aebutia')
+                   .union(User.objects.filter(last_name: 'Fabia'))
+                   .union(User.objects.filter(last_name: 'Atilia'))
+                   .union(User.objects.filter(last_name: 'Claudia'))
+                   .union(User.objects.filter(last_name: 'Cloelia'))
+                   .order_by!({last_name: :DESC}, {first_name: :ASC})
+    families_without_union = User.where(last_name: ['Aebutia', 'Fabia', 'Atilia', 'Claudia', 'Cloelia'])
+                                  .order(last_name: :DESC, first_name: :ASC)
+    _check_set_operation(families_without_union, families)
+  end
+
+  def test_deep_union
+    claudia = User.objects.filter(last_name: 'Claudia')
+    verturia = User.objects.filter(last_name: 'Veturia')
+    aemilia = User.objects.filter(last_name: 'Aemilia')
+    three_families = claudia.union(verturia).union(aemilia).order_by!({ last_name: :DESC }, { first_name: :ASC })
+    three_families_without_union = User
+                                   .where(last_name: ['Claudia', 'Veturia', 'Aemilia'])
+                                   .order(last_name: :DESC, first_name: :ASC)
+    _check_set_operation(three_families_without_union, three_families)
+  end
+
+  def test_intersection
+    first_user = User.objects.first
+    qs_with_intersection = User.objects.filter(first_name: first_user.first_name)
+                               .intersection(User.objects.filter(last_name: first_user.last_name))
+                               .order_by!({ last_name: :DESC }, { first_name: :ASC })
+    qs_without_intersection = User.where(first_name: first_user.first_name, last_name: first_user.last_name)
+                                      .order(last_name: :DESC, first_name: :ASC)
+    _check_set_operation(qs_without_intersection, qs_with_intersection)
+  end
+
+  def test_deep_intersection
+    first_user = User.objects.first
+    qs_with_intersection = User.objects.filter(first_name: first_user.first_name)
+                               .intersection(User.objects.filter(last_name: first_user.last_name))
+                               .intersection(User.objects.filter(created_at__lt: Time.now))
+                               .order_by!({ last_name: :DESC }, { first_name: :ASC })
+    qs_without_intersection = User.where(first_name: first_user.first_name, last_name: first_user.last_name)
+                                .order(last_name: :DESC, first_name: :ASC)
+    _check_set_operation(qs_without_intersection, qs_with_intersection)
+  end
+
+  def test_difference
+    first_user = User.objects.first
+    qs_with_minus = User.objects
+                        .filter(last_name: first_user.last_name)
+                        .difference(User.objects.filter(first_name: first_user.first_name))
+                        .order_by!({ last_name: :DESC }, { first_name: :ASC })
+    qs_without_minus = User.where(last_name: first_user.last_name)
+                           .where.not(first_name: first_user.first_name)
+                           .order(last_name: :DESC, first_name: :ASC)
+    _check_set_operation(qs_without_minus, qs_with_minus)
+  end
+
+  # Check a set-operation based queryset is correct
+  def _check_set_operation(expected_qs, actual_qs)
+    record_count = 0
+    expected_qs.each_with_index do |expected_qs_record, expected_qs_record_index|
+      actual_qs_record = actual_qs[expected_qs_record_index]
+      assert_equal expected_qs_record.id, actual_qs_record.id
+      assert_equal expected_qs_record.last_name, actual_qs_record.last_name
+      assert_equal expected_qs_record.first_name, actual_qs_record.first_name
+      assert_equal expected_qs_record.last_name, actual_qs_record.last_name
+      record_count += 1
+    end
+    assert_equal expected_qs.count, actual_qs.count
+    assert_equal expected_qs.count, record_count
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+# Setup the log
+require 'fileutils'
+FileUtils.mkpath 'log' unless File.directory? 'log'
+ActiveRecord::Base.logger = Logger.new('log/test-queries.log')
+
+DEFAULT_DB_ADAPTER = 'sqlite3'
+#DEFAULT_DB_ADAPTER = 'mysql2'
+#DEFAULT_DB_ADAPTER = 'postgresql'
+
+# Make a connection
+adapter = ENV.fetch('DB', DEFAULT_DB_ADAPTER)
+case adapter
+when 'mysql2', 'postgresql'
+  config = {
+    host: '127.0.0.1',
+    database: 'babik_test',
+    encoding: 'utf8',
+    min_messages: 'WARNING',
+    adapter: adapter,
+    username: ENV['DB_USERNAME'] || 'postgres',
+    password: ENV['DB_PASSWORD'] || 'postgres'
+  }
+  ActiveRecord::Tasks::DatabaseTasks.create(config.stringify_keys)
+  ActiveRecord::Base.establish_connection(config)
+when 'sqlite3'
+  ActiveRecord::Base.establish_connection adapter: adapter, database: ':memory:'
+else
+  raise "Unknown DB adapter #{adapter}. Valid adapters are: mysql2, postgresql, sqlite3."
+end
+
+# Load babik library
+require 'babik'
+
+# Create tables
+load "#{__dir__}/config/db/schema.rb"
+
+# Load models
+require 'config/models/geozone'
+require 'config/models/user'
+require 'config/models/tag'
+require 'config/models/category'
+require 'config/models/post'
+require 'config/models/post_tag'
+require 'config/models/bad_tag'
+require 'config/models/bad_post'
+
+
+