rom 0.7.1 → 0.8.0

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ROM::Commands::Lazy do
+  let(:rom) { setup.finalize }
+  let(:setup) { ROM.setup(:memory) }
+
+  let(:create_user) { rom.command(:users).create }
+  let(:update_user) { rom.command(:users).update }
+  let(:create_task) { rom.command(:tasks).create }
+
+  let(:user) { { user: { name: 'Jane' } } }
+  let(:evaluator) { -> input { input[:user] } }
+
+  before do
+    setup.relation(:tasks)
+
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name)
+      end
+    end
+
+    setup.commands(:users) do
+      define(:create) do
+        result :one
+      end
+
+      define(:update)
+    end
+
+    setup.commands(:tasks) do
+      define(:create)
+    end
+  end
+
+  describe '#call' do
+    subject(:command) { ROM::Commands::Lazy.new(create_user, evaluator) }
+
+    it 'evaluates the input and calls command' do
+      command.call(user)
+
+      expect(rom.relation(:users)).to match_array([
+        { name: 'Jane' }
+      ])
+    end
+  end
+
+  describe '#>>' do
+    subject(:command) { ROM::Commands::Lazy.new(create_user, evaluator) }
+
+    it 'composes with another command' do
+      expect(command >> create_task).to be_instance_of(ROM::Commands::Composite)
+    end
+  end
+
+  describe '#combine' do
+    subject(:command) { ROM::Commands::Lazy.new(create_user, evaluator) }
+
+    it 'combines with another command' do
+      expect(command.combine(create_task)).to be_instance_of(ROM::Commands::Graph)
+    end
+  end
+
+  describe '#method_missing' do
+    subject(:command) { ROM::Commands::Lazy.new(update_user, evaluator) }
+
+    it 'forwards to command' do
+      rom.relations[:users] << { name: 'Jane' } << { name: 'Joe' }
+
+      new_command = command.by_name('Jane')
+      new_command.call(user: { name: 'Jane Doe' })
+
+      expect(rom.relation(:users)).to match_array([
+        { name: 'Jane Doe' },
+        { name: 'Joe' }
+      ])
+    end
+
+    it 'return original response if it was not a command' do
+      response = command.result
+      expect(response).to be(:many)
+    end
+
+    it 'raises error when message is unknown' do
+      expect { command.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+end

data/spec/unit/rom/commands_spec.rb

@@ -64,7 +64,7 @@ describe 'Commands' do
 
     describe 'extending command with a db-specific behavior' do
       before do
-        setup.repositories[:default].instance_exec do
+        setup.gateways[:default].instance_exec do
           def extend_command_class(klass, _)
             klass.class_eval do
               def super_command?
@@ -103,7 +103,7 @@ describe 'Commands' do
       end
 
       registry = ROM::Command.registry(
-        rom.relations, setup.repositories, commands.values
+        rom.relations, setup.gateways, commands.values
       )
 
       expect(registry).to eql(

data/spec/unit/rom/env_spec.rb

@@ -12,6 +12,14 @@ describe ROM::Env do
 
     setup.relation(:tasks)
 
+    setup.commands(:users) do
+      define(:create)
+    end
+
+    setup.commands(:tasks) do
+      define(:create)
+    end
+
     setup.mappers do
       define(:users) do
         attribute :name
@@ -25,6 +33,24 @@ describe ROM::Env do
     end
   end
 
+  describe '#command' do
+    it 'returns registered command registry' do
+      expect(rom.command(:users)).to be_instance_of(ROM::CommandRegistry)
+    end
+
+    it 'returns registered command' do
+      expect(rom.command(:users).create).to be_kind_of(ROM::Commands::Create)
+    end
+
+    it 'accepts an array with graph options and input' do
+      expect(rom.command([:users, [:create]])).to be_kind_of(ROM::Commands::Lazy)
+    end
+
+    it 'raises ArgumentError when unsupported arg was passed' do
+      expect { rom.command({ oops: 'sorry' }) }.to raise_error(ArgumentError)
+    end
+  end
+
   describe '#relation' do
     it 'yields selected relation to the block and returns a loaded relation' do
       result = rom.relation(:users) { |r| r.by_name('Jane') }.as(:name_list)

data/spec/unit/rom/gateway_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe ROM::Gateway do
+  describe '.setup' do
+    it 'sets up a gateway based on a type' do
+      gateway_class = Class.new(ROM::Gateway) do
+        attr_reader :args
+
+        def initialize(*args)
+          @args = args
+        end
+      end
+
+      allow(ROM::Gateway).to receive(:class_from_symbol)
+        .with(:wormhole).and_return(gateway_class)
+
+      args = %w(hello world)
+      gateway = ROM::Gateway.setup(:wormhole, *args)
+
+      expect(gateway).to be_instance_of(gateway_class)
+      expect(gateway.args).to eq(args)
+    end
+
+    it 'raises an exception if the type is not supported' do
+      expect {
+        ROM::Gateway.setup(:bogus, "memory://test")
+      }.to raise_error(ROM::AdapterLoadError, /bogus/)
+    end
+
+    it 'accepts a gateway instance' do
+      gateway = ROM::Gateway.new
+      expect(ROM::Gateway.setup(gateway)).to be(gateway)
+    end
+
+    it 'raises an exception if instance and arguments are passed' do
+      gateway = ROM::Gateway.new
+
+      expect { ROM::Gateway.setup(gateway, 'foo://bar') }.to raise_error(
+        ArgumentError,
+        "Can't accept arguments when passing an instance"
+      )
+    end
+
+    it 'raises an exception if a URI string is passed' do
+      expect { ROM::Gateway.setup('memory://test') }.to raise_error(
+        ArgumentError,
+        /URIs without an explicit scheme are not supported anymore/
+      )
+    end
+  end
+
+  describe '.class_from_symbol' do
+    context 'when adapter is already present' do
+      before do
+        module Test
+          module Adapter
+            class Gateway
+            end
+          end
+        end
+
+        ROM.register_adapter(:test_adapter, Test::Adapter)
+      end
+
+      it 'does not try to require an adapter if it is already present' do
+        klass = ROM::Gateway.class_from_symbol(:test_adapter)
+
+        expect(klass).to be(Test::Adapter::Gateway)
+      end
+    end
+
+    it 'instantiates a gateway based on type' do
+      klass = ROM::Gateway.class_from_symbol(:memory)
+      expect(klass).to be(ROM::Memory::Gateway)
+    end
+
+    it 'raises an exception if the type is not supported' do
+      expect { ROM::Gateway.class_from_symbol(:bogus) }
+        .to raise_error(ROM::AdapterLoadError, /bogus/)
+    end
+  end
+
+  describe '#disconnect' do
+    it 'does nothing' do
+      gateway_class = Class.new(ROM::Gateway)
+      gateway = gateway_class.new
+      expect(gateway.disconnect).to be(nil)
+    end
+  end
+end

data/spec/unit/rom/global_spec.rb

@@ -2,13 +2,14 @@ require 'spec_helper'
 
 describe ROM do
   describe '.setup' do
-    it 'allows passing in repository instances' do
-      klass = Class.new(ROM::Repository)
+    it 'allows passing in gateway instances' do
+      klass = Class.new(ROM::Gateway)
       repo = klass.new
 
       setup = ROM.setup(test: repo)
 
-      expect(setup.repositories[:test]).to be(repo)
+      expect(setup.gateways[:test]).to be(repo)
     end
   end
+
 end

data/spec/unit/rom/mapper/dsl_spec.rb

@@ -232,6 +232,19 @@ describe ROM::Mapper do
 
       expect(header).to eql(expected_header)
     end
+
+    it 'raises an exception when using a block and options to define attributes' do
+      expect {
+        mapper.wrap(city: [:name]) { attribute :other_name }
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
+
+    it 'raises an exception when using options and a mapper to define attributes' do
+      task_mapper = Class.new(ROM::Mapper) { attribute :title }
+      expect {
+        mapper.wrap city: [:name], mapper: task_mapper
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
   end
 
   describe '#group' do
@@ -250,6 +263,19 @@ describe ROM::Mapper do
 
       expect(header).to eql(expected_header)
     end
+
+    it 'raises an exception when using a block and options to define attributes' do
+      expect {
+        mapper.group(cities: [:name]) { attribute :other_name }
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
+
+    it 'raises an exception when using options and a mapper to define attributes' do
+      task_mapper = Class.new(ROM::Mapper) { attribute :title }
+      expect {
+        mapper.group cities: [:name], mapper: task_mapper
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
   end
 
   describe 'top-level :prefix option' do
@@ -386,7 +412,7 @@ describe ROM::Mapper do
       let(:attributes) do
         [
           [:name],
-          [:task, type: :array, header: task_mapper.header]
+          [:task, type: :hash, header: task_mapper.header]
         ]
       end
 
@@ -416,6 +442,21 @@ describe ROM::Mapper do
 
       expect(header).to eql(expected_header)
     end
+
+    it 'works without a block' do
+      expected_header = ROM::Header.coerce(
+        [
+          [:title],
+          [:tasks, combine: true, type: :array, header: []]
+        ]
+      )
+
+      mapper.attribute :title
+
+      mapper.combine :tasks, on: { title: :title }
+
+      expect(header).to eql(expected_header)
+    end
   end
 
   describe '#method_missing' do

data/spec/unit/rom/mapper_spec.rb

@@ -30,7 +30,10 @@ describe ROM::Mapper do
   describe '.registry' do
     it 'builds mapper class registry for base and virtual relations' do
       users = Class.new(ROM::Mapper) { relation(:users) }
-      entity = Class.new(ROM::Mapper) { relation(:users); register_as(:entity) }
+      entity = Class.new(ROM::Mapper) do
+        relation(:users)
+        register_as(:entity)
+      end
       active = Class.new(users) { relation(:active) }
       admins = Class.new(users) { relation(:admins) }
       custom = Class.new(users) { register_as(:custom) }

data/spec/unit/rom/memory/commands/create_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require 'rom/memory'
+
+describe ROM::Memory::Commands::Delete do
+  include_context 'users and tasks'
+
+  subject(:command) { ROM::Memory::Commands::Delete.build(users) }
+
+  let(:users) { rom.relations[:users] }
+
+  before do
+    setup.relation(:users) do
+      def by_id(id)
+        restrict(id: id)
+      end
+    end
+  end
+
+  it_behaves_like 'a command'
+end

data/spec/unit/rom/memory/commands/delete_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require 'rom/memory'
+
+describe ROM::Memory::Commands::Create do
+  include_context 'users and tasks'
+
+  subject(:command) { ROM::Memory::Commands::Create.build(users) }
+
+  let(:users) { rom.relations[:users] }
+
+  before do
+    setup.relation(:users) do
+      def by_id(id)
+        restrict(id: id)
+      end
+    end
+  end
+
+  it_behaves_like 'a command'
+end

data/spec/unit/rom/memory/commands/update_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require 'rom/memory'
+
+describe ROM::Memory::Commands::Update do
+  include_context 'users and tasks'
+
+  subject(:command) { ROM::Memory::Commands::Update.build(users) }
+
+  let(:users) { rom.relations[:users] }
+
+  before do
+    setup.relation(:users) do
+      def by_id(id)
+        restrict(id: id)
+      end
+    end
+  end
+
+  it_behaves_like 'a command'
+end

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

@@ -11,7 +11,11 @@ describe ROM::Memory::Relation do
     ROM::Memory::Dataset.new([
       { name: 'Jane', email: 'jane@doe.org', age: 10 },
       { name: 'Jade', email: 'jade@doe.org', age: 11 },
-      { name: 'Joe', email: 'joe@doe.org', age: 12 }
+      { name: 'Joe',  email: 'joe@doe.org',  age: 12 },
+      { name: 'Jack',                        age: 11 },
+      { name: 'Jill', email: 'jill@doe.org'          },
+      { name: 'John'                                 },
+      { name: 'Judy', email: 'judy@doe.org', age: 11 }
     ])
   end
 
@@ -29,7 +33,11 @@ describe ROM::Memory::Relation do
       expect(relation.project(:name, :age)).to match_array([
         { name: 'Jane', age: 10 },
         { name: 'Jade', age: 11 },
-        { name: 'Joe', age: 12 }
+        { name: 'Joe',  age: 12 },
+        { name: 'Jack', age: 11 },
+        { name: 'Jill'          },
+        { name: 'John'          },
+        { name: 'Judy', age: 11 }
       ])
     end
   end
@@ -44,33 +52,57 @@ describe ROM::Memory::Relation do
     end
 
     it 'restricts data using block' do
-      expect(relation.restrict { |tuple| tuple[:age] > 10 }).to match_array([
+      expect(relation.restrict { |tuple| tuple[:age].to_i > 10 }).to match_array([
         { name: 'Jade', email: 'jade@doe.org', age: 11 },
-        { name: 'Joe', email: 'joe@doe.org', age: 12 }
+        { name: 'Joe',  email: 'joe@doe.org',  age: 12 },
+        { name: 'Jack',                        age: 11 },
+        { name: 'Judy', email: 'judy@doe.org', age: 11 }
       ])
     end
 
     it 'allows to use array as a value' do
       expect(relation.restrict(age: [10, 11])).to match_array([
         { name: 'Jane', email: 'jane@doe.org', age: 10 },
-        { name: 'Jade', email: 'jade@doe.org', age: 11 }
+        { name: 'Jade', email: 'jade@doe.org', age: 11 },
+        { name: 'Jack',                        age: 11 },
+        { name: 'Judy', email: 'judy@doe.org', age: 11 }
       ])
     end
 
     it 'allows to use regexp as a value' do
       expect(relation.restrict(name: /\w{4}/)).to match_array([
         { name: 'Jane', email: 'jane@doe.org', age: 10 },
-        { name: 'Jade', email: 'jade@doe.org', age: 11 }
+        { name: 'Jade', email: 'jade@doe.org', age: 11 },
+        { name: 'Jack',                        age: 11 },
+        { name: 'Jill', email: 'jill@doe.org'          },
+        { name: 'John'                                 },
+        { name: 'Judy', email: 'judy@doe.org', age: 11 }
       ])
     end
   end
 
   describe '#order' do
     it 'sorts data using provided attribute names' do
-      expect(relation.order(:name).to_a).to eq([
-        { name: 'Jade', email: 'jade@doe.org', age: 11 },
-        { name: 'Jane', email: 'jane@doe.org', age: 10 },
-        { name: 'Joe', email: 'joe@doe.org', age: 12 }
+      expect(relation.order(:age, :email).to_a).to eq([
+        { name: 'Jane', age: 10, email: 'jane@doe.org' },
+        { name: 'Jade', age: 11, email: 'jade@doe.org' },
+        { name: 'Judy', age: 11, email: 'judy@doe.org' },
+        { name: 'Jack', age: 11                        },
+        { name: 'Joe',  age: 12, email: 'joe@doe.org'  },
+        { name: 'Jill',          email: 'jill@doe.org' },
+        { name: 'John'                                 }
+      ])
+    end
+
+    it 'places nil before other values when required' do
+      expect(relation.order(:age, :email, nils_first: true).to_a).to eq([
+        { name: 'John'                                 },
+        { name: 'Jill',          email: 'jill@doe.org' },
+        { name: 'Jane', age: 10, email: 'jane@doe.org' },
+        { name: 'Jack', age: 11                        },
+        { name: 'Jade', age: 11, email: 'jade@doe.org' },
+        { name: 'Judy', age: 11, email: 'judy@doe.org' },
+        { name: 'Joe',  age: 12, email: 'joe@doe.org'  }
       ])
     end
   end