rom-sql 0.7.0 → 0.8.0

data/spec/integration/gateway_spec.rb

@@ -1,14 +1,12 @@
-require 'spec_helper'
-
 describe ROM::SQL::Gateway do
   describe 'migration' do
-    let(:conn) { Sequel.connect(DB_URI) }
+    let(:conn) { Sequel.connect(POSTGRES_DB_URI) }
 
     context 'creating migrations inline' do
       subject(:gateway) { container.gateways[:default] }
 
-      let(:configuration) { ROM::Configuration.new(:sql, conn) }
-      let!(:container) { ROM.container(configuration) }
+      let(:conf) { ROM::Configuration.new(:sql, conn) }
+      let!(:container) { ROM.container(conf) }
 
       after do
         [:rabbits, :carrots].each do |name|
@@ -48,8 +46,8 @@ describe ROM::SQL::Gateway do
       end
 
       let(:migrator) { ROM::SQL::Migration::Migrator.new(conn, path: migration_dir) }
-      let(:configuration) { ROM::Configuration.new(:sql, [conn, migrator: migrator]) }
-      let!(:container) { ROM.container(configuration) }
+      let(:conf) { ROM::Configuration.new(:sql, [conn, migrator: migrator]) }
+      let!(:container) { ROM.container(conf) }
 
       it 'returns true for pending migrations' do
         expect(container.gateways[:default].pending_migrations?).to be_truthy
@@ -70,31 +68,25 @@ describe ROM::SQL::Gateway do
     include_context 'database setup'
 
     it 'skips settings up associations when tables are missing' do
-      configuration = ROM::Configuration.new(:sql, uri) do |config|
-        config.use(:macros)
-
+      conf = ROM::Configuration.new(:sql, uri) do |config|
         config.relation(:foos) do
           use :assoc_macros
-          primary_key :id
           one_to_many :bars, key: :foo_id
         end
       end
-      expect { ROM.container(configuration) }.not_to raise_error
+      expect { ROM.container(conf) }.not_to raise_error
     end
 
     it 'skips finalization a relation when table is missing' do
-      configuration = ROM::Configuration.new(:sql, uri) do |config|
-        config.use(:macros)
-
+      conf = ROM::Configuration.new(:sql, uri) do |config|
         class Foos < ROM::Relation[:sql]
           dataset :foos
           use :assoc_macros
-          primary_key :id
           one_to_many :bars, key: :foo_id
         end
       end
 
-      expect { ROM.container(configuration) }.not_to raise_error
+      expect { ROM.container(conf) }.not_to raise_error
       expect { Foos.model.dataset }.to raise_error(Sequel::Error, /no dataset/i)
     end
   end

data/spec/integration/migration_spec.rb

@@ -1,11 +1,9 @@
-require 'spec_helper'
-
-describe ROM::SQL, '.migration' do
+RSpec.describe ROM::SQL, '.migration' do
   let(:connection) { ROM::SQL.gateway.connection }
-  let(:configuration) { ROM::Configuration.new(:sql, DB_URI) }
+  let(:conf) { ROM::Configuration.new(:sql, POSTGRES_DB_URI) }
 
   before do
-    configuration
+    conf
     connection.drop_table?(:dragons)
   end
 

data/spec/integration/plugins/associates_spec.rb

