rom 3.3.3 → 4.0.0.beta1

data/spec/unit/rom/container_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Container do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration
-
-    users = Class.new(ROM::Relation[:memory]) do
-      schema(:users) do
-        attribute :name, ROM::Types::String
-        attribute :email, ROM::Types::String
-      end
-
-      def by_name(name)
-        restrict(name: name).project(:name)
-      end
-    end
-
-    tasks = Class.new(ROM::Relation[:memory]) do
-      schema(:tasks) do
-        attribute :name, ROM::Types::String
-        attribute :title, ROM::Types::String
-        attribute :priority, ROM::Types::Int
-      end
-    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
-
-    it 'returns a relation with finalized schema' do
-      expect(container.relation(:tasks).schema.relations[:users]).to be(container.relations[:users])
-    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'
-
-RSpec.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/enumerable_dataset_spec.rb

@@ -1,15 +0,0 @@
-require 'rom/enumerable_dataset'
-
-RSpec.describe ROM::EnumerableDataset do
-  let(:klass) do
-    Class.new do
-      include ROM::EnumerableDataset
-
-      def self.row_proc
-        -> i { i.each_with_object({}) { |(k,v),h| h[k.to_sym] = v } }
-      end
-    end
-  end
-
-  it_behaves_like 'an enumerable dataset'
-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

data/spec/unit/rom/gateway_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Gateway do
-
-  subject(:gateway) { Class.new(ROM::Gateway).new }
-
-  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
-      expect(gateway.disconnect).to be(nil)
-    end
-  end
-
-  describe '#logger' do
-    it 'does nothing' do
-      expect(gateway.logger).to be(nil)
-    end
-  end
-
-  describe '#use_logger' do
-    it 'does nothing' do
-      expect(gateway.use_logger).to be(nil)
-    end
-
-    it 'accepts parameters' do
-      params = [5, "mutations", "are", "nice"]
-
-      expect { gateway.use_logger(params) }.to_not raise_error
-    end
-  end
-
-  describe '#extend_command_class' do
-    it 'returns the class sent as 1st parameter' do
-      klass = Class.new.freeze
-
-      expect(gateway.extend_command_class(klass, "foo")).to eq(klass)
-    end
-  end
-
-  describe '.adapter' do
-    let(:gateway_class) { Class.new(ROM::Gateway) }
-
-    it 'gets/sets the adapter' do
-      expect { gateway_class.adapter :custom }
-        .to change { gateway_class.adapter }
-        .from(nil)
-        .to(:custom)
-    end
-  end
-
-  describe "#adapter" do
-    before { Test::CustomGateway = Class.new(ROM::Gateway) }
-
-    let(:gateway) { Test::CustomGateway.new }
-
-    it 'returns class adapter' do
-      Test::CustomGateway.adapter :custom
-      expect(gateway.adapter).to eql :custom
-    end
-
-    it 'requires the adapter to be defined' do
-      expect { gateway.adapter }.to raise_error(
-        ROM::MissingAdapterIdentifierError, /Test::CustomGateway/
-      )
-    end
-  end # describe #adapter
-
-end

data/spec/unit/rom/mapper_registry_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::MapperRegistry do
-  subject(:registry) { ROM::MapperRegistry.new }
-
-  let(:user_mapper) { double('user_mapper') }
-  let(:index_mapper) { double('index_mapper') }
-
-  before do
-    registry[:users] = user_mapper
-    registry[:index] = index_mapper
-  end
-
-  describe '#by_path' do
-    it 'returns first matching mapper' do
-      mapper = registry.by_path('users')
-
-      expect(mapper).to be(user_mapper)
-
-      mapper = registry.by_path('users.index')
-
-      expect(mapper).to be(index_mapper)
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.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

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-require 'rom/lint/spec'
-
-require 'rom/memory/dataset'
-
-RSpec.describe ROM::Memory::Dataset do
-  subject(:dataset) { ROM::Memory::Dataset.new(data) }
-
-  let(:data) do
-    [
-      { name: 'Jane', email: 'jane@doe.org', age: 10 },
-      { name: 'Jade', email: 'jade@doe.org', age: 11 },
-      { name: 'Joe', email: 'joe@doe.org', age: 12 }
-    ]
-  end
-
-  it_behaves_like "a rom enumerable dataset"
-
-  describe 'subclassing' do
-    it 'supports options' do
-      descendant = Class.new(ROM::Memory::Dataset) do
-        option :path
-      end
-
-      dataset = descendant.new([1, 2, 3], path: '/data')
-
-      expect(dataset.to_a).to eql([1, 2, 3])
-      expect(dataset.path).to eql('/data')
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'rom/lint/spec'
-require 'rom/memory'
-
-RSpec.describe ROM::Memory::Gateway do
-  let(:gateway) { ROM::Memory::Gateway }
-  let(:uri) { nil }
-
-  it_behaves_like "a rom gateway" do
-    let(:identifier) { :memory }
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'rom/memory'
-
-RSpec.describe ROM::Memory::Relation, '.inherited' do
-  subject(:relation) do
-    Class.new(ROM::Relation[:test]) do
-      schema(:users) do
-        attribute :name, ROM::Types::String
-      end
-    end.new([])
-  end
-
-  before do
-    module Test
-      module AnotherAdapter
-        class Relation < ROM::Memory::Relation
-          adapter :test
-        end
-      end
-    end
-
-    ROM.register_adapter(:test, Test::AnotherAdapter)
-  end
-
-  after do
-    ROM.adapters.delete(:test)
-  end
-
-  it 'extends subclass with core methods' do
-    expect(relation.name.to_sym).to be(:users)
-    expect(relation.schema.map(&:name)).to eql(%i[name])
-  end
-end