rom 2.0.2 → 4.2.1

data/spec/unit/rom/gateway_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-
-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'
-
-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'
-
-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'
-
-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, reader: true
-      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/relation_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'rom/lint/spec'
-
-require 'rom/memory/dataset'
-require 'rom/memory/relation'
-
-describe ROM::Memory::Relation do
-  subject(:relation) { ROM::Memory::Relation.new(dataset) }
-
-  let(:dataset) 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: 'Jack',                        age: 11 },
-      { name: 'Jill', email: 'jill@doe.org'          },
-      { name: 'John'                                 },
-      { name: 'Judy', email: 'judy@doe.org', age: 11 }
-    ])
-  end
-
-  describe '#take' do
-    it 'takes given number of tuples' do
-      expect(relation.take(2)).to match_array([
-        { name: 'Jane', email: 'jane@doe.org', age: 10 },
-        { name: 'Jade', email: 'jade@doe.org', age: 11 }
-      ])
-    end
-  end
-
-  describe '#project' do
-    it 'projects tuples with the provided keys' do
-      expect(relation.project(:name, :age)).to match_array([
-        { name: 'Jane', age: 10 },
-        { name: 'Jade', age: 11 },
-        { name: 'Joe',  age: 12 },
-        { name: 'Jack', age: 11 },
-        { name: 'Jill'          },
-        { name: 'John'          },
-        { name: 'Judy', age: 11 }
-      ])
-    end
-  end
-
-  describe '#restrict' do
-    it 'restricts data using criteria hash' do
-      expect(relation.restrict(age: 10)).to match_array([
-        { name: 'Jane', email: 'jane@doe.org', age: 10 }
-      ])
-
-      expect(relation.restrict(age: 10.0)).to match_array([])
-    end
-
-    it 'restricts data using block' do
-      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: '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: '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: '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(: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
-end

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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'rom/lint/spec'
-require 'rom/memory'
-
-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/storage_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'rom/memory/storage'
-
-describe ROM::Memory::Storage do
-  describe 'thread safe' do
-    let(:threads) { 4 }
-    let(:operations) { 5000 }
-
-    describe 'data' do
-      it 'create datasets properly' do
-        storage = ROM::Memory::Storage.new
-
-        threaded_operations do |thread, operation|
-          key = "#{thread}:#{operation}"
-          storage.create_dataset(key)
-        end
-
-        expect(storage.size).to eql(threads * operations)
-      end
-    end
-
-    describe 'dataset' do
-      it 'inserts data in proper order' do
-        storage = ROM::Memory::Storage.new
-        dataset = storage.create_dataset(:ary)
-
-        threaded_operations do
-          dataset << :data
-        end
-
-        expect(dataset.size).to eql(threads * operations)
-      end
-    end
-
-    def threaded_operations
-      threads.times.map { |thread|
-        Thread.new do
-          operations.times do |operation|
-            yield thread, operation
-          end
-        end
-      }.each(&:join)
-    end
-  end
-end

