rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/integration/associations/many_to_many_spec.rb

@@ -1,162 +0,0 @@
-RSpec.describe ROM::SQL::Associations::ManyToMany, helpers: true do
-  include_context 'users and tasks'
-
-  with_adapters do
-    context 'through a relation with a composite PK' do
-      subject(:assoc) do
-        build_assoc(:many_to_many, :tasks, :tags, through: :task_tags)
-      end
-
-      let(:tags) { relations[:tags] }
-
-      before do
-        conf.relation(:task_tags) do
-          schema(infer: true) do
-            associations do
-              belongs_to :task
-              belongs_to :tag
-            end
-          end
-        end
-
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            associations do
-              has_many :task_tags
-              has_many :tags, through: :task_tags
-            end
-          end
-        end
-      end
-
-      describe '#result' do
-        specify { expect(assoc.result).to be(:many) }
-      end
-
-      describe '#combine_keys' do
-        specify { expect(assoc.combine_keys).to eql(id: :task_id) }
-      end
-
-      describe '#call' do
-        it 'prepares joined relations' do
-          relation = assoc.()
-
-          expect(relation.schema.map(&:to_sql_name)).
-            to eql([Sequel.qualify(:tags, :id),
-                    Sequel.qualify(:tags, :name),
-                    Sequel.qualify(:task_tags, :task_id)])
-          expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
-        end
-      end
-
-      describe ':through another assoc' do
-        subject(:assoc) do
-          build_assoc(:many_to_many, :users, :tags, through: :tasks)
-        end
-
-        it 'prepares joined relations through other association' do
-          relation = assoc.()
-
-          expect(relation.schema.map(&:to_sql_name)).
-            to eql([Sequel.qualify(:tags, :id),
-                    Sequel.qualify(:tags, :name),
-                    Sequel.qualify(:tasks, :user_id)])
-          expect(relation.to_a).to eql([id: 1, name: 'important', user_id: 2])
-        end
-      end
-
-      describe '#eager_load' do
-        it 'preloads relation based on association' do
-          relation = tags.eager_load(assoc).call(tasks.call)
-
-          expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
-        end
-
-        it 'maintains original relation' do
-          relation = tags.
-                       select_append(tags[:name].as(:tag)).
-                       eager_load(assoc).call(tasks.call)
-
-          expect(relation.to_a).to eql([id: 1, tag: 'important', name: 'important', task_id: 1])
-        end
-
-        it 'respects custom order' do
-          conn[:tags].insert id: 2, name: 'boring'
-          conn[:task_tags].insert(tag_id: 2, task_id: 1)
-
-          relation = tags.
-                       order(tags[:name].qualified).
-                       eager_load(assoc).call(tasks.call)
-
-          expect(relation.to_a).
-            to eql([
-                     { id: 2, name: 'boring', task_id: 1 },
-                     { id: 1, name: 'important', task_id: 1 }
-                   ])
-        end
-      end
-    end
-
-    context 'with two associations pointing to the same target relation' do
-      before do
-        inferrable_relations.concat %i(users_tasks)
-      end
-
-      before do
-        conn.create_table(:users_tasks) do
-          foreign_key :user_id, :users
-          foreign_key :task_id, :tasks
-          primary_key [:user_id, :task_id]
-        end
-
-        conf.relation(:users) do
-          schema(infer: true) do
-            associations do
-              has_many :users_tasks
-              has_many :tasks, through: :users_tasks
-              has_many :tasks, as: :priv_tasks
-            end
-          end
-        end
-
-        conf.relation(:users_tasks) do
-          schema(infer: true) do
-            associations do
-              belongs_to :user
-              belongs_to :task
-            end
-          end
-        end
-
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            associations do
-              has_many :users_tasks
-              has_many :users, through: :users_tasks
-            end
-          end
-        end
-      end
-
-      it 'does not conflict with two FKs' do
-        users = container.relations[:users]
-        tasks = container.relations[:tasks]
-        assoc = users.associations[:tasks]
-
-        relation = tasks.eager_load(assoc).call(users.call)
-
-        expect(relation.to_a).to be_empty
-      end
-
-      it 'preloads using FK' do
-        users = container.relations[:users]
-        tasks = container.relations[:tasks]
-        assoc = users.associations[:priv_tasks]
-
-        relation = tasks.eager_load(assoc).call(users.where(id: 2).call)
-
-        expect(relation.to_a).to eql([id: 1, user_id: 2, title: "Joe's task"])
-      end
-    end
-  end
-end

