rom-sql 1.3.5 → 2.0.0.beta1

data/spec/integration/auto_migrations/indexes_spec.rb

@@ -0,0 +1,109 @@
+RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
+  include_context 'database setup'
+
+  before do
+    conn.drop_table?(:users)
+  end
+
+  let(:table_name) { :users }
+
+  subject(:gateway) { container.gateways[:default] }
+
+  let(:inferrer) { ROM::SQL::Schema::Inferrer.new }
+
+  let(:migrated_schema) do
+    empty = define_schema(table_name)
+    empty.with(inferrer.(empty, gateway))
+  end
+
+  let(:attributes) { migrated_schema.to_a }
+
+  describe 'create table' do
+    describe 'one-column indexes' do
+      before do
+        conf.relation(:users) do
+          schema do
+            attribute :id,    ROM::SQL::Types::Serial
+            attribute :name,  ROM::SQL::Types::String.meta(index: true)
+          end
+        end
+      end
+
+      it 'creates ordinary b-tree indexes' do
+        gateway.auto_migrate!(conf)
+
+        expect(attributes.map(&:to_ast))
+          .to eql([
+                    [:attribute,
+                     [:id,
+                      [:definition, [Integer, {}]],
+                      primary_key: true, source: :users]],
+                    [:attribute,
+                     [:name,
+                      [:definition, [String, {}]],
+                      source: :users]],
+                  ])
+      end
+    end
+  end
+
+  describe 'alter table' do
+    describe 'one-column indexes' do
+      context 'adding' do
+        before do
+          conf.relation(:users) do
+            schema do
+              attribute :id,    ROM::SQL::Types::Serial
+              attribute :name,  ROM::SQL::Types::String.meta(index: true)
+            end
+          end
+        end
+
+        it 'adds indexed column' do
+          conn.create_table :users do
+            primary_key :id
+          end
+
+          gateway.auto_migrate!(conf)
+
+          expect(migrated_schema.attributes[1].name).to eql(:name)
+          expect(migrated_schema.indexes.map { |idx| idx.attributes.map(&:name) }).to eql([%i(name)])
+        end
+
+        it 'adds index to existing column' do
+          conn.create_table :users do
+            primary_key :id
+            column :name, String
+          end
+
+          gateway.auto_migrate!(conf)
+
+          expect(migrated_schema.indexes.map { |idx| idx.attributes.map(&:name) }).to eql([%i(name)])
+        end
+      end
+
+      context 'removing' do
+        before do
+          conf.relation(:users) do
+            schema do
+              attribute :id,    ROM::SQL::Types::Serial
+              attribute :name,  ROM::SQL::Types::String
+            end
+          end
+
+          conn.create_table :users do
+            primary_key :id
+            column :name, String
+
+            index :name
+          end
+        end
+
+        it 'removes index' do
+          gateway.auto_migrate!(conf)
+          expect(migrated_schema.indexes).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/integration/auto_migrations/managing_columns_spec.rb

