rom-sql 0.9.1 → 1.0.0.beta1

data/spec/integration/association/many_to_many/from_view_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
+  subject(:assoc) do
+    relations[:users].associations[:solved_puzzles]
+  end
+
+  include_context 'database setup'
+
+  with_adapters do
+    before do
+      conn.create_table(:puzzles) do
+        primary_key :id
+        column :text, String, null: false
+        column :solved, TrueClass, null: false, default: false
+      end
+
+      conn.create_table(:puzzle_solvers) do
+        foreign_key :user_id, :users, null: false
+        foreign_key :puzzle_id, :puzzles, null: false
+        primary_key [:user_id, :puzzle_id]
+      end
+
+      conf.relation(:puzzles) do
+        schema(infer: true)
+
+        view(:solved, schema) do
+          where(solved: true)
+        end
+      end
+
+      conf.relation(:puzzle_solvers) do
+        schema(infer: true) do
+          associations do
+            belongs_to :user
+            belongs_to :puzzle
+          end
+        end
+      end
+
+      conf.relation(:users) do
+        schema(infer: true) do
+          associations do
+            has_many :puzzle_solvers
+            has_many :puzzles, through: :puzzle_solvers
+            has_many :puzzles, through: :puzzle_solvers, as: :solved_puzzles, view: :solved
+          end
+        end
+      end
+
+      joe_id = relations[:users].insert(name: 'Joe')
+      jane_id = relations[:users].insert(name: 'Jane')
+
+      p1_id = relations[:puzzles].insert(text: 'P1')
+      p2_id = relations[:puzzles].insert(text: 'P2', solved: true)
+      p3_id = relations[:puzzles].insert(text: 'P3')
+
+      relations[:puzzle_solvers].insert(user_id: joe_id, puzzle_id: p2_id)
+      relations[:puzzle_solvers].insert(user_id: jane_id, puzzle_id: p2_id)
+
+      relations[:puzzle_solvers].insert(user_id: joe_id, puzzle_id: p1_id)
+      relations[:puzzle_solvers].insert(user_id: jane_id, puzzle_id: p3_id)
+    end
+
+    after do
+      conn.drop_table?(:puzzle_solvers)
+      conn.drop_table?(:puzzles)
+    end
+
+    it 'prepares joined relations using custom FK' do
+      relation = assoc.call(relations).order(:puzzles__text)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i[puzzles__id puzzles__text puzzles__solved puzzle_solvers__user_id])
+
+      expect(relation.to_a).
+        to eql([
+                 { id: 2, user_id: 1, solved: true, text: 'P2' },
+                 { id: 2, user_id: 2, solved: true, text: 'P2' }
+               ])
+    end
+  end
+end

data/spec/integration/association/many_to_many_spec.rb

@@ -109,7 +109,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
       it 'prepares joined relations' do
         relation = assoc.call(container.relations)
 
-        expect(relation.attributes).to eql(%i[id name task_id])
+        expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name task_tags__task_id])
         expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
       end
     end
@@ -122,7 +122,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
       it 'prepares joined relations through other association' do
         relation = assoc.call(container.relations)
 