@@ -0,0 +1,168 @@
+RSpec.describe 'Plugins / :associates' do
+  include_context 'relations'
+
+  with_adapters do
+    context 'with Create command' do
+      let(:users) { container.commands[:users] }
+      let(:tasks) { container.commands[:tasks] }
+      let(:tags) { container.commands[:tags] }
+
+      before do
+        conf.commands(:users) do
+          define(:create) { result :one }
+        end
+      end
+
+      shared_context 'automatic FK setting' do
+        it 'sets foreign key prior execution for many tuples' do
+          create_user = users[:create].with(name: 'Jade')
+          create_task = tasks[:create_many].with([{ title: 'Task one' }, { title: 'Task two' }])
+
+          command = create_user >> create_task
+
+          result = command.call
+
+          expect(result).to match_array([
+            { id: 1, user_id: 1, title: 'Task one' },
+            { id: 2, user_id: 1, title: 'Task two' }
+          ])
+        end
+
+        it 'sets foreign key prior execution for one tuple' do
+          create_user = users[:create].with(name: 'Jade')
+          create_task = tasks[:create_one].with(title: 'Task one')
+
+          command = create_user >> create_task
+
+          result = command.call
+
+          expect(result).to match_array(id: 1, user_id: 1, title: 'Task one')
+        end
+      end
+
+      context 'without a schema' do
+        include_context 'automatic FK setting' do
+          before do
+            conf.commands(:tasks) do
+              define(:create) do
+                register_as :create_many
+                associates :user, key: [:user_id, :id]
+              end
+
+              define(:create) do
+                register_as :create_one
+                result :one
+                associates :user, key: [:user_id, :id]
+              end
+            end
+          end
+        end
+      end
+
+      context 'with a schema' do
+        include_context 'automatic FK setting'
+
+        before do
+          conf.relation_classes[1].class_eval do
+            schema do
+              attribute :id, ROM::SQL::Types::Serial
+              attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+              attribute :title, ROM::SQL::Types::String
+
+              associations do
+                many_to_one :users, as: :user
+                one_to_many :task_tags
+                one_to_many :tags, through: :task_tags
+              end
+            end
+          end
+
+          conf.commands(:tasks) do
+            define(:create) do
+              register_as :create_many
+              associates :user
+            end
+
+            define(:create) do
+              register_as :create_one
+              result :one
+              associates :user
+            end
+          end
+        end
+
+        context 'with many-to-many association' do
+          before do
+            conf.relation(:tags) do
+              schema do
+                attribute :id, ROM::SQL::Types::Serial
+                attribute :name, ROM::SQL::Types::String
+
+                associations do
+                  one_to_many :task_tags
+                  one_to_many :tasks, through: :task_tags
+                end
+              end
+            end
+
+            conf.relation(:task_tags) do
+              schema do
+                attribute :tag_id, ROM::SQL::Types::ForeignKey(:tags)
+                attribute :task_id, ROM::SQL::Types::ForeignKey(:tasks)
+
+                primary_key :tag_id, :task_id
+
+                associations do
+                  many_to_one :tags
+                  many_to_one :tasks
+                end
+              end
+            end
+
+            conf.commands(:tasks) do
+              define(:create) do
+                result :one
+                associates :user
+              end
+            end
+
+            conf.commands(:tags) do
+              define(:create) do
+                associates :tasks
+              end
+            end
+          end
+
+          it 'sets FKs for the join table' do
+            create_user = users[:create].with(name: 'Jade')
+            create_task = tasks[:create].with(title: "Jade's task")
+            create_tags = tags[:create].with([{ name: 'red' }, { name: 'blue' }])
+
+            command = create_user >> create_task >> create_tags
+
+            result = command.call
+            tags = relations[:tasks].associations[:tags].call(relations).to_a
+
+            expect(result).to eql([
+              { id: 1, task_id: 1, name: 'red' }, { id: 2, task_id: 1, name: 'blue' }
+            ])
+
+            expect(tags).to eql(result)
+          end
+        end
+      end
+
+      it 'raises when already defined' do
+        expect {
+          conf.commands(:tasks) do
+            define(:create) do
+              result :one
+              associates :user, key: [:user_id, :id]
+              associates :user, key: [:user_id, :id]
+            end
+          end
+        }.to raise_error(ArgumentError, /user/)
+      end
+    end
+  end
+end

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe 'Plugins / :auto_wrap' do
+  with_adapters do
+    include_context 'users and tasks'
+
+    describe '#for_wrap' do
+      shared_context 'joined tuple' do
+        it 'returns joined tuples' do
+          task_with_user = tasks
+            .for_wrap({ id: :user_id }, users.name.relation)
+            .where(tasks__id: 2)
+            .one
+
+          expect(task_with_user).to eql(
+            id: 2, user_id: 1, title: "Jane's task", users_name: "Jane", users_id: 1
+          )
+        end
+      end
+
+      context 'when parent relation is registered under dataset name' do
+        subject(:tasks) { container.relations[:tasks] }
+
+        let(:users) { container.relations[:users] }
+
+        before do
+          conf.relation(:tasks)
+          conf.relation(:users)
+        end
+
+        include_context 'joined tuple'
+      end
+
+      context 'when parent relation is registered under a custom name' do
+        subject(:tasks) { container.relations[:tasks] }
+
+        let(:users) { container.relations[:authors] }
+
+        before do
+          conf.relation(:tasks)
+          conf.relation(:authors) { dataset :users }
+        end
+
+        include_context 'joined tuple'
+      end
+    end
+  end
+end

data/spec/integration/read_spec.rb

@@ -1,116 +1,119 @@
-require 'spec_helper'
 require 'virtus'
 
-describe 'Reading relations' do
+RSpec.describe 'Reading relations' do
   include_context 'users and tasks'
 
-  before :each do
-    class Goal
-      include Virtus.value_object(coerce: true)
+  # FIXME: one example fails on :mysql
+  with_adapters(:postgres, :sqlite) do
+    before :each do
+      class Goal
+        include Virtus.value_object(coerce: true)
 
