rom-sql 0.8.0 → 0.9.0

data/spec/integration/schema_inference_spec.rb

@@ -1,66 +1,228 @@
-RSpec.describe 'Schema inference' do
+RSpec.describe 'Schema inference for common datatypes' do
   include_context 'database setup'
 
-  before do
-    conn.drop_table?(:test_inferrence)
-
-    conn.create_table :test_inferrence do
-      primary_key :id
-      String :text, null: false
-      Boolean :flag, null: false
-      Date :date
-      DateTime :datetime, null: false
-      Decimal :money, null: false
-      Bytea :data
-    end
+  let(:schema) { container.relations[dataset].schema }
+
+  def trunc_ts(time, drop_usec: false)
+    usec = drop_usec ? 0 : time.to_time.usec.floor
+    Time.mktime(time.year, time.month, time.day, time.hour, time.min, time.sec, usec)
   end
 
-  let(:schema) { container.relations[dataset].schema }
+  with_adapters do |adapter|
+    describe 'inferring attributes' do
+      before do
+        dataset = self.dataset
+        conf.relation(dataset) do
+          schema(dataset, infer: true)
+        end
+      end
+
+      context 'for simple table' do
+        let(:dataset) { :users }
 
-  context 'inferring attributes' do
-    before do
-      dataset = self.dataset
-      conf.relation(dataset) do
-        schema(dataset, infer: true)
+        it 'can infer attributes for dataset' do
+          expect(schema.attributes).to eql(
+            id: ROM::SQL::Types::Serial.meta(name: :id),
+            name: ROM::SQL::Types::String.meta(name: :name)
+          )
+        end
       end
-    end
 
-    context 'for simple table' do
-      let(:dataset) { :users }
+      context 'for a table with FKs' do
+        let(:dataset) { :tasks }
 
-      it 'can infer attributes for dataset' do
-        expect(schema.attributes).to eql(
-          id: ROM::SQL::Types::Serial.meta(name: :id),
-          name: ROM::SQL::Types::Strict::String.meta(name: :name)
-        )
+        it 'can infer attributes for dataset' do
+          expect(schema.attributes).to eql(
+            id: ROM::SQL::Types::Serial.meta(name: :id),
+            title: ROM::SQL::Types::String.optional.meta(name: :title),
+            user_id: ROM::SQL::Types::Int.optional.meta(name: :user_id,
+                                                        foreign_key: true,
+                                                        relation: :users)
+         )
+        end
       end
-    end
 
-    context 'for a table with FKs' do
-      let(:dataset) { :tasks }
+      context 'for complex table' do
+        before do |example|
+          ctx = self
+          conn.drop_table?(:test_inferrence)
+
+          conn.create_table :test_inferrence do
+            primary_key :id
+            String :text, null: false
+            Boolean :flag, null: false
+            Date :date
+            DateTime :datetime, null: false
+
+            if ctx.postgres?(example)
+              Bytea :data
+            else
+              Blob :data
+            end
+          end
+        end
+
+        let(:dataset) { :test_inferrence }
 
-      it 'can infer attributes for dataset' do
-        expect(schema.attributes).to eql(
-          id: ROM::SQL::Types::Serial.meta(name: :id),
-          title: ROM::SQL::Types::Strict::String.optional.meta(name: :title),
-          user_id: ROM::SQL::Types::Strict::Int.optional.meta(name: :user_id, foreign_key: true, relation: :users)
-        )
+        it 'can infer attributes for dataset' do
+          expect(schema.attributes).to eql(
+            id: ROM::SQL::Types::Serial.meta(name: :id),
+            text: ROM::SQL::Types::String.meta(name: :text),
+            flag: ROM::SQL::Types::Bool.meta(name: :flag),
+            date: ROM::SQL::Types::Date.optional.meta(name: :date),
+            datetime: ROM::SQL::Types::Time.meta(name: :datetime),
+            data: ROM::SQL::Types::Blob.optional.meta(name: :data)
+          )
+        end
       end
     end
 
