rom 3.3.3 → 4.0.0.beta1

data/spec/unit/rom/commands/pre_and_post_processors_spec.rb

@@ -1,343 +0,0 @@
-require 'rom/command'
-require 'rom/memory'
-
-RSpec.describe ROM::Commands::Create[:memory], 'before/after hooks' do
-  let(:relation) do
-    spy(:relation)
-  end
-
-  describe '#before' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        before :init
-        before :normalize
-
-        def init(*)
-        end
-
-        def normalize(*)
-        end
-
-        def prepare(*)
-        end
-      end.build(relation)
-    end
-
-    it 'returns a new command with configured before hooks' do
-      expect(command.before(:prepare).before_hooks).to eql(%i[init normalize prepare])
-    end
-  end
-
-  describe '#after' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        after :finalize
-        after :filter
-
-        def finalize(*)
-        end
-
-        def filter(*)
-        end
-
-        def prepare(*)
-        end
-      end.build(relation)
-    end
-
-    it 'returns a new command with configured after hooks' do
-      expect(command.after(:prepare).after_hooks).to eql(%i[finalize filter prepare])
-    end
-
-    it 'worker with before' do
-      with_before_and_after = command.before(:filter).after(:finalize)
-
-      expect(with_before_and_after.before_hooks).to eql(%i[filter])
-      expect(with_before_and_after.after_hooks).to eql(%i[finalize filter finalize])
-    end
-  end
-
-  context 'without curried args' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        result :many
-        before :prepare
-        after :finalize
-
-        def execute(tuples)
-          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
-          relation.insert(input)
-          input
-        end
-
-        def prepare(tuples)
-          tuples.map { |tuple| tuple.merge(prepared: true) }
-        end
-
-        def finalize(tuples)
-          tuples.map { |tuple| tuple.merge(finalized: true) }
-        end
-      end.build(relation)
-    end
-
-    let(:tuples) do
-      [{ name: 'Jane' }, { name: 'Joe' }]
-    end
-
-    it 'applies before/after hooks' do
-      insert_tuples = [
-        { id: 1, name: 'Jane', prepared: true },
-        { id: 2, name: 'Joe', prepared: true }
-      ]
-
-      result = [
-        { id: 1, name: 'Jane', prepared: true, finalized: true },
-        { id: 2, name: 'Joe', prepared: true, finalized: true }
-      ]
-
-      expect(command.call(tuples)).to eql(result)
-
-      expect(relation).to have_received(:insert).with(insert_tuples)
-    end
-  end
-
-  context 'with one curried arg' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        result :many
-        before :prepare
-        after :finalize
-
-        def execute(tuples)
-          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
-          relation.insert(input)
-          input
-        end
-
-        def prepare(tuples, name)
-          tuples.map.with_index { |tuple, idx| tuple.merge(name: "#{name} #{idx + 1}") }
-        end
-
-        def finalize(tuples, *)
-          tuples.map { |tuple| tuple.merge(finalized: true) }
-        end
-      end.build(relation)
-    end
-
-    let(:tuples) do
-      [{ email: 'user-1@test.com' }, { email: 'user-2@test.com' }]
-    end
-
-    let(:relation) do
-      spy(:relation)
-    end
-
-    it 'applies before/after hooks' do
-      insert_tuples = [
-        { id: 1, email: 'user-1@test.com', name: 'User 1' },
-        { id: 2, email: 'user-2@test.com', name: 'User 2' }
-      ]
-
-      result = [
-        { id: 1, email: 'user-1@test.com', name: 'User 1', finalized: true },
-        { id: 2, email: 'user-2@test.com', name: 'User 2', finalized: true }
-      ]
-
-      expect(command.with(tuples).call('User')).to eql(result)
-
-      expect(relation).to have_received(:insert).with(insert_tuples)
-    end
-  end
-
-  context 'with 2 curried args' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        result :many
-        before :prepare
-        after :finalize
-
-        def execute(tuples)
-          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
-          relation.insert(input)
-          input
-        end
-
-        def prepare(tuples, name)
-          tuples.map.with_index { |tuple, idx| tuple.merge(name: "#{name} #{idx + 1}") }
-        end
-
-        def finalize(tuples, *)
-          tuples.map { |tuple| tuple.merge(finalized: true) }
-        end
-      end.build(relation)
-    end
-
-    let(:tuples) do
-      [{ email: 'user-1@test.com' }, { email: 'user-2@test.com' }]
-    end
-
-    let(:relation) do
-      spy(:relation)
-    end
-
-    it 'applies before/after hooks' do
-      insert_tuples = [
-        { id: 1, email: 'user-1@test.com', name: 'User 1' },
-        { id: 2, email: 'user-2@test.com', name: 'User 2' }
-      ]
-
-      result = [
-        { id: 1, email: 'user-1@test.com', name: 'User 1', finalized: true },
-        { id: 2, email: 'user-2@test.com', name: 'User 2', finalized: true }
-      ]
-
-      expect(command.with(tuples, 'User').call).to eql(result)
-
-      expect(relation).to have_received(:insert).with(insert_tuples)
-    end
-  end
-
-  context 'with pre-set opts' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        result :many
-        before prepare: { prepared: true }
-        after finalize: { finalized: true }
-
-        def execute(tuples)
-          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
-          relation.insert(input)
-          input
-        end
-
-        def prepare(tuples, opts)
-          tuples.map { |tuple| tuple.merge(opts) }
-        end
-
-        def finalize(tuples, opts)
-          tuples.map { |tuple| tuple.merge(opts) }
-        end
-      end.build(relation)
-    end
-
-    let(:tuples) do
-      [{ name: 'Jane' }, { name: 'Joe' }]
-    end
-
-    let(:relation) do
-      spy(:relation)
-    end
-
-    it 'applies before/after hooks' do
-      insert_tuples = [
-        { id: 1, name: 'Jane', prepared: true },
-        { id: 2, name: 'Joe', prepared: true }
-      ]
-
-      result = [
-        { id: 1, name: 'Jane', prepared: true, finalized: true },
-        { id: 2, name: 'Joe', prepared: true, finalized: true }
-      ]
-
-      expect(command.call(tuples)).to eql(result)
-
-      expect(relation).to have_received(:insert).with(insert_tuples)
-    end
-  end
-
-  context 'with pre-set opts for a curried command' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        result :many
-        before prepare: { prepared: true }
-        after finalize: { finalized: true }
-
-        def execute(tuples)
-          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
-          relation.insert(input)
-          input
-        end
-
-        def prepare(tuples, parent, opts)
-          tuples.map { |tuple| tuple.merge(opts).merge(parent_size: parent.size) }
-        end
-
-        def finalize(tuples, parent, opts)
-          tuples.map { |tuple| tuple.merge(opts).merge(user_id: parent[:id]) }
-        end
-      end.build(relation)
-    end
-
-    let(:tuples) do
-      [{ name: 'Jane' }, { name: 'Joe' }]
-    end
-
-    let(:relation) do
-      spy(:relation)
-    end
-
-    it 'applies before/after hooks' do
-      insert_tuples = [
-        { id: 1, name: 'Jane', parent_size: 1, prepared: true },
-        { id: 2, name: 'Joe', parent_size: 1, prepared: true }
-      ]
-
-      result = [
-        { id: 1, name: 'Jane', parent_size: 1, user_id: 1, prepared: true, finalized: true },
-        { id: 2, name: 'Joe', parent_size: 1, user_id: 1, prepared: true, finalized: true }
-      ]
-
-      expect(command.with(tuples).call(id: 1)).to eql(result)
-
-      expect(relation).to have_received(:insert).with(insert_tuples)
-    end
-  end
-
-  context 'calling with multiple args' do
-    subject(:command) do
-      Class.new(ROM::Commands::Create[:memory]) do
-        result :many
-        before prepare: { prepared: true }
-        after finalize: { finalized: true }
-
-        def execute(tuples)
-          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
-          relation.insert(input)
-          input
-        end
-
-        def prepare(tuples, parent, opts)
-          tuples.map { |tuple| tuple.merge(opts).merge(parent_size: parent.size) }
-        end
-
-        def finalize(tuples, parent, opts)
-          tuples.map { |tuple| tuple.merge(opts).merge(user_id: parent[:id]) }
-        end
-      end.build(relation)
-    end
-
-    let(:tuples) do
-      [{ name: 'Jane' }, { name: 'Joe' }]
-    end
-
-    let(:relation) do
-      spy(:relation)
-    end
-
-    it 'applies before/after hooks' do
-      insert_tuples = [
-        { id: 1, name: 'Jane', parent_size: 1, prepared: true },
-        { id: 2, name: 'Joe', parent_size: 1, prepared: true }
-      ]
-
-      result = [
-        { id: 1, name: 'Jane', parent_size: 1, user_id: 1, prepared: true, finalized: true },
-        { id: 2, name: 'Joe', parent_size: 1, user_id: 1, prepared: true, finalized: true }
-      ]
-
-      expect(command.call(tuples, id: 1)).to eql(result)
-
-      expect(relation).to have_received(:insert).with(insert_tuples)
-    end
-  end
-end

