rom 1.0.0 → 2.0.0

data/spec/integration/command_registry_spec.rb

@@ -15,6 +15,19 @@ describe 'ROM::CommandRegistry' do
     end)
   end
 
+  describe '#[]' do
+    it 'fetches a command from the registry' do
+      expect(users[:create]).to be_a(ROM::Commands::Create[:memory])
+    end
+
+    it 'throws an error when the command is not found' do
+      expect { users[:not_found] }.to raise_error(
+        ROM::CommandRegistry::CommandNotFoundError,
+        'There is no :not_found command for :users relation'
+      )
+    end
+  end
+
   describe '#try' do
     it 'returns a success result object on successful execution' do
       result = users.try { users.create.call(name: 'Jane') }

data/spec/integration/commands/delete_spec.rb

@@ -64,21 +64,4 @@ describe 'Commands / Delete' do
 
     expect(result.value).to eql(name: 'Jane', email: 'jane@doe.org')
   end
-
-  it 'raises when result is set to :one and relation contains more tuples' do
-    configuration.commands(:users) do
-      define(:delete) do
-        result :one
-      end
-    end
-
-    result = users.try { users.delete.call }
-
-    expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
-
-    expect(container.relations.users.to_a).to match_array([
-      { name: 'Jane', email: 'jane@doe.org' },
-      { name: 'Joe', email: 'joe@doe.org' }
-    ])
-  end
 end

data/spec/integration/commands/graph_builder_spec.rb

@@ -208,6 +208,6 @@ RSpec.describe 'Command graph builder' do
   it 'raises when unknown command is accessed' do
     expect {
       container.command.not_here(:users)
-    }.to raise_error(ROM::Registry::ElementNotFoundError, /not_here/)
+    }.to raise_error(ROM::CommandRegistry::CommandNotFoundError, /not_here/)
   end
 end

data/spec/integration/commands/graph_spec.rb

@@ -265,7 +265,7 @@ describe 'Building up a command graph for nested input' do
 
     command = container.command(options).as(:entity)
 
-    result = command.call(input).one
+    result = command.call(input)
 
     expect(result).to be_instance_of(Test::User)
     expect(result.tasks.first).to be_instance_of(Test::Task)

data/spec/integration/commands/update_spec.rb

@@ -73,25 +73,6 @@ describe 'Commands / Update' do
       expect(result.value).to eql(name: 'Jane', email: 'jane.doe@test.com')
     end
 