-    context 'for complex table' do
-      let(:dataset) { :test_inferrence }
-
-      it 'can infer attributes for dataset' do
-        expect(schema.attributes).to eql(
-          id: ROM::SQL::Types::Serial.meta(name: :id),
-          text: ROM::SQL::Types::Strict::String.meta(name: :text),
-          flag: ROM::SQL::Types::Strict::Bool.meta(name: :flag),
-          date: ROM::SQL::Types::Strict::Date.optional.meta(name: :date),
-          datetime: ROM::SQL::Types::Strict::Time.meta(name: :datetime),
-          money: ROM::SQL::Types::Strict::Decimal.meta(name: :money),
-          data: ROM::SQL::Types::Strict::String.optional.meta(name: :data)
-        )
+    describe 'using commands with inferred schema' do
+      let(:relation) { container.relation(:people) }
+
+      before do
+        conn.drop_table?(:people)
+
+        conf.relation(:people) do
+          schema(dataset, infer: true)
+        end
+
+        conf.commands(:people) do
+          define(:create) do
+            result :one
+          end
+        end
+      end
+
+      describe 'inserting' do
+        let(:create) { commands[:people].create }
+
+        context "Sequel's types" do
+          before do
+            conn.create_table :people do
+              primary_key :id
+              String :name, null: false
+            end
+          end
+
+          it "doesn't coerce or check types on insert by default" do
+            result = create.call(name: Sequel.function(:upper, 'Jade'))
+
+            expect(result).to eql(id: 1, name: 'JADE')
+          end
+        end
+
+        context 'nullable columns' do
+          before do
+            conn.create_table :people do
+              primary_key :id
+              String :name, null: false
+              Integer :age, null: true
+            end
+          end
+
+          it 'allows to insert records with nil value' do
+            result = create.call(name: 'Jade', age: nil)
+
+            expect(result).to eql(id: 1, name: 'Jade', age: nil)
+          end
+
+          it 'allows to omit nullable columns' do
+            result = create.call(name: 'Jade')
+
+            expect(result).to eql(id: 1, name: 'Jade', age: nil)
+          end
+        end
+
+        context 'columns with default value' do
+          before do
+            conn.create_table :people do
+              primary_key :id
+              String :name, null: false
+              Integer :age, null: false, default: 18
+            end
+          end
+
+          it 'sets default value on missing key' do
+            result = create.call(name: 'Jade')
+
+            expect(result).to eql(id: 1, name: 'Jade', age: 18)
+          end
+
+          it 'raises an error on inserting nil value' do
+            expect { create.call(name: 'Jade', age: nil) }.to raise_error(ROM::SQL::NotNullConstraintError)
+          end
+        end
+
+        context 'coercions' do
+          context 'date' do
+            before do
+              conn.create_table :people do
+                primary_key :id
+                String :name, null: false
+                Date :birth_date, null: false
+              end
+            end
+
+            it 'accetps Time' do
+              time = Time.iso8601('1970-01-01T06:00:00')
+              result = create.call(name: 'Jade', birth_date: time)
+
+              expect(result).to eql(id: 1, name: 'Jade', birth_date: Date.iso8601('1970-01-01T00:00:00'))
+            end
+          end
+
+          unless metadata[:sqlite] && defined? JRUBY_VERSION
+            context 'timestamp' do
+              before do
+                conn.create_table :people do
+                  primary_key :id
+                  String :name, null: false
+                  Timestamp :created_at, null: false
+                end
+              end
+
+              it 'accepts Date' do
+                date = Date.today
+                result = create.call(name: 'Jade', created_at: date)
+
+                expect(result).to eql(id: 1, name: 'Jade', created_at: date.to_time)
+              end
+
+              it 'accepts Time' do |ex|
+                now = Time.now
+                result = create.call(name: 'Jade', created_at: now)
+
+                expected_time = trunc_ts(now, drop_usec: mysql?(ex))
+                expect(result).to eql(id: 1, name: 'Jade', created_at: expected_time)
+              end
+
+              it 'accepts DateTime' do |ex|
+                now = DateTime.now
+                result = create.call(name: 'Jade', created_at: now)
+
+                expected_time = trunc_ts(now, drop_usec: mysql?(ex))
+                expect(result).to eql(id: 1, name: 'Jade', created_at: expected_time)
+              end
+
+              if !metadata[:mysql]
+                it 'accepts strings in RFC 2822' do
+                  now = Time.now
+                  result = create.call(name: 'Jade', created_at: now.rfc822)
+
+                  expect(result).to eql(id: 1, name: 'Jade', created_at: trunc_ts(now, drop_usec: true))
+                end
+
+                it 'accepts strings in RFC 3339' do
+                  now = DateTime.now
+                  result = create.call(name: 'Jade', created_at: now.rfc3339)
+
+                  expect(result).to eql(id: 1, name: 'Jade', created_at: trunc_ts(now, drop_usec: true))
+                end
+              end
+            end
+          end
+        end
       end
     end
   end

