rom 3.3.3 → 4.0.0.beta1

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

@@ -1,121 +0,0 @@
-require 'spec_helper'
-require 'rom/lint/spec'
-
-require 'rom/memory/dataset'
-require 'rom/memory/relation'
-
-RSpec.describe ROM::Memory::Relation do
-  subject(:relation) do
-    Class.new(ROM::Memory::Relation) do
-      schema do
-        attribute :name, ROM::Types::String
-        attribute :email, ROM::Types::String
-        attribute :age, ROM::Types::Int
-      end
-    end.new(dataset)
-  end
-
-  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
-      projected = relation.project(:name, :age)
-
-      expect(projected.schema).to eql(relation.schema.project(:name, :age))
-
-      expect(projected).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/storage_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'rom/memory/storage'
-
-RSpec.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'
-
-RSpec.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, input_schema: input_schema)
-      end
-
-      let(:input_schema) do
-        double(:input_schema)
-      end
-
-      it 'sets schema hash as input handler' do
-        command = Class.new(command_class).build(relation)
-
-        expect(command.input).to be(input_schema)
-      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(input_schema).to receive(:[]).with('my handler').and_return('a tuple')
-
-        expect(command.input['some value']).to eql('a tuple')
-      end
-    end
-  end
-end

data/spec/unit/rom/plugins/relation/instrumentation_spec.rb

@@ -1,44 +0,0 @@
-require 'rom'
-require 'rom/memory'
-
-RSpec.describe ROM::Plugins::Relation::Instrumentation do
-  before do
-    described_class.mixin Module.new
-  end
-
-  subject(:relation) do
-    relation_class.new(dataset, notifications: notifications)
-  end
-
-  let(:dataset) do
-    double(:dataset)
-  end
-
-  let(:relation_class) do
-    Class.new(ROM::Memory::Relation) do
-      schema(:users) do
-        attribute :name, ROM::Types::String
-      end
-
-      use :instrumentation
-
-      instrument def all
-        self
-      end
-    end
-  end
-
-  let(:notifications) { spy(:notifications) }
-
-  it 'uses notifications API when materializing a relation' do
-    relation.to_a
-
-    expect(notifications).to have_received(:instrument).with(:memory, name: :users)
-  end
-
-  it 'instruments custom methods' do
-    relation.all
-
-    expect(notifications).to have_received(:instrument).with(:memory, name: :users)
-  end
-end

data/spec/unit/rom/plugins/relation/key_inference_spec.rb

@@ -1,85 +0,0 @@
-require 'rom'
-require 'rom/memory'
-require 'rom/plugins/relation/key_inference'
-
-RSpec.describe ROM::Plugins::Relation::KeyInference do
-  subject(:relation) do
-    relation_class.new(
-      [],
-      __registry__: ROM::RelationRegistry.new(posts: posts, users: users, tags: tags)
-    )
-  end
-
-  let(:posts) { double(foreign_key: :post_id) }
-  let(:tags_name) { ROM::Relation::Name[:tags] }
-  let(:tags) { double(foreign_key: :tag_id) }
-  let(:users_name) { ROM::Relation::Name[:users] }
-  let(:users) { double(base_name: users_name) }
-
-  describe 'without a schema' do
-    let(:relation_class) do
-      Class.new(ROM::Memory::Relation) do
-        use :key_inference
-
-        dataset :users
-      end
-    end
-
-    describe '#base_name' do
-      it 'returns dataset name by default' do
-        expect(relation.base_name).to eql(ROM::Relation::Name[:users])
-      end
-    end
-
-    describe '#foreign_key' do
-      it 'returns default value' do
-        expect(relation.foreign_key).to be(:user_id)
-      end
-
-      it 'returns default value for another relation' do
-        expect(relation.foreign_key(:posts)).to be(:post_id)
-        expect(relation.foreign_key(posts)).to be(:post_id)
-      end
-
-      it 'returns default value for Relation::Name' do
-        expect(relation.foreign_key(ROM::Relation::Name[:posts])).to be(:post_id)
-      end
-
-      it 'supports objects responding to to_sym' do
-        external_name = double(to_sym: :tags)
-        expect(relation.foreign_key(external_name)).to be(:tag_id)
-      end
-    end
-  end
-
-  describe 'with a schema' do
-    let(:relation_class) do
-      Class.new(ROM::Memory::Relation) do
-        use :key_inference
-
-        schema :posts do
-          attribute :author_id, ROM::Types::Int.meta(foreign_key: true, target: :users)
-        end
-      end
-    end
-
-    describe '#foreign_key' do
-      it 'returns configured value' do
-        expect(relation.foreign_key(ROM::Relation::Name[:users])).to be(:author_id)
-        expect(relation.foreign_key(:users)).to be(:author_id)
-        expect(relation.foreign_key(users)).to be(:author_id)
-        expect(relation.foreign_key(users_name)).to be(:author_id)
-      end
-
-      it 'falls back to default when schema has no fk specified' do
-        expect(relation.foreign_key(:tags)).to be(:tag_id)
-        expect(relation.foreign_key(tags_name)).to be(:tag_id)
-      end
-
-      it 'supports objects responding to to_sym' do
-        external_name = double(to_sym: :tags)
-        expect(relation.foreign_key(external_name)).to be(:tag_id)
-      end
-    end
-  end
-end

