rom 2.0.2 → 4.2.1

data/spec/unit/rom/commands_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-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) {
-        def execute(task_input, user_tuple)
-          relation.insert(task_input.merge(user_id: user_tuple[:user_id]))
-        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
-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'
-
-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,99 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Container do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before 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
-
-    tasks = Class.new(ROM::Relation[:memory]) do
-      register_as :tasks
-      dataset :tasks
-    end
-
-    create_user = Class.new(ROM::Commands::Create[:memory]) do
-      relation :users
-      register_as :create
-    end
-
-    create_task = Class.new(ROM::Commands::Create[:memory]) do
-      relation :tasks
-      register_as :create
-    end
-
-    users_mapper = Class.new(ROM::Mapper) do
-      register_as :users
-      relation :users
-      attribute :name
-      attribute :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(container.command(:users)).to be_instance_of(ROM::CommandRegistry)
-    end
-
-    it 'returns registered command' do
-      expect(container.command(:users).create).to be_kind_of(ROM::Commands::Create)
-    end
-
-    it 'accepts an array with graph options and input' do
-      expect(container.command([:users, [:create]])).to be_kind_of(ROM::Commands::Lazy)
-    end
-
-    it 'raises ArgumentError when unsupported arg was passed' do
-      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 = 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 = 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(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(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

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

data/spec/unit/rom/environment_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Environment do
-  let(:environment) { ROM::Environment.new(*params) }
-  let(:params) { [] }
-  let(:gateways) { environment.gateways }
-  let(:gateways_map) { environment.gateways_map }
-
-  context 'with an adapter identifier' do
-    let(:params) { [:memory] }
-    
-    it 'configures the gateways hash' do
-      expect(gateways).to be_kind_of(Hash)
-      expect(gateways.keys).to eq([:default])
-      expect(gateways[:default]).to be_kind_of(ROM::Memory::Gateway)
-    end
-    
-    it 'configures the gateways_map hash' do
-      expect(gateways_map).to be_kind_of(Hash)
-      expect(gateways_map.values).to eq([:memory])
-      expect(gateways_map.keys.first).to be_kind_of(ROM::Memory::Gateway)
-      expect(gateways_map.keys.first).to be(gateways[:default])
-    end
-  end
-  
-  context 'with a hash' do
-    let(:params) { [{default: :memory}] }
-
-    it 'configures the gateways hash' do
-      expect(gateways).to be_kind_of(Hash)
-      expect(gateways.keys).to eq([:default])
-      expect(gateways[:default]).to be_kind_of(ROM::Memory::Gateway)
-    end
-    
-    it 'configures the gateways_map hash' do
-      expect(gateways_map).to be_kind_of(Hash)
-      expect(gateways_map.values).to eq([:memory])
-      expect(gateways_map.keys.first).to be_kind_of(ROM::Memory::Gateway)
-      expect(gateways_map.keys.first).to be(gateways[:default])
-    end
-  end
-  
-  context 'with multiple gateways' do
-    let(:params) { [{foo: :memory, default: :memory}] }
-    
-    it 'configures the gateways hash' do
-      expect(gateways).to be_kind_of(Hash)
-      expect(gateways.keys).to eq([:foo, :default])
-      expect(gateways[:default]).to be_kind_of(ROM::Memory::Gateway)
-      expect(gateways[:foo]).to be_kind_of(ROM::Memory::Gateway)
-      expect(gateways[:default]).not_to be(gateways[:foo])
-    end
-    
-    it 'configures the gateways_map hash' do
-      expect(gateways_map).to be_kind_of(Hash)
-      expect(gateways_map.values).to eq([:memory, :memory])
-      expect(gateways_map.keys.map(&:class)).to eq([ROM::Memory::Gateway, ROM::Memory::Gateway])
-      expect(gateways_map.keys).to match_array(gateways.values)
-    end
-  end
-  
-  context 'with settings' do
-    before do
-      module Test
-        class Gateway < ROM::Gateway
-          attr_reader :settings
-
-          def initialize settings = {}
-            @settings = settings
-          end
-        end
-      end
-      
-      ROM.register_adapter(:test, Test)
-    end
-
-    context 'as a hash' do
-      let(:params) { [{foo: [:test, "foo"], bar: [:test, ["bar"]]}] }
-    
-      it 'configures the gateway instance' do
-        expect(gateways.values.map(&:settings)).to match_array(["foo", "bar"])
-      end
-    end
-    
-    context 'as flat args' do
-      let(:params) { [:test, "foo"] }
-    
-      it 'configures the gateway instance' do
-        expect(gateways.values.map(&:settings)).to match_array(["foo"])
-      end
-    end
-  end
-  
-  context 'with a Gateway instance' do
-    before do
-      module Test
-        class Gateway < ROM::Gateway
-          attr_reader :settings
-
-          def initialize settings = {}
-            @settings = settings
-          end
-        end
-      end
-      
-      ROM.register_adapter(:test, Test)
-    end
-    
-    let(:gateway) { Test::Gateway.new }
-    let(:params) { [gateway] }
-    
-    it 'configures the gateways hash' do
-      expect(gateways).to be_kind_of(Hash)
-      expect(gateways.keys).to eq([:default])
-      expect(gateways[:default]).to be(gateway)
-    end
-    
-    it 'configures the gateways_map hash' do
-      expect(gateways_map).to be_kind_of(Hash)
-      expect(gateways_map).to be_empty
-    end
-  end
-end