data/spec/integration/setup_spec.rb

@@ -1,7 +1,11 @@
-RSpec.describe 'ROM.container' do
+RSpec.describe 'ROM.container', skip_tables: true do
   include_context 'database setup'
 
   with_adapters do
+    before do
+      conn.drop_table?(:dragons)
+    end
+
     let(:rom) do
       ROM.container(:sql, uri) do |conf|
         conf.default.create_table(:dragons) do
@@ -11,10 +15,6 @@ RSpec.describe 'ROM.container' do
       end
     end
 
-    after do
-      rom.gateways[:default].drop_table(:dragons)
-    end
-
     it 'creates tables within the setup block' do
       expect(rom.relations[:dragons]).to be_kind_of(ROM::SQL::Relation)
     end

data/spec/integration/support/active_support_notifications_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
-require 'rom/sql/support/active_support_notifications'
-require 'active_support/log_subscriber'
+RSpec.describe 'ActiveSupport::Notifications support', :postgres do
+  before do
+    ROM::SQL.load_extensions(:active_support_notifications, :rails_log_subscriber)
+  end
 
-describe 'ActiveSupport::Notifications support' do
   include_context 'database setup'
 
   it 'works' do

data/spec/integration/support/rails_log_subscriber_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
-require 'rom/sql/support/active_support_notifications'
-require 'rom/sql/support/rails_log_subscriber'
-
 require 'active_support/log_subscriber/test_helper'
 
-describe 'Rails log subscriber' do
+RSpec.describe 'Rails log subscriber', :postgres do
+  before do
+    ROM::SQL.load_extensions(:active_support_notifications, :rails_log_subscriber)
+  end
+
   include ActiveSupport::LogSubscriber::TestHelper
 
   include_context 'database setup'

data/spec/shared/database_setup.rb

@@ -1,9 +1,13 @@
 shared_context 'database setup' do
-  let(:uri) do
-    if defined?(DB_URI)
-      DB_URI
+  let(:uri) do |example|
+    meta = example.metadata
+    adapters = ADAPTERS.select { |adapter| meta[adapter] }
+
+    case adapters.size
+    when 1 then DB_URIS.fetch(adapters.first)
+    when 0 then raise 'No adapter specified'
     else
-      POSTGRES_DB_URI
+      raise "Ambiguous adapter configuration, got #{adapters.inspect}"
     end
   end
 
@@ -17,27 +21,32 @@ shared_context 'database setup' do
     %i(task_tags users_tasks tasks tags
        subscriptions cards accounts
        posts users
-       rabbits carrots schema_migrations
+       rabbits carrots
+       puppies schema_migrations
     ).each do |name|
       conn.drop_table?(name)
     end
   end
 
   before do |example|
+    ctx = self
     conn.loggers << LOGGER
 
     drop_tables
+    next if example.metadata[:skip_tables]
 
     conn.create_table :users do
       primary_key :id
       String :name, null: false
-      check { char_length(name) > 2 } if postgres?(example)
+      check { char_length(name) > 2 } if ctx.postgres?(example)
     end
 
     conn.create_table :tasks do
       primary_key :id
       foreign_key :user_id, :users
       String :title, unique: true
+      constraint(:title_length) { char_length(title) > 1 } if ctx.postgres?(example)
+      constraint(:title_length) { length(title) > 1 }      if ctx.sqlite?(example)
     end
 
     conn.create_table :tags do
@@ -76,6 +85,12 @@ shared_context 'database setup' do
       Integer :card_id
       String :service
     end
