rom-sql 0.7.0 → 0.8.0

data/spec/integration/relation_schema_spec.rb

@@ -0,0 +1,180 @@
+RSpec.describe 'Inferring schema from database' do
+  include_context 'database setup'
+
+  with_adapters do
+    context "when database schema exists" do
+      it "infers the schema from the database relations" do
+        conf.relation(:users)
+
+        expect(container.relations.users.to_a)
+          .to eql(container.gateways[:default][:users].to_a)
+      end
+    end
+
+    context "for empty database schemas" do
+      it "returns an empty schema" do
+        drop_tables
+
+        expect { container.not_here }.to raise_error(NoMethodError)
+      end
+    end
+
+    context 'defining associations' do
+      it "allows defining a one-to-many" do
+        class Test::Posts < ROM::Relation[:sql]
+          schema(:posts) do
+            associations do
+              one_to_many :tags
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::OneToMany.new(:posts, :tags)
+
+        expect(Test::Posts.associations[:tags]).to eql(assoc)
+      end
+
+      it "allows defining a one-to-many using has_many shortcut" do
+        class Test::Posts < ROM::Relation[:sql]
+          schema(:posts) do
+            associations do
+              has_many :tags
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::OneToMany.new(:posts, :tags)
+
+        expect(Test::Posts.associations[:tags]).to eql(assoc)
+      end
+
+      it "allows defining a one-to-one" do
+        class Test::Users < ROM::Relation[:sql]
+          schema(:users) do
+            associations do
+              one_to_one :accounts
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::OneToOne.new(:users, :accounts)
+
+        expect(Test::Users.associations[:accounts]).to eql(assoc)
+      end
+
+      it "allows defining a one-to-one using has_one shortcut" do
+        class Test::Users < ROM::Relation[:sql]
+          schema(:users) do
+            associations do
+              has_one :account
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::OneToOne.new(:users, :accounts, as: :account)
+
+        expect(Test::Users.associations[:account]).to eql(assoc)
+        expect(Test::Users.associations[:account].target).to be_aliased
+      end
+
+      it "allows defining a one-to-one using has_one shortcut with an alias" do
+        class Test::Users < ROM::Relation[:sql]
+          schema(:users) do
+            associations do
+              has_one :account, as: :user_account
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::OneToOne.new(:users, :accounts, as: :user_account)
+
+        expect(Test::Users.associations[:user_account]).to eql(assoc)
+        expect(Test::Users.associations[:user_account].target).to be_aliased
+      end
+
+      it "allows defining a one-to-one-through" do
+        class Test::Users < ROM::Relation[:sql]
+          schema(:users) do
+            associations do
+              one_to_one :cards, through: :accounts
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::OneToOneThrough.new(:users, :cards, through: :accounts)
+
+        expect(Test::Users.associations[:cards]).to eql(assoc)
+      end
+
+      it "allows defining a many-to-one" do
+        class Test::Tags < ROM::Relation[:sql]
+          schema(:tags) do
+            associations do
+              many_to_one :posts
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :posts)
+
+        expect(Test::Tags.associations[:posts]).to eql(assoc)
+      end
+
+      it "allows defining a many-to-one using belongs_to shortcut" do
+        class Test::Tags < ROM::Relation[:sql]
+          schema(:tags) do
+            associations do
+              belongs_to :post
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :posts, as: :post)
+
+        expect(Test::Tags.associations[:post]).to eql(assoc)
+      end
+
+      it "allows defining a many-to-one using belongs_to shortcut" do
+        class Test::Tags < ROM::Relation[:sql]
+          schema(:tags) do
+            associations do
+              belongs_to :post, as: :post_tag
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :posts, as: :post_tag)
+
+        expect(Test::Tags.associations[:post_tag]).to eql(assoc)
+      end
+
+      it "allows defining a many-to-many" do
+        class Test::Posts < ROM::Relation[:sql]
+          schema(:posts) do
+            associations do
+              one_to_many :tags, through: :posts_tags
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::ManyToMany.new(:posts, :tags, through: :posts_tags)
+
+        expect(Test::Posts.associations[:tags]).to eql(assoc)
+      end
+
+      it "allows defining a many-to-one with a custom name" do
+        class Test::Tags < ROM::Relation[:sql]
+          schema(:tags) do
+            associations do
+              many_to_one :published_posts, relation: :posts
+            end
+          end
+        end
+
+        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :published_posts, relation: :posts)
+
+        expect(Test::Tags.associations[:published_posts]).to eql(assoc)
+      end
+    end
+  end
+end

data/spec/integration/schema_inference_spec.rb

@@ -0,0 +1,67 @@
+RSpec.describe 'Schema inference' 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
+  end
+
+  let(:schema) { container.relations[dataset].schema }
+
+  context '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 }
+
+      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)
+        )
+      end
+    end
+
+    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),
+          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)
+        )
+      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)
+        )
+      end
+    end
+  end
+end

data/spec/integration/setup_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe 'ROM.container' do
+  include_context 'database setup'
+
+  with_adapters do
+    let(:rom) do
+      ROM.container(:sql, uri) do |conf|
+        conf.default.create_table(:dragons) do
+          primary_key :id
+          column :name, String
+        end
+      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
+  end
+end

data/spec/shared/database_setup.rb

@@ -1,16 +1,29 @@
 shared_context 'database setup' do
-  let(:uri) { DB_URI }
+  let(:uri) do
+    if defined?(DB_URI)
+      DB_URI
+    else
+      POSTGRES_DB_URI
+    end
+  end
+
   let(:conn) { Sequel.connect(uri) }