-    it 'raises when there is more than one tuple and result is set to :one' do
-      configuration.commands(:users) do
-        define(:update_one, type: :update) do
-          result :one
-        end
-      end
-
-      result = users.try {
-        users.update_one.call(email: 'jane.doe@test.com')
-      }
-
-      expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
-
-      expect(container.relations.users).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
     it 'allows only valid result types' do
       expect {
         configuration.commands(:users) do

data/spec/integration/commands_spec.rb

@@ -10,20 +10,27 @@ describe 'Commands' do
         restrict(id: id)
       end
     end
+
     configuration.commands(:users) do
       define(:update)
+      define(:create)
     end
   end
 
-  let(:command) { container.command(:users)[:update] }
+  let(:create) { container.command(:users)[:create] }
+  let(:update) { container.command(:users)[:update] }
 
   describe '#method_missing' do
     it 'forwards known relation view methods' do
-      expect(command.by_id(1).relation).to eql(users_relation.by_id(1))
+      expect(update.by_id(1).relation).to eql(users_relation.by_id(1))
     end
 
     it 'raises no-method error when a non-view relation method was sent' do
-      expect { command.as(:foo) }.to raise_error(NoMethodError, /as/)
+      expect { update.as(:foo) }.to raise_error(NoMethodError, /as/)
+    end
+
+    it 'does not forward relation view methods to non-restrictable commands' do
+      expect { create.by_id(1) }.to raise_error(NoMethodError, /by_id/)
     end
   end
 

data/spec/integration/multi_repo_spec.rb

@@ -3,7 +3,7 @@ require 'rom/memory'
 
 describe 'Using in-memory gateways for cross-repo access' do
   let(:configuration) do
-    ROM::Configuration.new(left: :memory, right: :memory, main: :memory).use(:macros)
+    ROM::Configuration.new(left: :memory, right: :memory, main: :memory)
   end
 
   let(:container) { ROM.container(configuration) }

data/spec/integration/relations/default_dataset_spec.rb

@@ -5,11 +5,34 @@ describe ROM::Relation, '.dataset' do
 
   it 'injects configured dataset when block was provided' do
     configuration.relation(:users) do
-      dataset { restrict(name: 'Jane') }
+      dataset do
+        insert(id: 2, name: 'Joe')
+        insert(id: 1, name: 'Jane')
+
+        restrict(name: 'Jane')
+      end
+    end
+
+    expect(container.relation(:users).to_a).to eql([{ id: 1, name: 'Jane' }])
+  end
+
+  it 'yields relation class for setting custom dataset proc' do
+    configuration.relation(:users) do
+      schema do
+        attribute :id, ROM::Memory::Types::Int.meta(primary_key: true)
+        attribute :name, ROM::Memory::Types::String
+      end
+
+      dataset do |rel_klass|
+        insert(id: 2, name: 'Joe')
+        insert(id: 1, name: 'Jane')
+
+        order(*rel_klass.schema.primary_key.map { |t| t.meta[:name] })
+      end
     end
 
-    expect(container.relation(:users).dataset).to eql(
-      container.relation(:users).dataset.restrict(name: 'Jane')
-    )
+    expect(container.relation(:users).to_a).to eql([
+      { id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }
+    ])
   end
 end

data/spec/integration/setup_spec.rb

@@ -43,7 +43,6 @@ describe 'Configuring ROM' do
   describe 'defining classes' do
     it 'sets up registries based on class definitions' do
       container = ROM.container(:memory) do |config|
-        config.use(:macros)
 
         class Test::UserRelation < ROM::Relation[:memory]
           dataset :users
@@ -87,8 +86,6 @@ describe 'Configuring ROM' do
       end
 
       container = ROM.container(:memory) do |rom|
-        rom.use(:macros)
-
         rom.relation(:users) do
           def by_name(name)
             restrict(name: name)
@@ -122,7 +119,7 @@ describe 'Configuring ROM' do
         end
       end
 
-      configuration = ROM::Configuration.new(:memory).use(:macros)
+      configuration = ROM::Configuration.new(:memory)
 
       configuration.relation(:users) do
         def by_name(name)

data/spec/shared/command_behavior.rb

@@ -1,14 +1,24 @@
 shared_examples_for 'a command' do
-  describe '#method_missing' do
-    it 'forwards to relation and wraps response if it returned another relation' do
-      new_command = command.by_id(1)
+  describe '#name' do
+    it 'returns relation name' do
+      expect(command.name).to eql(command.relation.name)
+    end
+  end
 
-      expect(new_command).to be_instance_of(command.class)
-      expect(new_command.relation).to eql(command.by_id(1).relation)
+  describe '#gateway' do
+    it 'returns relation gateway' do
+      expect(command.gateway).to eql(command.relation.gateway)
     end
+  end
 
-    it 'returns original response if it was not a relation' do
-      expect(command.name).to eql(command.relation.name)
+  describe '#method_missing' do
+    it 'forwards to relation and wraps response if it returned another relation' do
+      if command.class.restrictable
+        new_command = command.by_id(1)
+
+        expect(new_command).to be_instance_of(command.class)
+        expect(new_command.relation).to eql(command.by_id(1).relation)
+      end
     end
 
     it 'raises error when message is not known' do

data/spec/shared/container.rb

@@ -1,9 +1,9 @@
 RSpec.shared_context 'container' do
   let(:container) { ROM.container(configuration) }
-  let!(:configuration) { ROM::Configuration.new(:memory).use(:macros) }
+  let!(:configuration) { ROM::Configuration.new(:memory) }
   let(:gateway) { configuration.gateways[:default] }
   let(:users_relation) { container.relation(:users) }
   let(:tasks_relation) { container.relation(:tasks) }
   let(:users_dataset) { gateway.dataset(:users) }
   let(:tasks_dataset) { gateway.dataset(:tasks) }
-end
+end

data/spec/shared/gateway_only.rb

@@ -3,4 +3,4 @@ RSpec.shared_context 'gateway only' do
 
   let(:users_dataset) { gateway.dataset(:users) }
   let(:tasks_dataset) { gateway.dataset(:tasks) }
-end
+end

data/spec/spec_helper.rb

@@ -9,6 +9,11 @@ if RUBY_ENGINE == "rbx"
   CodeClimate::TestReporter.start
 end
 
+SPEC_ROOT = root = Pathname(__FILE__).dirname
+
+require 'rom/support/deprecations'
+ROM::Deprecations.set_logger!(SPEC_ROOT.join('../log/deprecations.log'))
+
 require 'rom'
 require 'anima'
 
@@ -17,8 +22,6 @@ begin
 rescue LoadError
 end
 
-SPEC_ROOT = root = Pathname(__FILE__).dirname
-
 Dir[root.join('support/*.rb').to_s].each do |f|
   require f
 end
@@ -38,10 +41,6 @@ def T(*args)
 end
 
 RSpec.configure do |config|
-  config.before do
-    ROM.env = nil
-  end
-
   config.after do
     Test.remove_constants
   end

data/spec/unit/rom/association_set_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe ROM::AssociationSet do
+  describe '#try' do
+    it 'returns association when it exists' do
+      assoc = spy(:assoc)
+      assoc_set = ROM::AssociationSet.new(users: assoc)
+
+      assoc_set.try(:users, &:done)
+
+      expect(assoc).to have_received(:done)
+    end
+
+    it 'returns false when assoc is not found' do
+      assoc = spy(:assoc)
+      fallback = spy(:fallback)
+      assoc_set = ROM::AssociationSet.new({})
+
+      assoc_set.try(:users, &:done) or fallback.done
+
+      expect(assoc).to_not have_received(:done)
+      expect(fallback).to have_received(:done)
+    end
+  end
+end

data/spec/unit/rom/auto_registration_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe ROM::Setup, '#auto_registration' do
 
   context 'with namespace turned on' do
     before do
-      setup.auto_registration(SPEC_ROOT.join('fixtures/lib/persistence'))
+      setup.auto_registration(SPEC_ROOT.join('fixtures/lib/persistence').to_s)
     end
 
     describe '#relations' do

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

@@ -284,6 +284,14 @@ describe ROM::Commands::Lazy do
     end
   end
 
+  describe '#unwrap' do
+    subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
+
+    it 'returns wrapped command' do
+      expect(command.unwrap).to be(create_user)
+    end
+  end
+
   describe '#method_missing' do
     subject(:command) { ROM::Commands::Lazy[update_user].new(update_user, evaluator) }
 

data/spec/unit/rom/commands_spec.rb

@@ -30,6 +30,24 @@ describe 'Commands' do
     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
@@ -63,9 +81,9 @@ describe 'Commands' do
   end
 
   describe '#>>' do
-    let(:users) { double('users') }
-    let(:tasks) { double('tasks') }
-    let(:logs) { [] }
+    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' }
@@ -100,11 +118,9 @@ describe 'Commands' do
 
       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])
 