+
+    conn.create_table :puppies do
+      primary_key :id
+      String :name, null: false
+      TrueClass :cute, null: false, default: true
+    end
   end
 
   after do

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
-# encoding: utf-8
-
 require 'bundler'
 Bundler.setup
 
-if RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
-  require 'codeclimate-test-reporter'
-  CodeClimate::TestReporter.start
+if RUBY_ENGINE == 'ruby' && ENV['CI'] == 'true'
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
 end
 
 require 'rom-sql'
@@ -22,17 +22,20 @@ end
 LOGGER = Logger.new(File.open('./log/test.log', 'a'))
 
 if defined? JRUBY_VERSION
-  SQLITE_DB_URI = 'jdbc:sqlite:::memory'
-  POSTGRES_DB_URI = 'jdbc:postgresql://localhost/rom_sql'
-  MYSQL_DB_URI = 'jdbc:mysql://localhost/rom_sql?user=root'
+  DB_URIS = {
+    sqlite: 'jdbc:sqlite:::memory',
+    postgres: 'jdbc:postgresql://localhost/rom_sql',
+    mysql: 'jdbc:mysql://localhost/rom_sql?user=root'
+  }
 else
-  SQLITE_DB_URI = 'sqlite::memory'
-  POSTGRES_DB_URI = 'postgres://localhost/rom_sql'
-  MYSQL_DB_URI = 'mysql2://root@localhost/rom_sql'
+  DB_URIS = {
+    sqlite: 'sqlite::memory',
+    postgres: 'postgres://localhost/rom_sql',
+    mysql: 'mysql2://root@localhost/rom_sql'
+  }
 end
 
-URIS = { postgres: POSTGRES_DB_URI, sqlite: SQLITE_DB_URI, mysql: MYSQL_DB_URI }
-ADAPTERS = URIS.keys
+ADAPTERS = DB_URIS.keys
 PG_LTE_95 = ENV.fetch('PG_LTE_95', 'true') == 'true'
 
 SPEC_ROOT = root = Pathname(__FILE__).dirname
@@ -44,38 +47,48 @@ Dir[root.join('support/**/*')].each { |f| require f }
 require 'rom/support/deprecations'
 ROM::Deprecations.set_logger!(root.join('../log/deprecations.log'))
 
-def db?(type, example = nil)
-  if example
-    example.metadata[:adapter] == type
-  else
-    defined?(DB_URI) && DB_URI.include?(type.to_s)
-  end
-end
+ROM::SQL.load_extensions(:postgres)
 
-def postgres?(example = nil)
-  db?(:postgres, example)
+require 'dry-types'
+module Types
+  include Dry::Types.module
 end
 
-def mysql?(example = nil)
-  db?(:mysql, example)
-end
+module ENVHelper
+  def db?(type, example)
+    example.metadata[type]
+  end
+
+  def postgres?(example)
+    db?(:postgres, example)
+  end
 
-def with_adapter(adapter, &block)
-  Object.const_set(:DB_URI, URIS[:mysql])
-  block.call
-  Object.send(:remove_const, :DB_URI)
+  def mysql?(example)
+    db?(:mysql, example)
+  end
+
+  def sqlite?(example)
+    db?(:sqlite, example)
+  end
+
+  def jruby?
+    defined? JRUBY_VERSION
+  end
 end
 
 def with_adapters(*args, &block)
+  reset_adapter = { postgres: false, mysql: false, sqlite: false }
   adapters = args.empty? || args[0] == :all ? ADAPTERS : args
 
   adapters.each do |adapter|
-    context("with #{adapter}", adapter: adapter, &block)
+    context("with #{adapter}", **reset_adapter, adapter => true, &block)
   end
 end
 
 RSpec.configure do |config|
-  config.disable_monkey_patching
+  config.disable_monkey_patching!
+
+  config.include ENVHelper
 
   config.before(:suite) do
     tmp_test_dir = TMP_PATH.join('test')
@@ -83,10 +96,6 @@ RSpec.configure do |config|
     FileUtils.mkdir_p(tmp_test_dir)
   end
 
-  config.around(adapter: :mysql) do |example|
-    with_adapter(:mysql) { example.run }
-  end
-
   config.before do
     module Test
     end