-  let(:configuration) { ROM::Configuration.new(:sql, conn).use(:macros) }
-  let(:container) { ROM.container(configuration) }
+  let(:conf) { ROM::Configuration.new(:sql, conn) }
+  let(:container) { ROM.container(conf) }
+  let(:relations) { container.relations }
+  let(:commands) { container.commands }
 
   def drop_tables
-    [:tasks, :users, :tags, :task_tags, :rabbits, :carrots, :schema_migrations].each do |name|
+    %i(task_tags users_tasks tasks tags
+       subscriptions cards accounts
+       posts users
+       rabbits carrots schema_migrations
+    ).each do |name|
       conn.drop_table?(name)
     end
   end
 
-  before do
+  before do |example|
     conn.loggers << LOGGER
 
     drop_tables
@@ -18,14 +31,13 @@ shared_context 'database setup' do
     conn.create_table :users do
       primary_key :id
       String :name, null: false
-      index :name, unique: true
-      check { char_length(name) > 2 }
+      check { char_length(name) > 2 } if postgres?(example)
     end
 
     conn.create_table :tasks do
       primary_key :id
       foreign_key :user_id, :users
-      String :title
+      String :title, unique: true
     end
 
     conn.create_table :tags do
@@ -38,6 +50,32 @@ shared_context 'database setup' do
       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
   end
 
   after do

data/spec/shared/relations.rb

@@ -0,0 +1,8 @@
+RSpec.shared_context 'relations' do
+  include_context 'database setup'
+
+  before do
+    conf.relation(:users)
+    conf.relation(:tasks)
+  end
+end

data/spec/shared/users_and_accounts.rb

@@ -0,0 +1,10 @@
+shared_context 'users and accounts' do
+  include_context 'database setup'
+
+  before do
+    conn[:users].insert id: 1, name: 'Piotr'
+    conn[:accounts].insert id: 1, 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/users_and_tasks.rb

@@ -2,9 +2,27 @@ shared_context 'users and tasks' do
   include_context 'database setup'
 
   before do
-    conn[:users].insert id: 1, name: 'Piotr'
-    conn[:tasks].insert id: 1, user_id: 1, title: 'Finish ROM'
+    conn[:users].insert id: 1, name: 'Jane'
+    conn[:users].insert id: 2, name: 'Joe'
+
+    conn[:tasks].insert id: 1, user_id: 2, title: "Joe's task"
+    conn[:tasks].insert id: 2, user_id: 1, title: "Jane's task"
+
     conn[:tags].insert id: 1, name: 'important'
     conn[:task_tags].insert(tag_id: 1, task_id: 1)
+
+    conn[:posts].insert(
+      post_id: 1,
+      author_id: 2,
+      title: "Joe's post",
+      body: 'Joe wrote sutin'
+    )
+
+    conn[:posts].insert(
+      post_id: 2,
+      author_id: 1,
+      title: "Jane's post",
+      body: 'Jane wrote sutin'
+    )
   end
 end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@
 require 'bundler'
 Bundler.setup
 
-if RUBY_ENGINE == 'rbx'
+if RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
   require 'codeclimate-test-reporter'
   CodeClimate::TestReporter.start
 end
@@ -11,37 +11,90 @@ end
 require 'rom-sql'
 require 'rom/sql/rake_task'
 
-# FIXME: why do we need to require it manually??
-require 'sequel/adapters/postgres'
-require 'active_support/inflector'
-
 require 'logger'
+require 'tempfile'
+
 begin
   require 'byebug'
 rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
 
 LOGGER = Logger.new(File.open('./log/test.log', 'a'))
-DB_URI = 'postgres://localhost/rom_sql'
 
-root = Pathname(__FILE__).dirname
+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'
+else
+  SQLITE_DB_URI = 'sqlite::memory'
+  POSTGRES_DB_URI = 'postgres://localhost/rom_sql'
+  MYSQL_DB_URI = 'mysql2://root@localhost/rom_sql'
+end
+
+URIS = { postgres: POSTGRES_DB_URI, sqlite: SQLITE_DB_URI, mysql: MYSQL_DB_URI }
+ADAPTERS = URIS.keys
+PG_LTE_95 = ENV.fetch('PG_LTE_95', 'true') == 'true'
+
+SPEC_ROOT = root = Pathname(__FILE__).dirname
 TMP_PATH = root.join('../tmp')
 
-Dir[root.join('shared/*.rb').to_s].each { |f| require f }
+Dir[root.join('shared/**/*')].each { |f| require f }
+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
+
+def postgres?(example = nil)
+  db?(:postgres, example)
+end
+
+def mysql?(example = nil)
+  db?(:mysql, example)
+end
+
+def with_adapter(adapter, &block)
+  Object.const_set(:DB_URI, URIS[:mysql])
+  block.call
+  Object.send(:remove_const, :DB_URI)
+end
+
+def with_adapters(*args, &block)
+  adapters = args.empty? || args[0] == :all ? ADAPTERS : args
+
+  adapters.each do |adapter|
+    context("with #{adapter}", adapter: adapter, &block)
+  end
+end
 
 RSpec.configure do |config|
+  config.disable_monkey_patching
+
   config.before(:suite) do
     tmp_test_dir = TMP_PATH.join('test')
     FileUtils.rm_r(tmp_test_dir) if File.exist?(tmp_test_dir)
     FileUtils.mkdir_p(tmp_test_dir)
   end
 
+  config.around(adapter: :mysql) do |example|
+    with_adapter(:mysql) { example.run }
+  end
+
   config.before do
-    @constants = Object.constants
+    module Test
+    end
   end
 
   config.after do
-    added_constants = Object.constants - @constants
-    added_constants.each { |name| Object.send(:remove_const, name) }
+    Object.send(:remove_const, :Test)
   end
+
+  config.include(Helpers, helpers: true)
 end