rom-sql 1.2.2 → 1.3.0

data/spec/extensions/postgres/integration_spec.rb

@@ -17,6 +17,7 @@ RSpec.describe 'PostgreSQL extension', :postgres do
 
     conf.commands(:people) do
       define(:create)
+      define(:update)
     end
   end
 
@@ -35,4 +36,24 @@ RSpec.describe 'PostgreSQL extension', :postgres do
       expect(people_relation.to_a).to eq([id: 1, name: 'John Doe', tags: []])
     end
   end
+
+  describe 'using retrurning' do
+    let(:create_person) { commands[:people].create }
+    let(:update_person) { commands[:people].update }
+    let(:composite_relation) { people_relation >> -> r { r.to_a.map { |x| x.fetch(:name).upcase } } }
+
+    context 'with pipeline' do
+      it 'works with create' do
+        mapped_people = create_person.new(composite_relation).call(name: 'John Doe', tags: ['foo'])
+        expect(mapped_people).to eql(['JOHN DOE'])
+      end
+
+      it 'works with update' do
+        create_person.call(name: 'John Doe', tags: ['foo'])
+
+        mapped_people = update_person.new(composite_relation).call(name: 'Jane Doe')
+        expect(mapped_people).to eql(['JANE DOE'])
+      end
+    end
+  end
 end

data/spec/integration/commands/update_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe 'Commands / Update', seeds: false do
 
       conf.relation(:users) do
         def by_id(id)
-          where(id: id).limit(1)
+          where(id: id)
         end
 
         def by_name(name)

data/spec/integration/migration_spec.rb

@@ -1,24 +1,55 @@
-RSpec.describe ROM::SQL, '.migration', :postgres do
+RSpec.describe ROM::SQL, '.migration' do
   include_context 'database setup'
 
   before do
     inferrable_relations.concat %i(dragons schema_migrations)
   end
 
-  before { conf }
+  with_adapters do
+    before { conf }
 
-  it 'creates a migration for a specific gateway' do
-    migration = ROM::SQL.migration do
-      change do
-        create_table :dragons do
-          primary_key :id
-          column :name, String
+    it 'creates a migration for a specific gateway' do
+      migration = ROM::SQL.migration(container) do
+        change do
+          create_table :dragons do
+            primary_key :id
+            column :name, String
+          end
         end
       end
+
+      migration.apply(conn, :up)
+
+      expect(conn.table_exists?(:dragons)).to be(true)
     end
+  end
+
+  context 'with non-default gateway' do
+    with_adapters(:postgres) do
+      let(:conf) do
+        ROM::Configuration.new(
+          default: [:sql, conn, inferrable_relations: %i(schema_migrations)],
+          in_memory: [:sql, DB_URIS[:sqlite], inferrable_relations: %i(schema_migrations)]
+        )
+      end
 
-    migration.apply(conn, :up)
+      let(:in_memory_connection) { container.gateways[:in_memory].connection }
 
-    expect(conn.table_exists?(:dragons)).to be(true)
+      it 'creates a migration for a specific gateway' do
+        in_memory_migration = ROM::SQL.migration(container, :in_memory) do
+          change do
+            create_table :turtles do
+              primary_key :id
+              column :name, String
+            end
+          end
+        end
+
+        in_memory_migration.apply(in_memory_connection, :up)
+
+        expect(in_memory_connection.table_exists?(:dragons)).to be(false)
+        expect(in_memory_connection.table_exists?(:turtles)).to be(true)
+      end
+    end
   end
 end

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -49,16 +49,63 @@ RSpec.describe 'Plugins / :auto_wrap' do
         end
       end
 
-      context 'using association' do
+      context 'using association with inferred relation name' do
         before do
-          conf.relation(:tasks) {
-            schema(infer: true) { associations { belongs_to :users, as: :assignee } }
-          }
+          conf.relation(:tasks) do
+            schema(infer: true) do
+              associations do
+                belongs_to :user
+              end
+            end
+          end
 
-          conf.relation(:users) { schema(infer: true) }
+          conf.relation(:users) do
+            schema(infer: true)
+          end
+        end
+
+        include_context 'joined tuple' do
+          let(:name) { :user }
+        end
+      end
+
+      context 'using association with an alias' do
+        before do
+          conf.relation(:tasks) do
+            schema(infer: true) do
+              associations do
+                belongs_to :users, as: :assignee
+              end
+            end
+          end
+
+          conf.relation(:users) do
+            schema(infer: true)
+          end
+        end
+
+        include_context 'joined tuple' do
+          let(:name) { :assignee }
+        end
+      end
+
+      context 'using association with an aliased relation' do
+        before do
+          conf.relation(:tasks) do
+            schema(infer: true) do
+              associations do
+                belongs_to :users, as: :assignee, relation: :people
+              end
+            end
+          end
+
+          conf.relation(:people) do
+            schema(:users, infer: true)
+          end
         end
 
         include_context 'joined tuple' do