-      result = command.call
-
-      expect(result).to eql(task_tuple)
-      expect(logs).to include(task_tuple)
+      expect(command.call).to eql(task_tuple)
     end
 
     it 'forwards methods to the left' do
@@ -123,5 +139,27 @@ describe 'Commands' do
 
       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
 end

data/spec/unit/rom/configurable_spec.rb

@@ -46,4 +46,4 @@ RSpec.describe ROM::Configurable do
       expect(config.key?(:sql)).to be(true)
     end
   end
-end
+end

data/spec/unit/rom/container_spec.rb

@@ -90,4 +90,10 @@ describe ROM::Container do
       expect(container.mappers.users[:name_list]).to_not be(nil)
     end
   end
+
+  describe '#disconnect' do
+    it 'does not break' do
+      container.disconnect
+    end
+  end
 end

data/spec/unit/rom/create_container_spec.rb

@@ -148,4 +148,4 @@ describe ROM::CreateContainer do
       end
     end
   end
-end
+end

data/spec/unit/rom/environment_spec.rb

@@ -120,4 +120,4 @@ RSpec.describe ROM::Environment do
       expect(gateways_map).to be_empty
     end
   end
-end
+end

data/spec/unit/rom/memory/commands_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'rom/memory'
+
+describe ROM::Memory::Commands do
+  let(:relation) do
+    Class.new(ROM::Relation[:memory]) do
+      schema do
+        attribute :id, ROM::Memory::Types::Int
+        attribute :name, ROM::Memory::Types::String
+      end
+    end.new(ROM::Memory::Dataset.new([]))
+  end
+
+  describe 'Create' do
+    subject(:command) { ROM::Commands::Create[:memory].build(relation) }
+
+    describe '#call' do
+      it 'uses default input handler' do
+        result = command.call([id: 1, name: 'Jane', haha: 'oops'])
+
+        expect(result).to eql([{ id: 1, name: 'Jane' }])
+      end
+    end
+  end
+
+  describe 'Update' do
+    subject(:command) { ROM::Commands::Update[:memory].build(relation) }
+
+    before do
+      relation.insert(id: 1, name: 'Jane')
+    end
+
+    describe '#call' do
+      it 'uses default input handler' do
+        result = command
+          .new(relation.restrict(id: 1))
+          .call(name: 'Jane Doe', haha: 'oops')
+
+        expect(result).to eql([{ id: 1, name: 'Jane Doe' }])
+      end
+    end
+  end
+end