rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/unit/gateway_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-require 'rom/lint/spec'
-
-RSpec.describe ROM::SQL::Gateway, :postgres do
-  include_context 'users and tasks'
-
-  let(:gateway) { container.gateways[:default] }
-
-  it_behaves_like 'a rom gateway' do
-    let(:identifier) { :sql }
-    let(:gateway) { ROM::SQL::Gateway }
-  end
-
-  describe 'sqlite with a file db', :sqlite, postgres: false do
-    before do
-      Tempfile.new('test.sqlite')
-    end
-
-    it 'establishes an sqlite connection' do
-      gateway = ROM::SQL::Gateway.new(uri)
-      expect(gateway).to be_instance_of(ROM::SQL::Gateway)
-    end
-  end
-
-  describe '#dataset?' do
-    it 'returns true if a table exists' do
-      expect(gateway.dataset?(:users)).to be(true)
-    end
-
-    it 'returns false if a table does not exist' do
-      expect(gateway.dataset?(:not_here)).to be(false)
-    end
-  end
-
-  describe 'using options' do
-    it 'allows custom sequel-specific options' do
-      migrator = double('migrator')
-
-      expect(Sequel).to receive(:connect)
-        .with(uri, host: '127.0.0.1', migrator: migrator)
-        .and_return(conn)
-
-      gateway = ROM::SQL::Gateway.new(uri, migrator: migrator, host: '127.0.0.1')
-
-      expect(gateway.options).to eql(migrator: migrator, host: '127.0.0.1')
-    end
-
-    it 'allows extensions' do
-      extensions = [:pg_array, :pg_array_ops]
-      connection = Sequel.connect uri
-
-      expect(connection).to receive(:extension).with(:pg_array, :pg_json, :pg_enum, :pg_hstore, :pg_array_ops)
-      expect(connection).to receive(:extension).with(:freeze_datasets) unless RUBY_ENGINE == 'rbx'
-
-      ROM::SQL::Gateway.new(connection, extensions: extensions)
-    end
-  end
-
-  describe '#disconnect' do
-    let(:gateway) { ROM::SQL::Gateway.new(uri) }
-
-    it 'disconnects via sequel connection' do
-      # FIXME: no idea how to test it in a different way
-      # FIXME: we are leaking connection here
-      expect(gateway.connection).to receive(:disconnect)
-      gateway.disconnect
-    end
-  end
-end

data/spec/unit/logger_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Logger', :postgres do
-  include_context 'database setup'
-
-  it 'sets up a logger for sequel' do
-    gateway = container.gateways[:default]
-
-    gateway.use_logger(LOGGER)
-
-    expect(gateway.logger).to be(LOGGER)
-    expect(conn.loggers).to include(LOGGER)
-  end
-end

data/spec/unit/migration_tasks_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-namespace :db do
-  task :setup do
-    #noop
-  end
-end
-
-RSpec.describe 'MigrationTasks', :postgres, skip_tables: true do
-  include_context 'database setup'
-
-  let(:migrator) { container.gateways[:default].migrator }
-
-  before do
-    ROM::SQL::Gateway.instance = nil
-    ROM::SQL::RakeSupport.env = nil
-    conf
-  end
-
-  context 'db:reset' do
-    it 'calls proper commands' do
-      expect(migrator).to receive(:run).with(target: 0)
-      expect(migrator).to receive(:run)
-
-      expect {
-        Rake::Task["db:reset"].invoke
-      }.to output("<= db:reset executed\n").to_stdout
-    end
-  end
-
-  context 'db:migrate' do
-    context 'with VERSION' do
-      it 'calls proper commands' do
-        expect(migrator).to receive(:run).with(target: 1)
-
-        expect {
-          Rake::Task["db:migrate"].invoke(1)
-        }.to output("<= db:migrate version=[1] executed\n").to_stdout
-      end
-    end
-
-    context 'without VERSION' do
-      it 'calls proper commands' do
-        expect(migrator).to receive(:run)
-
-        expect {
-          Rake::Task["db:migrate"].execute
-        }.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
-    it 'calls proper commands' do
-      expect(migrator).to receive(:run).with(target: 0)
-
-      expect {
-        Rake::Task["db:clean"].invoke
-      }.to output("<= db:clean executed\n").to_stdout
-    end
-  end
-
-  context 'db:create_migration' do
-    context 'without NAME' do
-      it 'exit without creating any file' do
-        expect(File).to_not receive(:write)
-
-        expect {
-          expect {
-            Rake::Task["db:create_migration"].execute
-          }.to output(/No NAME specified/).to_stdout
-        }.to raise_error(SystemExit)
-      end
-    end
-
-    context 'with NAME' do
-      let(:dirname) { 'tmp/db/migrate' }
-      let(:name) { 'foo_bar' }
-      let(:version) { '001' }
-      let(:filename) { "#{version}_#{name}.rb" }
-      let(:path) { File.join(dirname, filename) }
-
-      it 'calls proper commands with default VERSION' do
-        expect(migrator).to receive(:create_file).with(name).and_return(path)
-
-        expect {
-          Rake::Task["db:create_migration"].execute(
-            Rake::TaskArguments.new([:name], [name]))
-        }.to output("<= migration file created #{path}\n").to_stdout
-      end
-
-      it 'calls proper commands with manualy set VERSION' do
-        expect(migrator).to receive(:create_file).with(name, version).and_return(path)
-
-        expect {
-          Rake::Task["db:create_migration"].execute(
-            Rake::TaskArguments.new([:name, :version], [name, version]))
-        }.to output("<= migration file created #{path}\n").to_stdout
-      end
-    end
-  end
-end