data/spec/unit/rom/plugin_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-
-describe "ROM::PluginRegistry" do
-  include_context 'container'
-
-  before do
-    Test::ConfigurationPlugin = Module.new
-    Test::CommandPlugin     = Module.new
-    Test::MapperPlugin      = Module.new
-    Test::RelationPlugin    = Module.new do
-      def plugged_in
-        "a relation"
-      end
-    end
-
-    ROM.plugins do
-      register :registration, Test::ConfigurationPlugin, type: :configuration
-      register :publisher,    Test::CommandPlugin,     type: :command
-      register :pager,        Test::RelationPlugin,    type: :relation
-      register :translater,   Test::MapperPlugin,      type: :mapper
-    end
-
-    configuration
-  end
-
-  around do |example|
-    orig_plugins = ROM.plugin_registry
-    example.run
-    ROM.instance_variable_set('@plugin_registry', orig_plugins)
-  end
-
-  it "makes configuration plugins available" do
-    expect(ROM.plugin_registry.configuration[:registration].mod).to eq Test::ConfigurationPlugin
-  end
-
-  it "includes relation plugins" do
-    users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-      use :pager
-    end
-    configuration.register_relation(users)
-
-    expect(container.relation(:users).plugged_in).to eq "a relation"
-  end
-
-  it "makes command plugins available" do
-    users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-    end
-
-    create_user = Class.new(ROM::Commands::Create[:memory]) do
-      relation :users
-      register_as :create
-      use :publisher
-    end
-
-    configuration.register_relation(users)
-    configuration.register_command(create_user)
-
-    expect(container.command(:users).create).to be_kind_of Test::CommandPlugin
-  end
-
-  it "inclues plugins in mappers" do
-    users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-    end
-    translator = Class.new(ROM::Mapper) do
-      relation :users
-      register_as :translator
-      use :translater
-    end
-
-    configuration.register_relation(users)
-    configuration.register_mapper(translator)
-
-    expect(container.mappers[:users][:translator]).to be_kind_of Test::MapperPlugin
-  end
-
-  it "restricts plugins to defined type" do
-    expect {
-      configuration.relation(:users) do
-        use :publisher
-      end
-    }.to raise_error ROM::UnknownPluginError
-  end
-
-  it "allows definition of adapter restricted plugins" do
-    Test::LazyPlugin = Module.new do
-      def lazy?
-        true
-      end
-    end
-
-    ROM.plugins do
-      adapter :memory do
-        register :lazy, Test::LazyPlugin, type: :relation
-      end
-    end
-
-    users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-      use :lazy
-    end
-    configuration.register_relation(users)
-
-    expect(container.relation(:users)).to be_lazy
-  end
-
-  it "respects adapter restrictions" do
-    Test::LazyPlugin = Module.new
-    Test::LazyMemoryPlugin = Module.new
-    Test::LazySQLPlugin = Module.new
-
-    ROM.plugins do
-      register :lazy, Test::LazyPlugin, type: :command
-
-      adapter :memory do
-        register :lazy_command, Test::LazyMemoryPlugin, type: :command
-      end
-
-      adapter :sql do
-        register :lazy, Test::LazySQLPlugin, type: :command
-      end
-    end
-
-    users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-    end
-
-    create_user = Class.new(ROM::Commands::Create[:memory]) do
-      relation :users
-      register_as :create
-      use :lazy
-    end
-
-    update_user = Class.new(ROM::Commands::Update[:memory]) do
-      relation :users
-      register_as :update
-      use :lazy_command
-    end
-
-    configuration.register_relation(users)
-    configuration.register_command(create_user)
-    configuration.register_command(update_user)
-
-    expect(container.command(:users).create).not_to be_kind_of Test::LazySQLPlugin
-    expect(container.command(:users).create).to be_kind_of Test::LazyPlugin
-    expect(container.command(:users).update).to be_kind_of Test::LazyMemoryPlugin
-  end
-end

data/spec/unit/rom/plugins/command/schema_spec.rb

@@ -1,66 +0,0 @@
-require 'rom/relation'
-require 'rom/command'
-require 'rom/plugins/command/schema'
-
-RSpec.describe ROM::Plugins::Command::Schema do
-  describe '.build' do
-    let(:command_class) do
-      Class.new(ROM::Command) { use :schema }
-    end
-
-    context 'when relation has no schema defined' do
-      let(:relation) do
-        instance_double(ROM::Relation, schema?: false)
-      end
-
-      it 'sets default input handler when command does not have a custom one' do
-        command = Class.new(command_class).build(relation)
-
-        expect(command.input).to be(ROM::Command.input)
-      end
-
-      it 'sets custom input handler when command defines it' do
-        my_handler = double(:my_handler)
-
-        command = Class.new(command_class) { input my_handler }.build(relation)
-
-        expect(command.input).to be(my_handler)
-      end
-
-      it 'sets custom input handler when it is passed as an option' do
-        my_handler = double(:my_handler)
-
-        command = Class.new(command_class).build(relation, input: my_handler)
-
-        expect(command.input).to be(my_handler)
-      end
-    end
-
-    context 'when relation has a schema' do
-      let(:relation) do
-        instance_double(ROM::Relation, schema?: true, schema_hash: schema_hash)
-      end
-
-      let(:schema_hash) do
-        double(:schema_hash)
-      end
-
-      it 'sets schema hash as input handler' do
-        command = Class.new(command_class).build(relation)
-
-        expect(command.input).to be(schema_hash)
-      end
-
-      it 'sets a composed input handler with schema hash and a custom one' do
-        my_handler = double(:my_handler)
-
-        command = Class.new(command_class) { input my_handler }.build(relation)
-
-        expect(my_handler).to receive(:[]).with('some value').and_return('my handler')
-        expect(schema_hash).to receive(:[]).with('my handler').and_return('a tuple')
-
-        expect(command.input['some value']).to eql('a tuple')
-      end
-    end
-  end
-end