data/spec/integration/associations/many_to_one/custom_fks_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Associations::ManyToOne, '#call' do
-  include_context 'database setup'
-
-  before do
-    inferrable_relations.concat %i(destinations flights)
-  end
-
-  let(:assoc_from) { relations[:flights].associations[:from] }
-  let(:assoc_to) { relations[:flights].associations[:to] }
-
-  with_adapters do
-    before do
-      conn.create_table(:destinations) do
-        primary_key :id
-        column :name, String, null: false
-      end
-
-      conn.create_table(:flights) do
-        primary_key :id
-        foreign_key :from_id, :destinations, null: false
-        foreign_key :to_id, :destinations, null: false
-        column :code, String, null: false
-      end
-
-      conf.relation(:destinations) { schema(infer: true) }
-
-      conf.relation(:flights) do
-        schema(infer: true) do
-          associations do
-            belongs_to :destination, as: :from, foreign_key: :from_id
-            belongs_to :destination, as: :to, foreign_key: :to_id
-          end
-        end
-      end
-
-      from_id = relations[:destinations].insert(name: 'FROM')
-      to_id = relations[:destinations].insert(name: 'TO')
-
-      relations[:flights].insert(code: 'F1', from_id: from_id, to_id: to_id)
-    end
-
-    it 'prepares joined relations using correct FKs based on association aliases' do
-      relation = assoc_from.()
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:destinations, :id),
-                Sequel.qualify(:destinations, :name),
-                Sequel.qualify(:flights, :id).as(:flight_id)])
-
-      expect(relation.first).to eql(id: 1, name: 'FROM', flight_id: 1)
-
-      relation = assoc_to.()
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:destinations, :id),
-                Sequel.qualify(:destinations, :name),
-                Sequel.qualify(:flights, :id).as(:flight_id)])
-
-      expect(relation.first).to eql(id: 2, name: 'TO', flight_id: 1)
-    end
-  end
-end

data/spec/integration/associations/many_to_one/from_view_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Associations::ManyToOne, '#call' do
-  include_context 'database setup'
-
-  before do
-    inferrable_relations.concat %i(destinations flights)
-  end
-
-  let(:assoc_inter) { relations[:flights].associations[:inter_destination] }
-  let(:assoc_final) { relations[:flights].associations[:final_destination] }
-
-  with_adapters do
-    before do
-      conn.create_table(:destinations) do
-        primary_key :id
-        column :name, String, null: false
-        column :intermediate, TrueClass, null: false, default: false
-      end
-
-      conn.create_table(:flights) do
-        primary_key :id
-        foreign_key :destination_id, :destinations, null: false
-        column :code, String, null: false
-      end
-
-      conf.relation(:destinations) do
-        schema(infer: true)
-
-        view(:intermediate, schema) do
-          where(intermediate: true)
-        end
-
-        view(:final, schema) do
-          where(intermediate: false)
-        end
-      end
-
-      conf.relation(:flights) do
-        schema(infer: true) do
-          associations do
-            belongs_to :destination, as: :inter_destination, view: :intermediate
-            belongs_to :destination, as: :final_destination, view: :final
-          end
-        end
-      end
-
-      final_id = relations[:destinations].insert(name: 'Final')
-      inter_id = relations[:destinations].insert(name: 'Intermediate', intermediate: true)
-
-      relations[:flights].insert(code: 'F1', destination_id: inter_id)
-      relations[:flights].insert(code: 'F2', destination_id: final_id)
-    end
-
-    after do
-      conn.drop_table(:flights)
-      conn.drop_table(:destinations)
-    end
-
-    it 'prepares joined relations using custom view in target relation' do
-      relation = assoc_inter.()
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:destinations, :id),
-                Sequel.qualify(:destinations, :name),
-                Sequel.qualify(:destinations, :intermediate),
-                Sequel.qualify(:flights, :id).as(:flight_id)])
-
-      expect(relation.first).to eql(id: 2, intermediate: db_true, name: 'Intermediate', flight_id: 1)
-      expect(relation.count).to be(1)
-
-      relation = assoc_final.()
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:destinations, :id),
-                Sequel.qualify(:destinations, :name),
-                Sequel.qualify(:destinations, :intermediate),
-                Sequel.qualify(:flights, :id).as(:flight_id)])
-
-      expect(relation.first).to eql(id: 1, intermediate: db_false, name: 'Final', flight_id: 2)
-      expect(relation.count).to be(1)
-    end
-  end
-end