data/spec/unit/rom/commands/result_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Commands::Result do
-  describe '#value' do
-    subject(:result) { ROM::Commands::Result::Success }
-
-    it 'bubble up nested values' do
-      data = double(to_ary: ['foo'])
-      r = result.new(result.new(result.new(data)))
-
-      expect(r.value).to eq(data)
-    end
-  end
-
-  describe '#success?' do
-    context 'not launched command' do
-      subject(:command) { ROM::Commands::Result }
-
-      it 'returns false' do
-        expect(command.new.success?).to eq(false)
-      end
-    end
-
-    context 'successful command' do
-      subject(:result) { ROM::Commands::Result::Success }
-
-      it 'returns true' do
-        data = double(to_ary: ['foo'])
-        expect(result.new(data).success?).to eq(true)
-      end
-    end
-
-    context 'failed command' do
-      subject(:result) { ROM::Commands::Result::Failure }
-
-      it 'returns false' do
-        error = double(:error)
-        expect(result.new(error).success?).to eq(false)
-      end
-    end
-  end
-
-  describe '#failure?' do
-    context 'not launched command' do
-      subject(:command) { ROM::Commands::Result }
-
-      it 'returns false' do
-        expect(command.new.success?).to eq(false)
-      end
-    end
-
-    context 'successful command' do
-      subject(:result) { ROM::Commands::Result::Success }
-
-      it 'returns false' do
-        data = double(to_ary: ['foo'])
-        expect(result.new(data).failure?).to eq(false)
-      end
-    end
-
-    context 'failed command' do
-      subject(:result) { ROM::Commands::Result::Failure }
-
-      it 'returns true' do
-        error = double(:error)
-        expect(result.new(error).failure?).to eq(true)
-      end
-    end
-  end
-end

