rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/integration/schema/rename_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Schema, '#rename', :postgres, seeds: false do
-  include_context 'users'
-
-  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 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,29 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Defining a view using schemas', seeds: false do
-  include_context 'users'
-
-  with_adapters do
-    describe 'defining a projected view' do
-      before do
-        conf.relation(:users) do
-          schema(infer: true)
-
-          view(:names) do
-            schema { project(:name) }
-            relation { order(:name, :id) }
-          end
-        end
-
-        container.relations[:users].insert(name: 'Joe')
-        container.relations[:users].insert(name: 'Jane')
-        container.relations[:users].insert(name: 'Jade')
-      end
-
-      it 'automatically projects a relation view' do
-        expect(relations[:users].names.to_a)
-          .to eql([{ name: 'Jade' }, { name: 'Jane' }, { name: 'Joe' }])
-      end
-    end
-  end
-end

data/spec/integration/sequel_api_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Using legacy sequel api', :sqlite do
-  include_context 'users'
-
-  before do
-    conf.relation(:users) do
-      include ROM::SQL::Relation::SequelAPI
-    end
-
-    users.insert(name: 'Jane')
-  end
-
-  describe '#select' do
-    it 'selects columns' do
-      expect(users.select(Sequel.qualify(:users, :id), Sequel.qualify(:users, :name)).first).
-        to eql(id: 1, name: 'Jane')
-    end
-
-    it 'supports legacy blocks' do
-      expect(users.select { count(id).as(:count) }.group(:id).first).to eql(count: 1)
-    end
-  end
-
-  describe '#where' do
-    it 'restricts relation' do
-      expect(users.where(name: 'Jane').first).to eql(id: 1, name: 'Jane')
-    end
-  end
-
-  describe '#order' do
-    it 'orders relation' do
-      expect(users.order(Sequel.qualify(:users, :name)).first).to eql(id: 1, name: 'Jane')
-    end
-  end
-end

data/spec/integration/setup_spec.rb

@@ -1,26 +0,0 @@
-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
-
-        conf.relation(:dragons) do
-          schema(infer: true)
-        end
-      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
-  end
-end

data/spec/integration/support/active_support_notifications_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'ActiveSupport::Notifications support', :postgres, seeds: false do
-  before do
-    ROM::SQL.load_extensions(:active_support_notifications, :rails_log_subscriber)
-  end
-
-  include_context 'users'
-
-  it 'works' do
-    container.gateways[:default].use_logger(LOGGER)
-
-    sql = nil
-
-    ActiveSupport::Notifications.subscribe('sql.rom') do |*, payload|
-      sql = payload[:sql]
-    end
-
-    query = %(SELECT * FROM "users" WHERE name = 'notification test')
-    conn.run(query)
-
-    expect(sql).to eql(query)
-  end
-end

data/spec/integration/support/rails_log_subscriber_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-require 'active_support/log_subscriber/test_helper'
-
-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 'users'
-
-  let(:test_query) do
-    %(SELECT * FROM "users" WHERE name = 'notification test')
-  end
-
-  let(:logger) { ActiveSupport::LogSubscriber::TestHelper::MockLogger.new }
-
-  before do
-    set_logger(logger)
-    container.gateways[:default].use_logger(logger)
-  end
-
-  it 'works' do
-    conn.run(test_query)
-
-    expect(logger.logged(:debug).last).to include(test_query)
-  end
-end

data/spec/integration/wrap_spec.rb

