rom 0.9.1 → 1.0.0.beta1

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

@@ -11,4 +11,60 @@ describe ROM::Commands::Result do
       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,21 +1,20 @@
 require 'spec_helper'
 
 describe 'Commands' do
+  include_context 'gateway only'
   include_context 'users and tasks'
 
-  let(:users) { rom.relations.users }
-
-  before do
-    setup.relation(:users) do
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation) do
       def by_id(id)
         restrict(id: id)
       end
-    end
+    end.new(users_dataset)
   end
 
   describe '.build_class' do
     it 'creates a command class constant' do
-      klass = ROM::Command.build_class(:create, :users, adapter: :memory) {
+      klass = ROM::ConfigurationDSL::Command.build_class(:create, :users, adapter: :memory) {
         def super?
           true
         end
@@ -24,7 +23,7 @@ describe 'Commands' do
       expect(klass.name).to eql('ROM::Memory::Commands::Create[Users]')
       expect(klass.register_as).to eql(:create)
 
-      command = klass.build(rom.relations.users)
+      command = klass.build(users_relation)
 
       expect(command).to be_a(ROM::Memory::Commands::Create)
       expect(command).to be_super
@@ -37,7 +36,7 @@ describe 'Commands' do
         relation :users
       end
 
-      command = klass.build(users)
+      command = klass.build(users_relation)
 
       expect(command).to be_kind_of(ROM::Memory::Commands::Create)
     end
@@ -47,7 +46,7 @@ describe 'Commands' do
         relation :users
       end
 
-      command = klass.build(users)
+      command = klass.build(users_relation)
 
       expect(command).to be_kind_of(ROM::Memory::Commands::Update)
     end
@@ -57,63 +56,10 @@ describe 'Commands' do
         relation :users
       end
 
-      command = klass.build(users)
+      command = klass.build(users_relation)
 
       expect(command).to be_kind_of(ROM::Memory::Commands::Delete)
     end
-
-    describe 'extending command with a db-specific behavior' do
-      before do
-        setup.gateways[:default].instance_exec do
-          def extend_command_class(klass, _)
-            klass.class_eval do
-              def super_command?
-                true
-              end
-            end
-            klass
-          end
-        end
-      end
-
-      it 'applies to defined classes' do
-        klass = Class.new(ROM::Commands::Create[:memory]) { relation :users }
-        command = klass.build(users)
-        expect(command).to be_super_command
-      end
-
-      it 'applies to generated classes' do
-        klass = ROM::Command.build_class(:create, :users, adapter: :memory)
-        command = klass.build(users)
-        expect(command).to be_super_command
-      end
-    end
-  end
-
-  describe '.registry' do
-    it 'builds a hash with commands grouped by relations' do
-      commands = {}
-
-      [:Create, :Update, :Delete].each do |command_type|
-        klass = Class.new(ROM::Commands.const_get(command_type)) do
-          relation :users
-        end
-        klass.class_eval "def self.name; 'Test::#{command_type}'; end"
-        commands[command_type] = klass
-      end
-
-      registry = ROM::Command.registry(
-        rom.relations, setup.gateways, commands.values
-      )
-
-      expect(registry).to eql(
-        users: {
-          create: commands[:Create].build(users),
-          update: commands[:Update].build(users),
-          delete: commands[:Delete].build(users)
-        }
-      )
-    end
   end
 
   describe '#>>' do
@@ -178,14 +124,4 @@ describe 'Commands' do
       command.with(user_input).call
     end
   end
-
-  describe 'access to exposed relations' do
-    it 'exposes relation' do
-      command = ROM::Commands::Update[:memory].build(users)
-
-      users.insert(id: 1, name: 'Jane')
-
-      expect(command.by_id(1).relation).to eql(users.by_id(1))
-    end
-  end
 end

data/spec/unit/rom/configurable_spec.rb

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+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

data/spec/unit/rom/container_spec.rb

@@ -1,87 +1,93 @@
 require 'spec_helper'
 
 describe ROM::Container do
+  include_context 'container'
   include_context 'users and tasks'
 
   before do
-    setup.relation(:users) do
+    configuration
+
+    users = Class.new(ROM::Relation[:memory]) do
+      register_as :users
+      dataset :users
       def by_name(name)
         restrict(name: name).project(:name)
       end
     end
 
-    setup.relation(:tasks)
+    tasks = Class.new(ROM::Relation[:memory]) do
+      register_as :tasks
+      dataset :tasks
+    end
 
-    setup.commands(:users) do
-      define(:create)
+    create_user = Class.new(ROM::Commands::Create[:memory]) do
+      relation :users
+      register_as :create
     end
 
-    setup.commands(:tasks) do
-      define(:create)
+    create_task = Class.new(ROM::Commands::Create[:memory]) do
+      relation :tasks
+      register_as :create
     end
 
-    setup.mappers do
-      define(:users) do
-        attribute :name
-        attribute :email
-      end
+    users_mapper = Class.new(ROM::Mapper) do
+      register_as :users
+      relation :users
+      attribute :name
+      attribute :email
+    end
 
-      define(:name_list, parent: :users) do
-        attribute :name
-        exclude :email
-      end
+    name_list = Class.new(users_mapper) do
+      register_as :name_list
+      attribute :name
+      exclude :email
     end
+
+    configuration.register_relation(users, tasks)
+    configuration.register_command(create_user, create_task)
+    configuration.register_mapper(users_mapper, name_list)
   end
 
   describe '#command' do
     it 'returns registered command registry' do
-      expect(rom.command(:users)).to be_instance_of(ROM::CommandRegistry)
+      expect(container.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)
+      expect(container.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)
+      expect(container.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)
+      expect { container.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)
+      result = container.relation(:users) { |r| r.by_name('Jane') }.as(:name_list)
 
       expect(result.call).to match_array([{ name: 'Jane' }])
     end
 
     it 'returns lazy-mapped relation' do
-      by_name = rom.relation(:users).as(:name_list).by_name
+      by_name = container.relation(:users).as(:name_list).by_name
 
       expect(by_name['Jane']).to match_array([{ name: 'Jane' }])
     end
 
     it 'returns relation without mappers when mappers are not defined' do
-      expect(rom.relation(:tasks)).to be_kind_of(ROM::Relation)
-      expect(rom.relation(:tasks).mappers.elements).to be_empty
-    end
-  end
-
-  describe '#read' do
-    it 'returns loaded relation and display a deprecation warning' do
-      expect {
-        result = rom.read(:users) { |r| r.by_name('Jane') }.as(:name_list)
-        expect(result.call).to match_array([{ name: 'Jane' }])
-      }.to output(/^ROM::Container#read is deprecated/).to_stderr
+      expect(container.relation(:tasks)).to be_kind_of(ROM::Relation)
+      expect(container.relation(:tasks).mappers.elements).to be_empty
     end
   end
 
   describe '#mappers' do
     it 'returns mappers for all relations' do
-      expect(rom.mappers.users[:name_list]).to_not be(nil)
+      expect(container.mappers.users[:name_list]).to_not be(nil)
     end
   end
 end

data/spec/unit/rom/create_container_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe ROM::CreateContainer do
+  describe '#finalize' do
+    include_context 'container'
+
+    context 'with gateway that supports schema inferring' do
+      it 'builds relation from inferred schema' do
+        repo = configuration.gateways[:default]
+        dataset = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:users])
+        allow(repo).to receive(:dataset).with(:users).and_return(dataset)
+
+        expect(container.relations.users.dataset).to be(dataset)
+      end
+
+      it 'skips inferring a relation when there is a defined one already' do
+        repo = configuration.gateways[:default]
+        dataset_double = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:users])
+        allow(repo).to receive(:dataset).with(:users).and_return(dataset_double)
+
+        users = Class.new(ROM::Relation[:memory]) do
+          register_as :users
+          dataset :users
+        end
+
+        configuration.register_relation(users)
+
+        expect { container }.not_to raise_error
+
+        expect(container.relations.users).to be_instance_of(users)
+      end
+
+      it 'skips inferring when it is turned off for the adapter' do
+        configuration.config.gateways.default.infer_relations = false
+
+        repo = configuration.default
+
+        expect(repo).not_to receive(:schema)
+
+        container
+      end
+
+      it 'infers configured relations' do
+        configuration.config.gateways.default.inferrable_relations = [:test_tasks]
+
+        repo = configuration.default
+        dataset = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:test_tasks, :test_users])
+
+        expect(repo).to receive(:dataset).with(:test_tasks).and_return(dataset)
+        expect(repo).to_not receive(:dataset).with(:test_users)
+
+        expect(container.relations.elements.key?(:test_users)).to be(false)
+        expect(container.relations[:test_tasks]).to be_kind_of(ROM::Memory::Relation)
+        expect(container.relations[:test_tasks].dataset).to be(dataset)
+      end
+
+      it 'skip inferring blacklisted relations' do
+        configuration.config.gateways.default.not_inferrable_relations = [:test_users]
+
+        repo = configuration.default
+        dataset = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:test_tasks, :test_users])
+
+        expect(repo).to receive(:dataset).with(:test_tasks).and_return(dataset)
+        expect(repo).to_not receive(:dataset).with(:test_users)
+
+        expect(container.relations.elements.key?(:test_users)).to be(false)
+        expect(container.relations[:test_tasks]).to be_kind_of(ROM::Memory::Relation)
+        expect(container.relations[:test_tasks].dataset).to be(dataset)
+      end
+
+      it 'can register multiple relations with same dataset' do
+        configuration
+
+        apples = Class.new(ROM::Relation[:memory]) do
+          dataset :fruits
+          register_as :apples
+
+          def apple?
+            true
+          end
+        end
+
+        oranges = Class.new(ROM::Relation[:memory]) do
+          dataset :fruits
+          register_as :oranges
+
+          def orange?
+            true
+          end
+        end
+
+        configuration.register_relation(apples)
+        configuration.register_relation(oranges)
+
+        expect(container.relations.apples).to be_apple
+        expect(container.relations.oranges).to be_orange
+        expect(container.relations.apples).to_not eq(container.relations.oranges)
+      end
+
+      it "raises an error when registering relations with the same `register_as`" do
+        configuration
+
+        users = Class.new(ROM::Relation[:memory]) do
+          dataset :guests
+          register_as :users
+        end
+
+        users2 = Class.new(ROM::Relation[:memory]) do
+          dataset :admins
+          register_as :users
+        end
+
+        configuration.register_relation(users)
+        configuration.register_relation(users2)
+
+        expect { container }.to raise_error(
+          ROM::RelationAlreadyDefinedError, /register_as :users/
+        )
+      end
+    end
+
+    context 'empty setup' do
+      let(:configuration) { ROM::Configuration.new({}) }
+      let(:container) { ROM.container(configuration) }
+
+      it 'builds empty gateways' do
+        expect(container.gateways).to eql({})
+      end
+
+      it 'builds empty relations' do
+        expect(container.relations).to eql(ROM::RelationRegistry.new)
+      end
+
+      it 'builds empty mappers' do
+        expect(container.mappers).to eql(ROM::Registry.new)
+      end
+
+      it 'builds empty commands' do
+        expect(container.commands).to eql(ROM::Registry.new)
+      end
+    end
+  end
+end