-      values do
-        attribute :id, Integer
-        attribute :title, String
+        values do
+          attribute :id, Integer
+          attribute :title, String
+        end
       end
-    end
 
-    class User
-      include Virtus.value_object(coerce: true)
+      class User
+        include Virtus.value_object(coerce: true)
 
-      values do
-        attribute :id, Integer
-        attribute :name, String
-        attribute :goals, Array[Goal]
+        values do
+          attribute :id, Integer
+          attribute :name, String
+          attribute :goals, Array[Goal]
+        end
       end
-    end
 
-    class UserGoalCount
-      include Virtus.value_object(coerce: true)
+      class UserGoalCount
+        include Virtus.value_object(coerce: true)
 
-      values do
-        attribute :id, Integer
-        attribute :name, String
-        attribute :goal_count, Integer
+        values do
+          attribute :id, Integer
+          attribute :name, String
+          attribute :goal_count, Integer
+        end
       end
-    end
 
-    configuration.relation(:goals) do
-      use :assoc_macros
+      conf.relation(:goals) do
+        use :assoc_macros
 
-      register_as :goals
-      dataset :tasks
-    end
+        register_as :goals
+        dataset :tasks
+      end
 
-    configuration.relation(:users) do
-      use :assoc_macros
+      conf.relation(:users) do
+        use :assoc_macros
 
-      one_to_many :goals, key: :user_id
+        one_to_many :goals, key: :user_id
 
-      def by_name(name)
-        where(name: name)
-      end
+        def by_name(name)
+          where(name: name)
+        end
 
-      def with_goals
-        association_left_join(:goals, select: [:id, :title])
-      end
+        def with_goals
+          association_left_join(:goals, select: [:id, :title])
+        end
 
-      def all
-        select(:id, :name)
+        def all
+          select(:id, :name)
+        end
       end
-    end
 
-    configuration.relation(:user_goal_counts) do
-      use :assoc_macros
+      conf.relation(:user_goal_counts) do
+        use :assoc_macros
 
-      dataset :users
-      register_as :user_goal_counts
-      one_to_many :goals, key: :user_id
+        dataset :users
+        register_as :user_goal_counts
+        one_to_many :goals, key: :user_id
 
-      def all
-        with_goals.select_group(:users__id, :users__name).select_append {
-          count(:tasks).as(:goal_count)
-        }
-      end
+        def all
+          with_goals.select_group(:users__id, :users__name).select_append {
+            count(:tasks).as(:goal_count)
+          }
+        end
 
-      def with_goals
-        association_left_join(:goals, select: [:id, :title])
+        def with_goals
+          association_left_join(:goals, select: [:id, :title])
+        end
       end
-    end
 
-    configuration.mappers do
-      define(:users) do
-        model User
+      conf.mappers do
+        define(:users) do
+          model User
 
-        group :goals do
-          model Goal
+          group :goals do
+            model Goal
 
-          attribute :id, from: :tasks_id
-          attribute :title
+            attribute :id, from: :tasks_id
+            attribute :title
+          end
         end
-      end
 
-      define(:user_goal_counts) do
-        model UserGoalCount
+        define(:user_goal_counts) do
+          model UserGoalCount
+        end
       end
     end
-  end
 
-  it 'loads domain objects' do
-    user = container.relation(:users).as(:users).with_goals.by_name('Piotr').to_a.first
+    it 'loads domain objects' do
+      user = container.relation(:users).as(:users).with_goals.by_name('Jane').to_a.first
 
-    expect(user).to eql(
-      User.new(
-        id: 1, name: 'Piotr', goals: [Goal.new(id: 1, title: 'Finish ROM')]
-      ))
-  end
+      expect(user).to eql(
+        User.new(
+          id: 1, name: 'Jane', goals: [Goal.new(id: 2, title: "Jane's task")]
+        ))
+    end
 
-  it 'works with grouping and aggregates' do
-    container.relations[:goals].insert(id: 2, user_id: 1, title: 'Get Milk')
+    it 'works with grouping and aggregates' do
+      container.relations[:goals].insert(id: 3, user_id: 1, title: 'Get Milk')
 
-    users_with_goal_count = container.relation(:user_goal_counts).as(:user_goal_counts).all
+      users_with_goal_count = container.relation(:user_goal_counts).as(:user_goal_counts).all
 
-    expect(users_with_goal_count.to_a).to eq([
-      UserGoalCount.new(id: 1, name: "Piotr", goal_count: 2)
-    ])
+      expect(users_with_goal_count.to_a).to eq([
+        UserGoalCount.new(id: 1, name: "Jane", goal_count: 2),
+        UserGoalCount.new(id: 2, name: "Joe", goal_count: 1)
+      ])
+    end
   end
 end