@@ -1,91 +0,0 @@
-RSpec.describe ROM::SQL::Wrap do
-  with_adapters do
-    include_context 'users and tasks'
-
-    describe '#wrap' do
-      shared_context 'joined tuple' do
-        it 'returns nested tuples' do
-          task_with_user = tasks
-            .wrap(name)
-            .where { id.qualified.is(2) }
-            .one
-
-          expect(task_with_user).to eql(
-            id: 2, user_id: 1, title: "Jane's task", users_name: "Jane", users_id: 1
-          )
-        end
-
-        it 'works with by_pk' do
-          task_with_user = tasks
-                             .wrap(name)
-                             .by_pk(1)
-                             .one
-
-          expect(task_with_user).
-            to eql(id: 1, user_id: 2, title: "Joe's task", users_name: "Joe", users_id: 2)
-        end
-      end
-
-      context 'using association with inferred relation name' do
-        before do
-          conf.relation(:tasks) do
-            auto_map false
-
-            schema(infer: true) do
-              associations do
-                belongs_to :user
-              end
-            end
-          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
-            auto_map false
-
-            schema(infer: true) do
-              associations do
-                belongs_to :users, as: :assignee
-              end
-            end
-          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
-            auto_map false
-
-            schema(infer: true) do
-              associations do
-                belongs_to :users, as: :assignee, relation: :people
-              end
-            end
-          end
-
-          conf.relation(:people) do
-            auto_map false
-
-            schema(:users, infer: true)
-          end
-        end
-
-        include_context 'joined tuple' do
-          let(:users) { relations[:people] }
-          let(:name) { :assignee }
-        end
-      end
-    end
-  end
-end

data/spec/shared/accounts.rb

@@ -1,48 +0,0 @@
-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
-
-    conf.relation(:accounts) { schema(infer: true) }
-    conf.relation(:cards) { schema(infer: true) }
-    conf.relation(:subscriptions) { schema(infer: true) }
-  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,70 +0,0 @@
-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] }
-
-    case adapters.size
-    when 1 then DB_URIS.fetch(adapters.first)
-    when 0 then raise 'No adapter specified'
-    else
-      raise "Ambiguous adapter configuration, got #{adapters.inspect}"
-    end
-  end
-
-  let(:conn) { Sequel.connect(uri) }
-  let(:database_type) { conn.database_type }
-  let(:inferrable_relations) { [] }
-  let(:conf) { TestConfiguration.new(:sql, conn) }
-  let(:container) { ROM.container(conf) }
-  let(:relations) { container.relations }
-  let(:commands) { container.commands }
-
-  before do
-    conn.loggers << LOGGER
-    inferrable_relations.each { |name| conf.relation(name) { schema(infer: true) } }
-  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
-
-  after do
-    inferrable_relations.reverse.each do |name|
-      conn.drop_table?(name)
-    end
-  end
-
-  def db_true
-    if database_type == :oracle
-      'Y'
-    else
-      true
-    end
-  end
-
-  def db_false
-    if database_type == :oracle
-      'N'
-    else
-      false
-    end
-  end
-end

data/spec/shared/notes.rb

@@ -1,23 +0,0 @@
-RSpec.shared_context 'notes' do
-
-  before do
-    inferrable_relations.concat %i(notes)
-  end
-
-  before do |example|
-    ctx = self
-
-    conn.create_table :notes do
-      primary_key :id
-      foreign_key :user_id, :users
-      String :text, null: false
-      # TODO: Remove Oracle's workarounds once inferer can infer not-null timestamps
-      DateTime :created_at, null: ctx.oracle?(example)
-      DateTime :updated_at, null: ctx.oracle?(example)
-      DateTime :completed_at
-      Date :written
-    end
-
-    conf.relation(:notes) { schema(infer: true) }
-  end
-end

data/spec/shared/posts.rb

@@ -1,34 +0,0 @@
-RSpec.shared_context 'posts' do
-  before do
-    inferrable_relations.concat %i(posts)
-  end
-
-  before do |example|
-    conn.create_table :posts do
-      primary_key :post_id
-      foreign_key :author_id, :users
-      String :title
-      String :body
-    end
-
-    conf.relation(:posts) { schema(infer: true) }
-  end
-
-  before do |example|
-    next if example.metadata[:seeds] == false
-
-    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