-        expect(relation.attributes).to eql(%i[id name user_id])
+        expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name tasks__user_id])
         expect(relation.to_a).to eql([id: 1, name: 'important', user_id: 2])
       end
     end

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

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Association::ManyToOne, '#call' do
+  let(:assoc_from) { relations[:flights].associations[:from] }
+  let(:assoc_to) { relations[:flights].associations[:to] }
+
+  include_context 'database setup'
+
+  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(: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
+
+    after do
+      conn.drop_table(:flights)
+      conn.drop_table(:destinations)
+    end
+
+    it 'prepares joined relations using correct FKs based on association aliases' do
+      relation = assoc_from.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i(destinations__id destinations__name flights__id___flight_id))
+
+      expect(relation.first).to eql(id: 1, name: 'FROM', flight_id: 1)
+
+      relation = assoc_to.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i(destinations__id destinations__name flights__id___flight_id))
+
+      expect(relation.first).to eql(id: 2, name: 'TO', flight_id: 1)
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Association::ManyToOne, '#call' do
+  let(:assoc_inter) { relations[:flights].associations[:inter_destination] }
+  let(:assoc_final) { relations[:flights].associations[:final_destination] }
+
+  include_context 'database setup'
+
+  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.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i(destinations__id destinations__name destinations__intermediate flights__id___flight_id))
+
+      expect(relation.first).to eql(id: 2, intermediate: true, name: 'Intermediate', flight_id: 1)
+      expect(relation.count).to be(1)
+
+      relation = assoc_final.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i(destinations__id destinations__name destinations__intermediate flights__id___flight_id))
+
+      expect(relation.first).to eql(id: 1, intermediate: false, name: 'Final', flight_id: 2)
+      expect(relation.count).to be(1)
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Association::OneToMany, '#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')
+      c1_id = relations[:categories].insert(name: 'C3', parent_id: p2_id)
+      c2_id = relations[:categories].insert(name: 'C4', parent_id: p1_id)
+      c3_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.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i[categories__id categories__parent_id 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/association/many_to_one_spec.rb

@@ -43,7 +43,8 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
       it 'prepares joined relations' do
         relation = assoc.call(container.relations)
 
-        expect(relation.attributes).to eql(%i[id name task_id])
+        expect(relation.schema.map(&:to_sym))
+          .to eql(%i[users__id users__name tasks__id___task_id])
 
         expect(relation.where(user_id: 1).one).to eql(id: 1, task_id: 2, name: 'Jane')
 
@@ -89,7 +90,8 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
         it 'prepares joined relations' do
           relation = assoc.call(container.relations)
 
-          expect(relation.attributes).to eql(%i[id name post_id])
+          expect(relation.schema.map(&:to_sym))
+            .to eql(%i[users__id users__name posts__post_id])
 
           expect(relation.order(:id).to_a).to eql([
             { id: 1, name: 'Jane', post_id: 2 },

data/spec/integration/association/one_to_many/custom_fks_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
+  subject(:assoc) do
+    relations[:users].associations[:solved_puzzles]
+  end
+
+  include_context 'database setup'
+
+  with_adapters do
+    before do
+      conn.create_table(:puzzles) do
+        primary_key :id
+        foreign_key :author_id, :users, null: false
+        foreign_key :solver_id, :users, null: true
+        column :text, String, null: false
+      end
+
+      conf.relation(:users) do
+        schema(infer: true) do
+          associations do
+            has_many :puzzles, as: :created_puzzles, foreign_key: :author_id
+            has_many :puzzles, as: :solved_puzzles, foreign_key: :solver_id
+          end
+        end
+      end
+
+      joe_id = relations[:users].insert(name: 'Joe')
+      jane_id = relations[:users].insert(name: 'Jane')
+
+      relations[:puzzles].insert(author_id: joe_id, text: 'P1')
+      relations[:puzzles].insert(author_id: joe_id, solver_id: jane_id, text: 'P2')
+    end
+
+    after do
+      conn.drop_table(:puzzles)
+    end
+
+    it 'prepares joined relations using custom FK' do
+      relation = assoc.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i[puzzles__id puzzles__author_id puzzles__solver_id puzzles__text])
+
+      expect(relation.first).to eql(id: 2, author_id: 1, solver_id: 2, text: 'P2')
+    end
+  end
+end

data/spec/integration/association/one_to_many/from_view_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
+  subject(:assoc) do
+    relations[:users].associations[:solved_puzzles]
+  end
+
+  include_context 'database setup'
+
+  with_adapters do
+    before do
+      conn.create_table(:puzzles) do
+        primary_key :id
+        foreign_key :user_id, :users, null: false
+        column :text, String, null: false
+        column :solved, TrueClass, null: false, default: false
+      end
+
+      conf.relation(:users) do
+        schema(infer: true) do
+          associations do
+            has_many :puzzles
+            has_many :puzzles, as: :solved_puzzles, view: :solved
+          end
+        end
+      end
+
+      conf.relation(:puzzles) do
+        schema(infer: true)
+
+        view(:solved, schema) do
+          where(solved: true)
+        end
+      end
+
+      joe_id = relations[:users].insert(name: 'Joe')
+      jane_id = relations[:users].insert(name: 'Jane')
+
+      relations[:puzzles].insert(user_id: joe_id, text: 'P1')
+      relations[:puzzles].insert(user_id: joe_id, solved: true, text: 'P2')
+    end
+
+    after do
+      conn.drop_table(:puzzles)
+    end
+
+    it 'prepares joined relations using custom view' do
+      relation = assoc.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i[puzzles__id puzzles__user_id puzzles__text puzzles__solved])
+
+      expect(relation.count).to be(1)
+      expect(relation.first).to eql(id: 2, user_id: 1, solved: true, text: 'P2')
+    end
+  end
+end

data/spec/integration/association/one_to_many/self_ref_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
+  subject(:assoc) do
+    relations[:categories].associations[:children]
+  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
+            has_many :categories, as: :children, foreign_key: :parent_id
+          end
+        end
+      end
+
+      p1_id = relations[:categories].insert(name: 'P1')
+      p2_id = relations[:categories].insert(name: 'P2')
+      c1_id = relations[:categories].insert(name: 'C3', parent_id: p2_id)
+      c2_id = relations[:categories].insert(name: 'C4', parent_id: p1_id)
+      c3_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.call(relations)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i[categories__id categories__parent_id categories__name])
+
+      expect(relation.to_a).
+        to eql([
+                 { id: 3, parent_id: 2, name: 'C3' },
+                 { id: 4, parent_id: 1, name: 'C4' },
+                 { id: 5, parent_id: 1, name: 'C5' }
+               ])
+    end
+  end
+end