data/spec/unit/rom/registry_spec.rb

@@ -1,86 +0,0 @@
-require 'rom/registry'
-
-RSpec.shared_examples_for 'registry fetch' do
-  it 'raises an ArgumentError when nil is used as a key' do
-    expect {
-      registry.public_send(fetch_method, nil)
-    }.to raise_error(ArgumentError, "key cannot be nil")
-  end
-
-  it 'returns registered element identified by name' do
-    expect(registry.public_send(fetch_method, :mars)).to be(mars)
-  end
-
-  it 'raises error when element is not found' do
-    expect { registry.public_send(fetch_method, :twix) }.to raise_error(
-      ROM::Registry::ElementNotFoundError,
-      ":twix doesn't exist in Candy registry"
-    )
-  end
-
-  it 'returns the value from an optional block when key is not found' do
-    value = registry.public_send(fetch_method, :candy) { :twix }
-
-    expect(value).to eq(:twix)
-  end
-
-  it 'calls #to_sym on a key before fetching' do
-    expect(registry.public_send(fetch_method, double(to_sym: :mars))).to be(mars)
-  end
-end
-
-RSpec.describe ROM::Registry do
-  subject(:registry) { registry_class.new(mars: mars) }
-
-  let(:mars) { double('mars') }
-
-  let(:registry_class) do
-    Class.new(ROM::Registry) do
-      def self.name
-        'Candy'
-      end
-    end
-  end
-
-  describe '#fetch' do
-    let(:fetch_method) { :fetch }
-
-    it_behaves_like 'registry fetch'
-  end
-
-  describe '#[]' do
-    let(:fetch_method) { :[] }
-
-    it_behaves_like 'registry fetch'
-  end
-
-  describe '#method_missing' do
-    it 'returns registered element identified by name' do
-      expect(registry.mars).to be(mars)
-    end
-
-    it 'raises no-method error when element is not there' do
-      expect { registry.twix }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe '#key?' do
-    let(:mars) { double(to_sym: :mars) }
-
-    it 'calls #to_sym on a key before checking if it exists' do
-      registry.key?(:mars)
-    end
-
-    it 'returns true for an existing key' do
-      expect(registry.key?(:mars)).to be(true)
-    end
-
-    it 'returns false for a non-existing key' do
-      expect(registry.key?(:twix)).to be(false)
-    end
-
-    it 'returns false for a nil key' do
-      expect(registry.key?(nil)).to be(false)
-    end
-  end
-end

data/spec/unit/rom/relation/attribute_reader_spec.rb

@@ -1,17 +0,0 @@
-require 'rom/memory'
-
-RSpec.describe ROM::Relation, '#[]' do
-  it 'defines a canonical schema for a relation' do
-    class Test::Users < ROM::Relation[:memory]
-      schema do
-        attribute :id, Types::Int
-        attribute :name, Types::String
-      end
-    end
-
-    relation = Test::Users.new([])
-
-    expect(relation[:id]).to be(Test::Users.schema[:id])
-    expect(relation[:name]).to be(Test::Users.schema[:name])
-  end
-end

data/spec/unit/rom/relation/call_spec.rb

@@ -1,51 +0,0 @@
-require 'rom/relation'
-
-RSpec.describe ROM::Relation, '#call' do
-  subject(:relation) do
-    relation_class.new(data)
-  end
-
-  context 'without read types in schema' do
-    let(:relation_class) do
-      Class.new(ROM::Relation[:memory]) do
-        schema do
-          attribute :id, ROM::Types::Int
-          attribute :name, ROM::Types::String
-        end
-      end
-    end
-
-    let(:data) do
-      [{ id: '1', name: 'Jane' }, { id: '2', name: 'John'} ]
-    end
-
-    it 'has noop output_schema' do
-      expect(relation.output_schema).to be(ROM::Relation::NOOP_OUTPUT_SCHEMA)
-    end
-
-    it 'returns loaded relation with data' do
-      expect(relation.call.collection).
-        to eql(data)
-    end
-  end
-
-  context 'with read types in schema' do
-    let(:relation_class) do
-      Class.new(ROM::Relation[:memory]) do
-        schema do
-          attribute :id, ROM::Types::String, read: ROM::Types::Coercible::Int
-          attribute :name, ROM::Types::String
-        end
-      end
-    end
-
-    let(:data) do
-      [{ id: '1', name: 'Jane' }, { id: '2', name: 'John'} ]
-    end
-
-    it 'returns loaded relation with coerced data' do
-      expect(relation.call.collection).
-        to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'John'} ])
-    end
-  end
-end