rom-sql 1.0.1 → 1.0.2

data/spec/integration/schema/inferrer_spec.rb

@@ -1,5 +1,9 @@
-RSpec.describe 'Schema inference for common datatypes' do
-  include_context 'database setup'
+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)
+  end
 
   let(:schema) { container.relations[dataset].schema }
 
@@ -22,10 +26,11 @@ RSpec.describe 'Schema inference for common datatypes' do
         let(:source) { ROM::Relation::Name[dataset] }
 
         it 'can infer attributes for dataset' 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)
-          )
+          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)
+               )
         end
       end
 
@@ -34,29 +39,35 @@ RSpec.describe 'Schema inference for common datatypes' do
         let(:source) { ROM::Relation::Name[:tasks] }
 
         it 'can infer attributes for dataset' 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),
-            user_id: ROM::SQL::Types::Int.optional.meta(name: :user_id,
-                                                        foreign_key: true,
-                                                        source: source,
-                                                        target: :users)
-         )
+          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),
+                 user_id: ROM::SQL::Types::Int.optional.meta(
+                   name: :user_id,
+                   foreign_key: true,
+                   source: source,
+                   target: :users
+                 )
+               )
         end
       end
 
       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
             Time :time
             Date :date
-            DateTime :datetime, null: false
+
+            if ctx.oracle?(example)
+              Date :datetime, null: false
+            else
+              DateTime :datetime, null: false
+            end
 
             if ctx.sqlite?(example)
               add_constraint(:test_constraint) { char_length(text) > 3 }
@@ -73,13 +84,14 @@ RSpec.describe 'Schema inference for common datatypes' do
         let(:dataset) { :test_inferrence }
         let(:source) { ROM::Relation::Name[dataset] }
 
-        it 'can infer attributes for dataset' do
+        it 'can infer attributes for dataset' do |ex|
+          date_type = oracle?(ex) ? ROM::SQL::Types::Time : ROM::SQL::Types::Date
+
           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),
-            flag: ROM::SQL::Types::Bool.meta(name: :flag, source: source),
             time: ROM::SQL::Types::Time.optional.meta(name: :time, source: source),
-            date: ROM::SQL::Types::Date.optional.meta(name: :date, source: source),
+            date: date_type.optional.meta(name: :date, source: source),
             datetime: ROM::SQL::Types::Time.meta(name: :datetime, source: source),
             data: ROM::SQL::Types::Blob.optional.meta(name: :data, source: source),
           )
@@ -87,10 +99,7 @@ RSpec.describe 'Schema inference for common datatypes' do
       end
 
       context 'numeric datatypes' do
-        before do |example|
-          ctx = self
-          conn.drop_table?(:test_numeric)
-
+        before do
           conn.create_table :test_numeric do
             primary_key :id
             decimal :dec, null: false
@@ -98,7 +107,6 @@ RSpec.describe 'Schema inference for common datatypes' do
             numeric :num, size: [5, 2], null: false
             smallint :small
             integer :int
-            bigint :big
             float :floating
             double :double_p
           end
@@ -107,15 +115,21 @@ RSpec.describe 'Schema inference for common datatypes' do
         let(:dataset) { :test_numeric }
         let(:source) { ROM::Relation::Name[dataset] }
 
+        let(:integer) { ROM::SQL::Types::Int.meta(source: source) }
         let(:decimal) { ROM::SQL::Types::Decimal.meta(source: source) }
 
         it 'infers attributes with precision' do |example|
           if mysql?(example)
             default_precision = decimal.meta(name: :dec, precision: 10, scale: 0)
+          elsif oracle?(example)
+            # Oracle treats DECIMAL as NUMBER(38, 0)
+            default_precision = integer.meta(name: :dec)
           else
             default_precision = decimal.meta(name: :dec)
           end
 
+          pending 'Add precision inferrence for Oracle' if oracle?(example)
+
           expect(schema.to_h).to eql(
             id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
             dec: default_precision,
@@ -123,7 +137,6 @@ RSpec.describe 'Schema inference for common datatypes' do
             num: decimal.meta(name: :num, precision: 5, scale: 2),
             small: ROM::SQL::Types::Int.optional.meta(name: :small, source: source),
             int: ROM::SQL::Types::Int.optional.meta(name: :int, source: source),
-            big: ROM::SQL::Types::Int.optional.meta(name: :big, source: source),
             floating: ROM::SQL::Types::Float.optional.meta(name: :floating, source: source),
             double_p: ROM::SQL::Types::Float.optional.meta(name: :double_p, source: source),
           )