data/spec/integration/associations/many_to_one/self_ref_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Associations::ManyToOne, '#call' do
-  subject(:assoc) do
-    relations[:categories].associations[:parent]
-  end
-
-  include_context 'database setup'
-
-  with_adapters do
-    before do
-      conn.create_table(:categories) do
-        primary_key :id
-        foreign_key :parent_id, :categories, null: true
-        column :name, String, null: false
-      end
-
-      conf.relation(:categories) do
-        schema(infer: true) do
-          associations do
-            belongs_to :categories, as: :parent, foreign_key: :parent_id
-          end
-        end
-      end
-
-      p1_id = relations[:categories].insert(name: 'P1')
-      p2_id = relations[:categories].insert(name: 'P2')
-      relations[:categories].insert(name: 'C3', parent_id: p2_id)
-      relations[:categories].insert(name: 'C4', parent_id: p1_id)
-      relations[:categories].insert(name: 'C5', parent_id: p1_id)
-    end
-
-    after do
-      conn.drop_table(:categories)
-    end
-
-    it 'prepares joined relations using custom FK for a self-ref association' do
-      relation = assoc.()
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:categories, :id),
-                Sequel.qualify(:categories, :parent_id),
-                Sequel.qualify(:categories, :name)])
-
-      expect(relation.to_a).
-        to eql([
-                 { id: 1, parent_id: nil, name: 'P1' },
-                 { id: 1, parent_id: nil, name: 'P1' },
-                 { id: 2, parent_id: nil, name: 'P2' }
-               ])
-    end
-  end
-end

data/spec/integration/associations/many_to_one_spec.rb

@@ -1,117 +0,0 @@
-RSpec.describe ROM::SQL::Associations::ManyToOne, helpers: true do
-  with_adapters do
-    context 'common name conventions' do
-      include_context 'users and tasks'
-      include_context 'accounts'
-
-      subject(:assoc) do
-        build_assoc(:many_to_one, :tasks, :users)
-      end
-
-      before do
-        conf.relation(:tasks) do
-          schema(infer: true)
-        end
-      end
-
-      describe '#name' do
-        it 'uses target by default' do
-          expect(assoc.name).to be(:users)
-        end
-      end
-
-      describe '#result' do
-        specify { expect(assoc.result).to be(:one) }
-      end
-
-      describe '#combine_keys' do
-        specify { expect(assoc.combine_keys).to eql(user_id: :id) }
-      end
-
-      describe '#call' do
-        it 'prepares joined relations' do
-          relation = assoc.(preload: false)
-
-          expect(relation.schema.map(&:to_sql_name)).
-            to eql([Sequel.qualify(:users, :id),
-                    Sequel.qualify(:users, :name),
-                    Sequel.qualify(:tasks, :id).as(:task_id)])
-
-          expect(relation.where(user_id: 1).one).to eql(id: 1, task_id: 2, name: 'Jane')
-
-          expect(relation.where(user_id: 2).one).to eql(id: 2, task_id: 1, name: 'Joe')
-
-          expect(relation.to_a).
-            to eql([
-                     { id: 1, task_id: 2, name: 'Jane' },
-                     { id: 2, task_id: 1, name: 'Joe' }
-                   ])
-        end
-      end
-
-      describe '#eager_load' do
-        it 'preloads relation based on association' do
-          relation = users.eager_load(assoc).call(tasks.call)
-
-          expect(relation.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }])
-        end
-
-        it 'maintains original relation' do
-          users.accounts.insert(user_id: 2, number: '31', balance: 0)
-
-          relation = users.
-                       join(:accounts, user_id: :id).
-                       select_append(users.accounts[:number].as(:account_num)).
-                       order(:account_num).
-                       eager_load(assoc).call(tasks.call)
-
-          expect(relation.to_a).
-            to eql([{ id: 2, name: 'Joe', account_num: '31' },
-                    { id: 1, name: 'Jane', account_num: '42' }])
-        end
-      end
-    end
-
-    context 'arbitrary name conventions' do
-      include_context 'users'
-      include_context 'posts'
-
-      let(:articles_name) { ROM::Relation::Name[:articles, :posts] }
-      let(:articles) { container.relations[:articles] }
-
-      subject(:assoc) do
-        build_assoc(:many_to_one, articles_name, :users)
-      end
-
-      before do
-        conf.relation(:articles) do
-          schema(:posts, infer: true)
-        end
-      end
-
-      describe '#call' do
-        it 'prepares joined relations' do
-          relation = assoc.()
-
-          expect(relation.schema.map(&:to_sql_name)).
-            to eql([Sequel.qualify(:users, :id),
-                    Sequel.qualify(:users, :name),
-                    Sequel.qualify(:posts, :post_id)])
-
-          expect(relation.order(:id).to_a).to eql([
-            { id: 1, name: 'Jane', post_id: 2 },
-            { id: 2, name: 'Joe', post_id: 1 }
-          ])
-
-          expect(relation.where(author_id: 1).to_a).to eql(
-            [id: 1, name: 'Jane', post_id: 2]
-          )
-
-          expect(relation.where(author_id: 2).to_a).to eql(
-            [id: 2, name: 'Joe', post_id: 1]
-          )
-        end
-      end
-    end
-  end
-end