@@ -0,0 +1,156 @@
+RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
+  include_context 'database setup'
+
+  before do
+    conn.drop_table?(:users)
+  end
+
+  before do
+    conf.relation(:users) do
+      schema do
+        attribute :id,    ROM::SQL::Types::Serial
+        attribute :name,  ROM::SQL::Types::String
+        attribute :email, ROM::SQL::Types::String.optional
+      end
+    end
+  end
+
+  let(:table_name) { :users }
+
+  subject(:gateway) { container.gateways[:default] }
+
+  let(:inferrer) { ROM::SQL::Schema::Inferrer.new }
+
+  let(:migrated_schema) do
+    empty = define_schema(table_name)
+    empty.with(inferrer.(empty, gateway))
+  end
+
+  let(:attributes) { migrated_schema.to_a }
+
+  describe 'create a table' do
+    it 'creates a table from a relation' do
+      gateway.auto_migrate!(conf)
+
+      expect(attributes.map(&:to_ast))
+        .to eql([
+                  [:attribute,
+                   [:id,
+                    [:definition, [Integer, {}]],
+                    primary_key: true, source: :users]],
+                  [:attribute, [:name, [:definition, [String, {}]], source: :users]],
+                  [:attribute,
+                   [:email,
+                    [:sum,
+                     [[:constrained,
+                       [[:definition, [NilClass, {}]],
+                        [:predicate, [:type?, [[:type, NilClass], [:input, ROM::Undefined]]]],
+                        {}]],
+                      [:definition, [String, {}]],
+                      {}]],
+                    source: :users]]
+                ])
+    end
+  end
+
+  describe 'adding columns' do
+    before do
+      conn.create_table :users do
+        primary_key :id
+      end
+    end
+
+    it 'adds columns to an existing table' do
+      gateway.auto_migrate!(conf)
+
+      expect(attributes[1].to_ast)
+        .to eql(
+              [:attribute, [:name, [:definition, [String, {}]], source: :users]]
+            )
+      expect(attributes[2].to_ast)
+        .to eql(
+              [:attribute,
+               [:email,
+                [:sum,
+                 [[:constrained,
+                   [[:definition, [NilClass, {}]],
+                    [:predicate, [:type?, [[:type, NilClass], [:input, ROM::Undefined]]]],
+                    {}]],
+                  [:definition, [String, {}]],
+                  {}]],
+                source: :users]]
+            )
+    end
+  end
+
+  describe 'removing columns' do
+    before do
+      conn.create_table :users do
+        primary_key :id
+        column :name, String, null: false
+        column :email, String
+        column :age, Integer, null: false
+      end
+    end
+
+    it 'removes columns from a table' do
+      gateway.auto_migrate!(conf)
+
+      expect(attributes.map(&:name)).to eql(%i(id name email))
+    end
+  end
+
+  describe 'empty diff' do
+    before do
+      conn.create_table :users do
+        primary_key :id
+        column :name, String, null: false
+        column :email, String
+      end
+    end
+
+    it 'leaves existing schema' do
+      current = container.relations[:users].schema
+
+      gateway.auto_migrate!(conf)
+
+      expect(attributes).to eql(current.to_a)
+    end
+  end
+
+  describe 'changing NOTNULL' do
+    describe 'adding' do
+      before do
+        conn.create_table :users do
+          primary_key :id
+          column :name, String
+          column :email, String
+        end
+      end
+
+      it 'adds the constraint' do
+        gateway.auto_migrate!(conf)
+
+        expect(attributes[1].name).to eql(:name)
+        expect(attributes[1]).not_to be_optional
+      end
+    end
+
+    describe 'removing' do
+      before do
+        conn.create_table :users do
+          primary_key :id
+          column :name, String, null: false
+          column :email, String, null: false
+        end
+      end
+
+      it 'removes the constraint' do
+        gateway.auto_migrate!(conf)
+
+        expect(attributes[2].name).to eql(:email)
+        expect(attributes[2]).to be_optional
+      end
+    end
+  end
+end

data/spec/integration/auto_migrations/postgres/column_types_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
+  include_context 'database setup'
+
+  before do
+    conn.drop_table?(:test_pg_types)
+  end
+
+  let(:table_name) { :test_pg_types }
+
+  subject(:gateway) { container.gateways[:default] }
+
+  let(:inferrer) { ROM::SQL::Schema::Inferrer.new }
+
+  let(:migrated_schema) do
+    empty = define_schema(table_name)
+    empty.with(inferrer.(empty, gateway))
+  end
+
+  let(:attributes) { migrated_schema.to_a }
+
+  describe 'common types' do
+    before do
+      conf.relation(:test_pg_types) do
+        schema do
+          attribute :id,              ROM::SQL::Types::Serial
+          attribute :string,          ROM::SQL::Types::String
+          attribute :int,             ROM::SQL::Types::Int
+          attribute :time,            ROM::SQL::Types::Time
+          attribute :date,            ROM::SQL::Types::Date
+          attribute :decimal,         ROM::SQL::Types::Decimal
+          attribute :string_nullable, ROM::SQL::Types::String.optional
+        end
+      end
+    end
+
+    it 'has support for PG data types' do
+      gateway.auto_migrate!(conf)
+
+      expect(attributes.map(&:to_ast))
+        .to eql([
+                  [:attribute,
+                   [:id,
+                    [:definition, [Integer, {}]],
+                    primary_key: true, source: :test_pg_types]],
+                  [:attribute, [:string, [:definition, [String, {}]], source: :test_pg_types]],
+                  [:attribute, [:int, [:definition, [Integer, {}]], source: :test_pg_types]],
+                  [:attribute, [:time, [:definition, [Time, {}]], source: :test_pg_types]],
+                  [:attribute, [:date, [:definition, [Date, {}]], source: :test_pg_types]],
+                  [:attribute, [:decimal, [:definition, [BigDecimal, {}]], source: :test_pg_types]],
+                  [:attribute,
+                   [:string_nullable,
+                    [:sum,
+                     [[:constrained,
+                       [[:definition, [NilClass, {}]],
+                        [:predicate, [:type?, [[:type, NilClass], [:input, ROM::Undefined]]]],
+                        {}]],
+                      [:definition, [String, {}]],
+                      {}]],
+                    source: :test_pg_types]]
+                ])
+    end
+  end
+end

data/spec/integration/commands/create_spec.rb

@@ -137,10 +137,8 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
     end
 
     it 'uses relation schema for the default input handler' do
-      conf.relation(:users) do
-        register_as :users_with_schema
-
-        schema do
+      conf.relation(:users_with_schema) do
+        schema(:users) do
           attribute :id, ROM::SQL::Types::Serial
           attribute :name, ROM::SQL::Types::String
         end