data/spec/unit/migrator_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe ROM::SQL::Migration::Migrator, :postgres, skip_tables: true do
-  include_context 'database setup'
-
-  subject(:migrator) { ROM::SQL::Migration::Migrator.new(conn, options) }
-
-  let(:options) { { path: TMP_PATH.join('test/migrations') } }
-
-  describe '#create_file' do
-    it 'creates a migration file under configured path with specified version and name' do
-      file_path = migrator.create_file('create_users', 1)
-
-      expect(file_path).to eql(migrator.path.join('1_create_users.rb'))
-      expect(File.exist?(file_path)).to be(true)
-      expect(File.read(file_path)).to eql(migrator.migration_file_content)
-    end
-
-    it 'auto-generates version when it is not provided' do
-      file_path = migrator.create_file('create_users')
-
-      expect(file_path.to_s).to match(/.(\d+)_create_users\.rb/)
-      expect(File.exist?(file_path)).to be(true)
-      expect(File.read(file_path)).to eql(migrator.migration_file_content)
-    end
-  end
-end

data/spec/unit/order_dsl_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::OrderDSL, :postgres, helpers: true do
-  include_context 'database setup'
-
-  subject(:dsl) do
-    ROM::SQL::OrderDSL.new(schema)
-  end
-
-  let(:schema) do
-    define_schema(:users, id: ROM::SQL::Types::Serial, name: ROM::SQL::Types::String)
-  end
-
-  let(:ds) do
-    conn[:users]
-  end
-
-  describe '#call' do
-    it 'returns an array with ordered expressions' do
-      expect(ds.literal(dsl.call { id }.first)).to eql('"id"')
-    end
-  end
-
-  describe '#method_missing' do
-    it 'responds to methods matching attribute names' do
-      expect(dsl.id.name).to be(:id)
-      expect(dsl.name.name).to be(:name)
-    end
-
-    it 'delegates to sequel virtual row' do
-      expect(ds.literal(dsl.call { nullif(id.qualified, Sequel.lit("''")).desc }.first)).
-        to eql(%(NULLIF("users"."id", '') DESC))
-    end
-
-    it 'allows to set nulls first/last' do
-      expect(ds.literal(dsl.call { id.desc(nulls: :first) }.first)).
-        to eql(%("id" DESC NULLS FIRST))
-
-      expect(ds.literal(dsl.call { id.desc(nulls: :last) }.first)).
-        to eql(%("id" DESC NULLS LAST))
-    end
-  end
-end

data/spec/unit/plugin/associates_spec.rb

@@ -1,94 +0,0 @@
-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(: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::Associations::ManyToMany.new(double(:definition).as_null_object, {})
-  end
-
-  let(:posts_assoc) do
-    ROM::SQL::Associations::ManyToMany.new(double(:definition).as_null_object, {})
-  end
-
-  before do
-    allow(associations).to receive(:[]).and_return(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(post_tuples, tag_tuples)
-      expect(tags_assoc).to receive(:parent_combine_keys).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

data/spec/unit/plugin/pagination_spec.rb

@@ -1,91 +0,0 @@
-require 'rom/sql/plugin/pagination'
-
-RSpec.describe 'Plugin / Pagination', seeds: false do
-  include_context 'users'
-
-  with_adapters do
-    before do
-      9.times { |i| conn[:users].insert(name: "User #{i}") }
-
-      conf.relation(:users) do
-        use :pagination
-
-        per_page 4
-      end
-    end
-
-    describe '#page' do
-      it 'allow to call with stringify number' do
-        expect {
-          container.relations[:users].page('5')
-        }.to_not raise_error
-      end
-
-      it 'preserves existing modifiers' do
-        expect(
-          container.relations[:users].send(:where, name: 'User 2').page(1).to_a.size
-        ).to be(1)
-      end
-    end
-
-    describe '#per_page' do
-      it 'allow to call with stringify number' do
-        expect {
-          container.relations[:users].per_page('5')
-        }.to_not raise_error
-      end
-
-      it 'returns paginated relation with provided limit' do
-        users = container.relations[:users].page(2).per_page(5)
-
-        expect(users.dataset.opts[:offset]).to eql(5)
-        expect(users.dataset.opts[:limit]).to eql(5)
-
-        expect(users.pager.current_page).to eql(2)
-
-        expect(users.pager.total).to be(9)
-        expect(users.pager.total_pages).to be(2)
-
-        expect(users.pager.next_page).to be(nil)
-        expect(users.pager.prev_page).to be(1)
-        expect(users.pager.limit_value).to eql(5)
-      end
-    end
-
-    describe '#total_pages' do
-      it 'returns a single page when elements are a perfect fit' do
-        users = container.relations[:users].page(1).per_page(3)
-        expect(users.pager.total_pages).to eql(3)
-      end
-
-      it 'returns the exact number of pages to accommodate all elements' do
-        users = container.relations[:users].per_page(9)
-        expect(users.pager.total_pages).to eql(1)
-      end
-    end
-
-    describe '#pager' do
-      it 'returns a pager with pagination meta-info' do
-        users = container.relations[:users].page(1)
-
-        expect(users.pager.total).to be(9)
-        expect(users.pager.total_pages).to be(3)
-
-        expect(users.pager.current_page).to be(1)
-        expect(users.pager.next_page).to be(2)
-        expect(users.pager.prev_page).to be(nil)
-
-        users = container.relations[:users].page(2)
-
-        expect(users.pager.current_page).to be(2)
-        expect(users.pager.next_page).to be(3)
-        expect(users.pager.prev_page).to be(1)
-
-        users = container.relations[:users].page(3)
-
-        expect(users.pager.next_page).to be(nil)
-        expect(users.pager.prev_page).to be(2)
-      end
-    end
-  end
-end