@@ -132,11 +145,13 @@ RSpec.describe 'Schema inference for common datatypes' do
     end
 
     describe 'using commands with inferred schema' do
+      before do
+        inferrable_relations.concat %i(people)
+      end
+
       let(:relation) { container.relation(:people) }
 
       before do
-        conn.drop_table?(:people)
-
         conf.relation(:people) do
           schema(dataset, infer: true)
         end
@@ -218,21 +233,26 @@ RSpec.describe 'Schema inference for common datatypes' do
               end
             end
 
-            it 'accetps Time' do
+            it 'accetps Time' do |ex|
               time = Time.iso8601('1970-01-01T06:00:00')
               result = create.call(name: 'Jade', birth_date: time)
+              # Oracle's Date type stores time
+              expected_date = oracle?(ex) ? time : Date.iso8601('1970-01-01T00:00:00')
 
-              expect(result).to eql(id: 1, name: 'Jade', birth_date: Date.iso8601('1970-01-01T00:00:00'))
+              expect(result).to eql(id: 1, name: 'Jade', birth_date: expected_date)
             end
           end
 
           unless metadata[:sqlite] && defined? JRUBY_VERSION
             context 'timestamp' do
-              before do
+              before do |ex|
+                ctx = self
+
                 conn.create_table :people do
                   primary_key :id
                   String :name, null: false
-                  Timestamp :created_at, null: false
+                  # TODO: fix ROM, then Sequel to infer TIMESTAMP NOT NULL for Oracle
+                  Timestamp :created_at, null: ctx.oracle?(ex)
                 end
               end
 
@@ -259,7 +279,8 @@ RSpec.describe 'Schema inference for common datatypes' do
                 expect(result).to eql(id: 1, name: 'Jade', created_at: expected_time)
               end
 
-              if !metadata[:mysql]
+              # TODO: Find out if Oracle's adapter really doesn't support RFCs
+              if !metadata[:mysql] && !metadata[:oracle]
                 it 'accepts strings in RFC 2822' do
                   now = Time.now
                   result = create.call(name: 'Jade', created_at: now.rfc822)

data/spec/integration/schema/prefix_spec.rb

@@ -1,18 +1,16 @@
 require 'spec_helper'
 
-RSpec.describe ROM::SQL::Schema, '#prefix' do
-  include_context 'database setup'
+RSpec.describe ROM::SQL::Schema, '#prefix', :postgres, seeds: false do
+  include_context 'users'
 
-  with_adapters :postgres do
-    before do
-      conf.relation(:users) do
-        schema(infer: true)
-      end
+  before do
+    conf.relation(:users) do
+      schema(infer: true)
     end
+  end
 
-    it 'auto-projects a relation with renamed columns using provided prefix' do
-      expect(relations[:users].schema.prefix(:user).(relations[:users]).dataset.sql)
-        .to eql('SELECT "id" AS "user_id", "name" AS "user_name" FROM "users" ORDER BY "users"."id"')
-    end
+  it 'auto-projects a relation with renamed columns using provided prefix' do
+    expect(relations[:users].schema.prefix(:user).(relations[:users]).dataset.sql)
+      .to eql('SELECT "id" AS "user_id", "name" AS "user_name" FROM "users" ORDER BY "users"."id"')
   end
 end

data/spec/integration/schema/qualified_spec.rb

@@ -1,18 +1,16 @@
 require 'spec_helper'
 
-RSpec.describe ROM::SQL::Schema, '#qualified' do
-  include_context 'database setup'
+RSpec.describe ROM::SQL::Schema, '#qualified', :postgres, seeds: false do
+  include_context 'users'
 
-  with_adapters :postgres do
-    before do
-      conf.relation(:users) do
-        schema(infer: true)
-      end
+  before do
+    conf.relation(:users) do
+      schema(infer: true)
     end
+  end
 