data/spec/integration/commands/delete_spec.rb

@@ -63,7 +63,7 @@ RSpec.describe 'Commands / Delete' do
     describe '#execute' do
       context 'with a single record' do
         it 'materializes the result' do
-          result = container.command(:users).delete.by_name(%w(Jade)).execute
+          result = container.commands[:users].delete.by_name(%w(Jade)).execute
           expect(result).to eq([
             { id: 3, name: 'Jade' }
           ])
@@ -72,7 +72,7 @@ RSpec.describe 'Commands / Delete' do
 
       context 'with multiple records' do
         it 'materializes the results' do
-          result = container.command(:users).delete.by_name(%w(Jade John)).execute
+          result = container.commands[:users].delete.by_name(%w(Jade John)).execute
           expect(result).to eq([
             { id: 3, name: 'Jade' },
             { id: 4, name: 'John' }

data/spec/integration/commands/update_spec.rb

@@ -16,6 +16,8 @@ RSpec.describe 'Commands / Update', seeds: false do
       }
 
       conf.relation(:users) do
+        schema(infer: true)
+
         def by_id(id)
           where(id: id)
         end

data/spec/integration/graph_spec.rb

@@ -4,18 +4,24 @@ RSpec.describe 'Eager loading' do
   with_adapters do
     before do
       conf.relation(:users) do
+        auto_map false
+
         def by_name(name)
           where(name: name)
         end
       end
 
       conf.relation(:tasks) do
+        auto_map false
+
         def for_users(users)
           where(user_id: users.map { |tuple| tuple[:id] })
         end
       end
 
       conf.relation(:tags) do
+        auto_map false
+
         def for_tasks(tasks)
           inner_join(:task_tags, task_id: :id)
             .where(task_id: tasks.map { |tuple| tuple[:id] })
@@ -24,9 +30,9 @@ RSpec.describe 'Eager loading' do
     end
 
     it 'issues 3 queries for 3.graphd relations' do
-      users = container.relation(:users).by_name('Piotr')
-      tasks = container.relation(:tasks)
-      tags = container.relation(:tags)
+      users = container.relations[:users].by_name('Piotr')
+      tasks = container.relations[:tasks]
+      tags = container.relations[:tags]
 
       relation = users.graph(tasks.for_users.graph(tags.for_tasks))
 

data/spec/integration/plugins/associates_spec.rb

@@ -8,6 +8,17 @@ RSpec.describe 'Plugins / :associates', seeds: false do
       let(:tags) { container.commands[:tags] }
 
       before do
+        conf.relation(:tasks) do
+          schema(infer: true) do
+            associations do
+              many_to_one :users, as: :user
+              many_to_one :users, as: :other
+              one_to_many :task_tags
+              one_to_many :tags, through: :task_tags
+            end
+          end
+        end
+
         conf.commands(:users) do
           define(:create) { result :one }
         end
@@ -82,35 +93,12 @@ RSpec.describe 'Plugins / :associates', seeds: false do
         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
-
+          conf.relation(:tasks) do
+            schema(infer: true) do
               associations do
                 many_to_one :users, as: :user
                 one_to_many :task_tags
@@ -136,10 +124,7 @@ RSpec.describe 'Plugins / :associates', seeds: false do
         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
-
+              schema(infer: true) do
                 associations do
                   one_to_many :task_tags
                   one_to_many :tasks, through: :task_tags
@@ -183,7 +168,7 @@ RSpec.describe 'Plugins / :associates', seeds: false do
             command = create_user >> create_task >> create_tags
 
             result = command.call
-            tags = relations[:tasks].associations[:tags].call(relations).to_a
+            tags = relations[:tasks].associations[:tags].().to_a
 
             expect(result).to eql([
               { id: 1, task_id: 1, name: 'red' }, { id: 2, task_id: 1, name: 'blue' }
@@ -231,7 +216,7 @@ RSpec.describe 'Plugins / :associates', seeds: false do
       end
 
       before do
-        conf.relation_classes[1].class_eval do
+        conf.relation(:tasks) do
           schema(infer: true) do
             associations do
               belongs_to :user
@@ -262,28 +247,4 @@ RSpec.describe 'Plugins / :associates', seeds: false do
       end
     end
   end
-
-  context 'misconfigured assocs', :sqlite do
-    subject(:command) do
-      container.commands[:users][:create]
-    end
-
-    context 'when keys are missing in class-level config' do
-      before do
-        conf.commands(:users) do
-          define(:create) do
-            associates :tasks
-          end
-        end
-      end
-
-      it 'raises error' do
-        expect { command }.
-          to raise_error(
-               ROM::SQL::Plugin::Associates::MissingJoinKeysError,
-               ':create command for :users relation is missing join keys configuration for :tasks association'
-             )
-      end
-    end
-  end
 end