+          let(:users) { relations[:people] }
           let(:name) { :assignee }
         end
       end

data/spec/integration/schema/inferrer_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
   include_context 'users and tasks'
 
   before do
-    inferrable_relations.concat %i(test_inferrence test_numeric)
+    inferrable_relations.concat %i(test_characters test_inferrence test_numeric)
   end
 
   let(:schema) { container.relations[dataset].schema }
@@ -29,7 +29,7 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
           expect(schema.to_h).
             to eql(
                  id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
-                 name: ROM::SQL::Types::String.meta(name: :name, source: source)
+                 name: ROM::SQL::Types::String.meta(name: :name, limit: 255, source: source)
                )
         end
       end
@@ -48,7 +48,7 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
           expect(schema.to_h).
             to eql(
                  id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
-                 title: ROM::SQL::Types::String.optional.meta(name: :title, source: source),
+                 title: ROM::SQL::Types::String.meta(limit: 255).optional.meta(name: :title, source: source),
                  user_id: ROM::SQL::Types::Int.optional.meta(
                    name: :user_id,
                    foreign_key: true,
@@ -66,7 +66,7 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
 
           conn.create_table :test_inferrence do
             primary_key :id
-            String :text, null: false
+            String :text, text: false, null: false
             Time :time
             Date :date
 
@@ -97,7 +97,7 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
           expect(schema.to_h).
             to eql(
                  id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
-                 text: ROM::SQL::Types::String.meta(name: :text, source: source),
+                 text: ROM::SQL::Types::String.meta(name: :text, limit: 255, source: source),
                  time: ROM::SQL::Types::Time.optional.meta(name: :time, source: source),
                  date: date_type.optional.meta(name: :date, source: source),
                  datetime: ROM::SQL::Types::Time.meta(name: :datetime, source: source),
@@ -106,6 +106,37 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
         end
       end
 
+      context 'character datatypes' do
+        before do
+          conn.create_table :test_characters do
+            String :text1, text: false, null: false
+            String :text2, size: 100, null: false
+            column :text3, 'char(100)', null: false
+            column :text4, 'varchar', null: false
+            column :text5, 'varchar(100)', null: false
+            String :text6, size: 100
+          end
+        end
+
+        let(:dataset) { :test_characters }
+        let(:source) { ROM::Relation::Name[dataset] }
+
+        let(:char_t) { ROM::SQL::Types::String.meta(source: source) }
+
+        it 'infers attributes with limit' do
+          expect(schema.to_h).to eql(
+            text1: char_t.meta(name: :text1, limit: 255),
+            text2: char_t.meta(name: :text2, limit: 100),
+            text3: char_t.meta(name: :text3, limit: 100),
+            text4: char_t.meta(name: :text4, limit: 255),
+            text5: char_t.meta(name: :text5, limit: 100),
+            text6: ROM::SQL::Types::String.meta(limit: 100).optional.meta(
+              name: :text6, source: source
+            )
+          )
+        end
+      end
+
       context 'numeric datatypes' do
         before do
           conn.create_table :test_numeric do

data/spec/shared/users.rb

@@ -16,7 +16,7 @@ RSpec.shared_context 'users' do
 
     conn.create_table :users do
       primary_key :id
-      String :name, null: false
+      String :name, text: false, null: false
       check { char_length(name) > 2 } if ctx.postgres?(example)
     end
   end

data/spec/shared/users_and_tasks.rb

@@ -17,7 +17,7 @@ RSpec.shared_context 'users and tasks' do
     conn.create_table :tasks do
       primary_key :id
       foreign_key :user_id, :users
-      String :title
+      String :title, text: false
       constraint(:title_length) { char_length(title) > 1 } if ctx.postgres?(example)
       constraint(:title_length) { length(title) > 1 }      if ctx.sqlite?(example)
     end

data/spec/spec_helper.rb

@@ -1,10 +1,16 @@
 require 'bundler'
 Bundler.setup
 
-if RUBY_ENGINE == 'ruby' && ENV['CI'] == 'true'
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter '/spec/'
+if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
+  require 'yaml'
+  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
+  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
+
+  if RUBY_VERSION == latest_mri
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/spec/'
+    end
   end
 end
 

data/spec/unit/attribute_spec.rb

@@ -6,12 +6,92 @@ RSpec.describe ROM::SQL::Attribute, :postgres do
   let(:ds) { users.dataset }
 
   describe '#is' do
-    it 'returns a boolean expression' do
-      expect(users[:id].is(1).sql_literal(ds)).to eql('("id" = 1)')
+    context 'with a standard value' do
+      it 'returns a boolean expression' do
+        expect(users[:id].is(1).sql_literal(ds)).to eql('("id" = 1)')
+      end
+
+      it 'returns a boolean equality expression for qualified attribute' do
+        expect((users[:id].qualified.is(1)).sql_literal(ds)).to eql('("users"."id" = 1)')
+      end
+    end
+
+    context 'with a nil value' do
+      it 'returns an IS NULL expression' do
+        expect(users[:id].is(nil).sql_literal(ds)).to eql('("id" IS NULL)')
+      end
+
+      it 'returns an IS NULL expression for qualified attribute' do
+        expect((users[:id].qualified.is(nil)).sql_literal(ds)).to eql('("users"."id" IS NULL)')
+      end
+    end
+
+    context 'with a boolean true' do
+      it 'returns an IS TRUE expression' do
+        expect(users[:id].is(true).sql_literal(ds)).to eql('("id" IS TRUE)')
+      end
+
+      it 'returns an IS TRUE expression for qualified attribute' do
+        expect((users[:id].qualified.is(true)).sql_literal(ds)).to eql('("users"."id" IS TRUE)')
+      end
+    end
+
+    context 'with a boolean false' do
+      it 'returns an IS FALSE expression' do
+        expect(users[:id].is(false).sql_literal(ds)).to eql('("id" IS FALSE)')
+      end
+
+      it 'returns an IS FALSE expression for qualified attribute' do
+        expect((users[:id].qualified.is(false)).sql_literal(ds)).to eql('("users"."id" IS FALSE)')
+      end
+    end
+  end
+
+  describe '#not' do
+    context 'with a standard value' do
+      it 'returns a negated boolean equality expression' do
+        expect(users[:id].not(1).sql_literal(ds)).to eql('("id" != 1)')
+      end
+
+      it 'returns a negated boolean equality expression for qualified attribute' do
+        expect((users[:id].qualified.not(1)).sql_literal(ds)).to eql('("users"."id" != 1)')
+      end
+    end
+
+    context 'with a nil value' do
+      it 'returns an IS NOT NULL expression' do
+        expect(users[:id].not(nil).sql_literal(ds)).to eql('("id" IS NOT NULL)')
+      end
+
+      it 'returns an IS NOT NULL expression for qualified attribute' do
+        expect((users[:id].qualified.not(nil)).sql_literal(ds)).to eql('("users"."id" IS NOT NULL)')
+      end
+    end
+
+    context 'with a boolean true' do
+      it 'returns an IS NOT TRUE expression' do
+        expect(users[:id].not(true).sql_literal(ds)).to eql('("id" IS NOT TRUE)')
+      end
+
+      it 'returns an IS NOT TRUE expression for qualified attribute' do
+        expect((users[:id].qualified.not(true)).sql_literal(ds)).to eql('("users"."id" IS NOT TRUE)')
+      end
+    end
+
+    context 'with a boolean false' do
+      it 'returns an IS NOT FALSE expression' do
+        expect(users[:id].not(false).sql_literal(ds)).to eql('("id" IS NOT FALSE)')
+      end
+
+      it 'returns an IS NOT FALSE expression for qualified attribute' do
+        expect((users[:id].qualified.not(false)).sql_literal(ds)).to eql('("users"."id" IS NOT FALSE)')
+      end
     end
+  end
 
-    it 'returns a boolean expression for qualified attribute' do
-      expect((users[:id].qualified.is(1)).sql_literal(ds)).to eql('("users"."id" = 1)')
+  describe '#!' do
+    it 'returns a new attribute with negated sql expr' do
+      expect((!users[:id].is(1)).sql_literal(ds)).to eql('("id" != 1)')
     end
   end
 

data/spec/unit/migration_tasks_spec.rb

@@ -12,7 +12,9 @@ RSpec.describe 'MigrationTasks', :postgres, skip_tables: true do
   let(:migrator) { container.gateways[:default].migrator }
 
   before do
-    allow(ROM::SQL::RakeSupport).to receive(:env) { conf }
+    ROM::SQL::Gateway.instance = nil
+    ROM::SQL::RakeSupport.env = nil
+    conf
   end
 
   context 'db:reset' do
@@ -46,6 +48,15 @@ RSpec.describe 'MigrationTasks', :postgres, skip_tables: true do
         }.to output("<= db:migrate executed\n").to_stdout
       end
     end
+
+    it 'raises an error on missing both env and Gateway.instance' do
+      ROM::SQL::RakeSupport.env = nil
+      ROM::SQL::Gateway.instance = nil
+
+      expect {
+        Rake::Task["db:migrate"].execute
+      }.to raise_error(ROM::SQL::RakeSupport::MissingEnv)
+    end
   end
 
   context 'db:clean' do

data/spec/unit/order_dsl_spec.rb

@@ -31,5 +31,13 @@ RSpec.describe ROM::SQL::OrderDSL, :postgres, helpers: true do
       expect(dsl.call { nullif(id.qualified, `''`).desc }.first.sql_literal(conn[:users])).
         to eql(%(NULLIF("users"."id", '') DESC))
     end
+
+    it 'allows to set nulls first/last' do
+      expect(dsl.call { id.desc(nulls: :first) }.first.sql_literal(conn[:users])).
+        to eql(%("id" DESC NULLS FIRST))
+
+      expect(dsl.call { id.desc(nulls: :last) }.first.sql_literal(conn[:users])).
+        to eql(%("id" DESC NULLS LAST))
+    end
   end
 end

data/spec/unit/plugin/associates_spec.rb

@@ -0,0 +1,99 @@
+require 'ostruct'
+require 'rom/sql/commands'
+
+RSpec.describe ROM::SQL::Plugin::Associates do
+  subject(:command) do
+    command_class.build(posts).with_association(:tags)
+  end
+
+  let(:posts) do
+    instance_double(Class.new(ROM::SQL::Relation), schema?: false, associations: associations)
+  end
+
+  let(:tags) do
+    instance_double(ROM::SQL::Relation, associations: associations)
+  end
+
+  let(:join_relation) do
+    instance_double(ROM::SQL::Relation)
+  end
+
+  let(:registry) do
+    Hash.new { |h, k| h.fetch(k.to_sym) }.update(posts: posts, tags: tags)
+  end
+
+  let(:command_class) do
+    Class.new(ROM::SQL::Commands::Create) do
+      use :associates, tags: []
+    end
+  end
+
+  let(:associations) do
+    Hash.new { |h, k| h.fetch(k.to_sym) }.update(posts: posts_assoc)
+  end
+
+  let(:tags_assoc) do
+    ROM::SQL::Association::ManyToMany.new(:posts, :tags, through: :posts_tags)
+  end
+
+  let(:posts_assoc) do
+    ROM::SQL::Association::ManyToMany.new(:tags, :posts, through: :posts_tags)
+  end
+
+  before do
+    allow(posts).to receive(:__registry__).and_return(registry)
+    allow(associations).to receive(:try).and_yield(tags_assoc)
+    allow(tags_assoc).to receive(:join_keys).and_return({})
+  end
+
+  shared_context 'associates result' do
+    it 'inserts join tuples and returns child tuples with combine keys' do
+      expect(tags_assoc).to receive(:persist).with(registry, post_tuples, tag_tuples)
+      expect(tags_assoc).to receive(:parent_combine_keys).with(registry).and_return(%i[name tag])
+
+      result = command.associate(post_tuples, tag_tuples, assoc: tags_assoc, keys: {})
+
+      expect(result).
+        to match_array([
+                         { title: 'post 1', tag: 'red' }, { title: 'post 1', tag: 'green'},
+                         { title: 'post 2', tag: 'red' }, { title: 'post 2', tag: 'green'}
+                       ])
+    end
+  end
+
+  describe '#associate' do
+    context 'with plain hash tuples' do
+      let(:post_tuples) do
+        [{ title: 'post 1' }, { title: 'post 2' }]
+      end
+
+      let(:tag_tuples) do
+        [{ name: 'red' }, { name: 'green' }]
+      end
+
+      include_context 'associates result'
+    end
+
+    context 'with tuples coercible to a hash' do
+      before do
+        module Test
+          class Post < OpenStruct
+            def to_hash
+              { title: title }
+            end
+          end
+        end
+      end
+
+      let(:post_tuples) do
+        [Test::Post.new(title: 'post 1'), Test::Post.new(title: 'post 2')]
+      end
+
+      let(:tag_tuples) do
+        [{ name: 'red' }, { name: 'green' }]
+      end
+
+      include_context 'associates result'
+    end
+  end
+end