-    it 'qualifies column names' do
-      expect(relations[:users].schema.qualified.(relations[:users]).dataset.sql)
-        .to eql('SELECT "users"."id", "users"."name" FROM "users" ORDER BY "users"."id"')
-    end
+  it 'qualifies column names' do
+    expect(relations[:users].schema.qualified.(relations[:users]).dataset.sql)
+      .to eql('SELECT "users"."id", "users"."name" FROM "users" ORDER BY "users"."id"')
   end
 end

data/spec/integration/schema/rename_spec.rb

@@ -1,23 +1,21 @@
 require 'spec_helper'
 
-RSpec.describe ROM::SQL::Schema, '#rename' do
-  include_context 'database setup'
+RSpec.describe ROM::SQL::Schema, '#rename', :postgres, seeds: false do
+  include_context 'users'
 
-  with_adapters :postgres do
-    before do
-      conf.relation(:users) do
-        schema(infer: true)
-      end
+  before do
+    conf.relation(:users) do
+      schema(infer: true)
     end
+  end
 
-    it 'auto-projects a relation with renamed columns' do
-      expect(relations[:users].schema.rename(id: :user_id, name: :user_name).(relations[:users]).dataset.sql)
-        .to eql('SELECT "id" AS "user_id", "name" AS "user_name" FROM "users" ORDER BY "users"."id"')
-    end
+  it 'auto-projects a relation with renamed columns' do
+    expect(relations[:users].schema.rename(id: :user_id, name: :user_name).(relations[:users]).dataset.sql)
+      .to eql('SELECT "id" AS "user_id", "name" AS "user_name" FROM "users" ORDER BY "users"."id"')
+  end
 
-    it 'auto-projects a relation with renamed and qualified columns' do
-      expect(relations[:users].schema.qualified.rename(id: :user_id, name: :user_name).(relations[:users]).dataset.sql)
-        .to eql('SELECT "users"."id" AS "user_id", "users"."name" AS "user_name" FROM "users" ORDER BY "users"."id"')
-    end
+  it 'auto-projects a relation with renamed and qualified columns' do
+    expect(relations[:users].schema.qualified.rename(id: :user_id, name: :user_name).(relations[:users]).dataset.sql)
+      .to eql('SELECT "users"."id" AS "user_id", "users"."name" AS "user_name" FROM "users" ORDER BY "users"."id"')
   end
 end

data/spec/integration/schema/view_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-RSpec.describe 'Defining a view using schemas' do
-  include_context 'database setup'
+RSpec.describe 'Defining a view using schemas', seeds: false do
+  include_context 'users'
 
   with_adapters do
     describe 'defining a projected view' do

data/spec/integration/sequel_api_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe 'Using legacy sequel api', :sqlite do
-  include_context 'database setup'
+  include_context 'users'
 
   let(:users) { relations[:users] }
 

data/spec/integration/setup_spec.rb

@@ -1,11 +1,7 @@
-RSpec.describe 'ROM.container', skip_tables: true do
+RSpec.describe 'ROM.container' 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
@@ -15,6 +11,10 @@ RSpec.describe 'ROM.container', skip_tables: true do
       end
     end
 
+    after do
+      rom.gateways[:default].connection.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,11 +1,11 @@
 require 'spec_helper'
 
-RSpec.describe 'ActiveSupport::Notifications support', :postgres do
+RSpec.describe 'ActiveSupport::Notifications support', :postgres, seeds: false do
   before do
     ROM::SQL.load_extensions(:active_support_notifications, :rails_log_subscriber)
   end
 
-  include_context 'database setup'
+  include_context 'users'
 
   it 'works' do
     container.gateways[:default].use_logger(LOGGER)

data/spec/integration/support/rails_log_subscriber_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 require 'active_support/log_subscriber/test_helper'
 
-RSpec.describe 'Rails log subscriber', :postgres do
+RSpec.describe 'Rails log subscriber', :postgres, seeds: false do
   before do
     ROM::SQL.load_extensions(:active_support_notifications, :rails_log_subscriber)
   end
 
   include ActiveSupport::LogSubscriber::TestHelper
 
-  include_context 'database setup'
+  include_context 'users'
 
   let(:test_query) do
     %(SELECT * FROM "users" WHERE name = 'notification test')

data/spec/shared/accounts.rb