data/spec/unit/rom/commands_spec.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Commands' do
-  include_context 'gateway only'
-  include_context 'users and tasks'
-
-  let(:users_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def by_id(id)
-        restrict(id: id)
-      end
-    end.new(users_dataset)
-  end
-
-  describe '.build_class' do
-    it 'creates a command class constant' do
-      klass = ROM::ConfigurationDSL::Command.build_class(:create, :users, adapter: :memory) {
-        def super?
-          true
-        end
-      }
-
-      expect(klass.name).to eql('ROM::Memory::Commands::Create[Users]')
-      expect(klass.register_as).to eql(:create)
-
-      command = klass.build(users_relation)
-
-      expect(command).to be_a(ROM::Memory::Commands::Create)
-      expect(command).to be_super
-    end
-  end
-
-  describe '.create_class' do
-    it 'builds a class' do
-      klass = ROM::Command.create_class(:create, ROM::Memory::Commands::Create)
-
-      expect(klass.name).to eql('ROM::Memory::Commands::Create[:create]')
-    end
-
-    it 'builds a class and yields it' do
-      klass = ROM::Command.create_class(:create, ROM::Memory::Commands::Create) do |k|
-        k.result :one
-        k
-      end
-
-      expect(klass.name).to eql('ROM::Memory::Commands::Create[:create]')
-      expect(klass.result).to be(:one)
-    end
-  end
-
-  describe '.build' do
-    it 'returns create command when type is set to :create' do
-      klass = Class.new(ROM::Commands::Create[:memory]) do
-        relation :users
-      end
-
-      command = klass.build(users_relation)
-
-      expect(command).to be_kind_of(ROM::Memory::Commands::Create)
-    end
-
-    it 'returns update command when type is set to :update' do
-      klass = Class.new(ROM::Commands::Update[:memory]) do
-        relation :users
-      end
-
-      command = klass.build(users_relation)
-
-      expect(command).to be_kind_of(ROM::Memory::Commands::Update)
-    end
-
-    it 'returns delete command when type is set to :delete' do
-      klass = Class.new(ROM::Commands::Delete[:memory]) do
-        relation :users
-      end
-
-      command = klass.build(users_relation)
-
-      expect(command).to be_kind_of(ROM::Memory::Commands::Delete)
-    end
-  end
-
-  describe '#>>' do
-    let(:users) { double('users', schema: nil) }
-    let(:tasks) { double('tasks', schema: nil) }
-    let(:logs) { double('logs', schema: nil) }
-
-    it 'composes two commands' do
-      user_input = { name: 'Jane' }
-      user_tuple = { user_id: 1, name: 'Jane' }
-
-      task_input = { title: 'Task One' }
-      task_tuple = { user_id: 1, title: 'Task One' }
-
-      create_user = Class.new(ROM::Commands::Create) {
-        def execute(user_input)
-          relation.insert(user_input)
-        end
-      }.build(users)
-
-      create_task = Class.new(ROM::Commands::Create) {
-        before :associate
-
-        def associate(task_input, user_tuple)
-          task_input.merge(user_id: user_tuple[:user_id])
-        end
-
-        def execute(task_input)
-          relation.insert(task_input)
-        end
-      }.build(tasks)
-
-      create_log = Class.new(ROM::Commands::Create) {
-        result :one
-
-        def execute(task_tuple)
-          relation << task_tuple
-        end
-      }.build(logs)
-
-      command = create_user.curry(user_input)
-      command >>= create_task.curry(task_input)
-      command >>= create_log
-
-      expect(users).to receive(:insert).with(user_input).and_return(user_tuple)
-      expect(tasks).to receive(:insert).with(task_tuple).and_return(task_tuple)
-      expect(logs).to receive(:<<).with(task_tuple).and_return([task_tuple])
-
-      expect(command.call).to eql(task_tuple)
-    end
-
-    it 'forwards methods to the left' do
-      user_input = { name: 'Jane' }
-      user_tuple = { user_id: 1, name: 'Jane' }
-
-      create_user = Class.new(ROM::Commands::Create) {
-        def execute(user_input)
-          relation.insert(user_input)
-        end
-      }.build(users)
-
-      command = create_user >> proc {}
-
-      expect(users).to receive(:insert).with(user_input).and_return(user_tuple)
-
-      command.with(user_input).call
-    end
-
-    it 'short-circuits pipeline when left-side result is empty' do
-      command = Class.new(ROM::Commands::Update) do
-        result :one
-
-        def execute(*)
-          []
-        end
-      end.build(users) >> -> result { result.map(&:to_a) }
-
-      expect(command.call('foo')).to be(nil)
-
-      command = Class.new(ROM::Commands::Update) do
-        result :many
-
-        def execute(*)
-          []
-        end
-      end.build(users) >> -> result { result.map(&:to_a) }
-
-      expect(command.call('foo')).to be(ROM::EMPTY_ARRAY)
-    end
-  end
-
-  describe '#with_opts' do
-    subject(:command) do
-      Class.new(ROM::Command::Create).build(relation, options)
-    end
-
-    let(:relation) { double(:relation) }
-    let(:options) { { result: :one } }
-
-    it 'returns a new command with updated options' do
-      new_command = command.with_opts(before: :test)
-
-      expect(new_command.relation).to be(relation)
-      expect(new_command.result).to be(:one)
-      expect(new_command.before_hooks).to eql([:test])
-    end
-  end
-end

data/spec/unit/rom/configurable_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Configurable do
-  let (:klass) { Class.new { include ROM::Configurable } }
-  let (:object) { klass.new }
-  let (:config) { object.config }
-  
-  it 'exposes the config property' do
-    expect { config }.not_to raise_error
-  end
-  
-  it 'is configurable via block' do
-    object.configure do |config|
-      config.sql.infer_relations = false
-    end
-    
-    expect(config.sql.infer_relations).to be(false)
-  end
-  
-  context ROM::Configurable::Config do  
-    it 'can be traversed via dot syntax' do
-      config.sql.infer_relations = false
-      expect(config.sql.infer_relations).to be(false)
-    end
-  
-    it 'can be traversed via bracket syntax' do
-      config[:sql].infer_relations = false
-
-      expect(config[:sql][:infer_relations]).to be(false)
-      expect(config).to respond_to(:sql)
-      expect(config.sql.infer_relations).to be(false)
-    end
-  
-    it 'freezes properly' do
-      config.freeze
-
-      expect { config.sql.infer_relations = false }.to raise_error(NoMethodError)
-    end
-
-    it 'handles unset keys when frozen' do
-      config.sql.infer_relations = false
-      config.freeze
-      
-      expect(config.other).to be(nil)
-      expect(config.key?(:other)).to be(false)
-      expect(config.key?(:sql)).to be(true)
-    end
-  end
-end

data/spec/unit/rom/configuration_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Configuration do
-  it 'is configurable via settings hash' do
-    configuration = ROM::Configuration.new(:memory, 'something', infer_schema: false)
-
-    expect(configuration.config.gateways.default.infer_schema).to be(false)
-
-    configuration = ROM::Configuration.new(:memory, infer_schema: false)
-
-    expect(configuration.config.gateways.default.infer_schema).to be(false)
-
-    configuration = ROM::Configuration.new(default: [:memory, infer_schema: false])
-
-    expect(configuration.config.gateways.default.infer_schema).to be(false)
-  end
-
-  describe '#method_missing' do
-    it 'returns a gateway if it is defined' do
-      repo = double('repo')
-      configuration = ROM::Configuration.new(repo: repo)
-
-      expect(configuration.repo).to be(repo)
-    end
-
-    it 'raises error if repo is not defined' do
-      configuration = ROM::Configuration.new
-
-      expect { configuration.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe '#[]' do
-    it 'returns a gateway if it is defined' do
-      repo = double('repo')
-      configuration = ROM::Configuration.new(repo: repo)
-
-      expect(configuration[:repo]).to be(repo)
-    end
-
-    it 'raises error if repo is not defined' do
-      configuration = ROM::Configuration.new({})
-
-      expect { configuration[:not_here] }.to raise_error(KeyError, /not_here/)
-    end
-  end
-
-  describe 'defining components when adapter was not registered' do
-    it 'raises error when trying to define a relation' do
-      expect {
-        Class.new(ROM::Relation[:not_here])
-      }.to raise_error(ROM::AdapterNotPresentError, /not_here/)
-    end
-
-    it 'raises error when trying to define a command' do
-      expect {
-        Class.new(ROM::Commands::Create[:not_here])
-      }.to raise_error(ROM::AdapterNotPresentError, /not_here/)
-    end
-  end
-end