@@ -0,0 +1,44 @@
+RSpec.shared_context 'accounts' do
+  let(:accounts) { container.relations[:accounts] }
+  let(:cards) { container.relations[:cards] }
+
+  before do
+    inferrable_relations.concat %i(accounts cards subscriptions)
+  end
+
+  before do |example|
+    ctx = self
+
+    conn.create_table :accounts do
+      primary_key :id
+      Integer :user_id
+      String :number
+
+      if ctx.oracle?(example)
+        Number :balance
+      else
+        Decimal :balance, size: [10, 2]
+      end
+    end
+
+    conn.create_table :cards do
+      primary_key :id
+      Integer :account_id
+      String :pan
+    end
+
+    conn.create_table :subscriptions do
+      primary_key :id
+      Integer :card_id
+      String :service
+    end
+  end
+
+  before do |example|
+    next if example.metadata[:seeds] == false
+
+    conn[:accounts].insert user_id: 1, number: '42', balance: 10_000.to_d
+    conn[:cards].insert id: 1, account_id: 1, pan: '*6789'
+    conn[:subscriptions].insert id: 1, card_id: 1, service: 'aws'
+  end
+end

data/spec/shared/database_setup.rb

@@ -1,4 +1,19 @@
-shared_context 'database setup' do
+RSpec.shared_context 'database setup' do
+  all_tables = %i(users tasks users_tasks tags task_tags posts puppies
+                  accounts cards subscriptions notes
+                  destinations flights categories user_group
+                  test_inferrence test_bidirectional people dragons
+                  rabbits carrots names schema_migrations)
+
+  cleared_dbs = []
+
+  before do
+    unless cleared_dbs.include?(conn.database_type)
+      all_tables.reverse.each { |table| conn.drop_table?(table) }
+      cleared_dbs << conn.database_type
+    end
+  end
+
   let(:uri) do |example|
     meta = example.metadata
     adapters = ADAPTERS.select { |adapter| meta[adapter] }
@@ -12,97 +27,43 @@ shared_context 'database setup' do
   end
 
   let(:conn) { Sequel.connect(uri) }
-  let(:conf) { ROM::Configuration.new(:sql, conn) }
+  let(:database_type) { conn.database_type }
+  let(:inferrable_relations) { [] }
+  let(:conf) { ROM::Configuration.new(:sql, conn, inferrable_relations: inferrable_relations) }
   let(:container) { ROM.container(conf) }
   let(:relations) { container.relations }
   let(:commands) { container.commands }
 
-  def drop_tables
-    %i(task_tags users_tasks tasks tags
-       subscriptions cards accounts
-       posts users
-       rabbits carrots notes
-       puppies schema_migrations
-    ).each do |name|
-      conn.drop_table?(name)
-    end
-  end
-
-  before do |example|
-    ctx = self
+  before do
     conn.loggers << LOGGER
+  end
 
-    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 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
-      primary_key :id
-      String :name
-    end
-
-    conn.create_table :task_tags do
-      primary_key [:tag_id, :task_id]
-      Integer :tag_id
-      Integer :task_id
-    end
-
-    conn.create_table :posts do
-      primary_key :post_id
-      foreign_key :author_id, :users
-      String :title
-      String :body
-    end
-
-    conn.create_table :accounts do
-      primary_key :id
-      Integer :user_id
-      String :number
-      Decimal :balance
-    end
-
-    conn.create_table :cards do
-      primary_key :id
-      Integer :account_id
-      String :pan
-    end
-
-    conn.create_table :subscriptions do
-      primary_key :id
-      Integer :card_id
-      String :service
-    end
+  after do
+    conn.disconnect
+    # Prevent the auto-reconnect when the test completed
+    # This will save from hardly reproducible connection run outs
+    conn.pool.available_connections.freeze
+  end
 
-    conn.create_table :puppies do
-      primary_key :id
-      String :name, null: false
-      TrueClass :cute, null: false, default: true
+  after do
+    inferrable_relations.reverse.each do |name|
+      conn.drop_table?(name)
     end
+  end
 
-    conn.create_table :notes do
-      primary_key :id
-      String :text, null: false
-      DateTime :created_at, null: false
-      DateTime :updated_at, null: false
-      DateTime :completed_at
-      Date :written
+  def db_true
+    if database_type == :oracle
+      'Y'
+    else
+      true
     end
   end
 
-  after do
-    conn.disconnect
+  def db_false
+    if database_type == :oracle
+      'N'
+    else
+      false
+    end
   end
 end