rom 3.3.3 → 4.0.0.beta1

data/spec/integration/mappers/unwrap_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Mapper definition DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  let(:header) { mapper.header }
-
-  describe 'unwrapping relation mapper' do
-    before do
-      configuration.relation(:tasks) do
-        def with_user
-          tuples = map { |tuple|
-            tuple.merge(user: users.restrict(name: tuple[:name]).first)
-          }
-
-          new(tuples)
-        end
-      end
-
-      configuration.relation(:users)
-
-      configuration.mappers do
-        define(:tasks) do
-          model name: 'Test::Task'
-
-          attribute :title
-          attribute :priority
-        end
-      end
-    end
-
-    it 'unwraps nested attributes via options hash' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          attribute :title
-          attribute :priority
-
-          unwrap user: [:email, :name]
-        end
-      end
-
-      result = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(result).to eql(title: 'be cool',
-                            priority: 2,
-                            name: 'Jane',
-                            email: 'jane@doe.org')
-    end
-
-    it 'unwraps nested attributes via options block' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          attribute :title
-          attribute :priority
-
-          unwrap :user do
-            attribute :name
-            attribute :user_email, from: :email
-          end
-        end
-      end
-
-      result = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(result).to eql(title: 'be cool',
-                            priority: 2,
-                            name: 'Jane',
-                            user_email: 'jane@doe.org')
-    end
-
-    it 'unwraps specified attributes via options block' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          attribute :title
-          attribute :priority
-
-          unwrap :contact, from: :user do
-            attribute :task_user_name, from: :name
-          end
-        end
-      end
-
-      result = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(result).to eql(title: 'be cool',
-                            priority: 2,
-                            name: 'Jane',
-                            task_user_name: 'Jane',
-                            contact: { email: 'jane@doe.org' })
-    end
-  end
-end

data/spec/integration/mappers/wrap_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Mapper definition DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  let(:header) { mapper.header }
-
-  describe 'wrapped relation mapper' do
-    before do
-      configuration.relation(:tasks) do
-        def with_user
-          join(users)
-        end
-      end
-
-      configuration.relation(:users)
-
-      configuration.mappers do
-        define(:tasks) do
-          model name: 'Test::Task'
-
-          attribute :title
-          attribute :priority
-        end
-      end
-    end
-
-    it 'allows defining wrapped attributes via options hash' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap user: [:email]
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: { email: 'jane@doe.org' }
-        )
-      )
-    end
-
-    it 'allows defining wrapped attributes via options block' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap :user do
-            attribute :email
-          end
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: { email: 'jane@doe.org' }
-        )
-      )
-    end
-
-    it 'allows defining nested wrapped attributes via a block' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks, inherit_header: false) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap :user do
-            model name: 'Test::TaskUser'
-            attribute :name
-
-            wrap :contact do
-              model name: 'Test::Contact'
-              attribute :email
-            end
-          end
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-      Test::TaskUser.send(:include, Dry::Equalizer(:name, :contact))
-      Test::Contact.send(:include, Dry::Equalizer(:email))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: Test::TaskUser.new(
-            name: 'Jane', contact: Test::Contact.new(email: 'jane@doe.org')
-          )
-        )
-      )
-    end
-
-    it 'allows defining wrapped attributes mapped to a model' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap :user do
-            model name: 'Test::User'
-            attribute :email
-          end
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-      Test::User.send(:include, Dry::Equalizer(:email))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: Test::User.new(email: 'jane@doe.org')
-        )
-      )
-    end
-  end
-end

data/spec/integration/memory/commands/create_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'rom/memory'
-
-RSpec.describe ROM::Memory::Commands::Create do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration.relation(:users) do
-      def by_id(id)
-        restrict(id: id)
-      end
-    end
-    configuration.commands(:users) do
-      define(:create)
-    end
-  end
-
-  subject(:command) { container.command(:users).create }
-
-  it_behaves_like 'a command'
-end

data/spec/integration/memory/commands/delete_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'rom/memory'
-
-RSpec.describe ROM::Memory::Commands::Delete do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration.relation(:users) do
-      def by_id(id)
-        restrict(id: id)
-      end
-    end
-    configuration.commands(:users) do
-      define(:delete)
-    end
-  end
-
-  subject(:command) { container.command(:users).delete }
-
-  it_behaves_like 'a command'
-end

data/spec/integration/memory/commands/update_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'rom/memory'
-
-RSpec.describe ROM::Memory::Commands::Update do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration.relation(:users) do
-      def by_id(id)
-        restrict(id: id)
-      end
-    end
-    configuration.commands(:users) do
-      define(:update)
-    end
-  end
-
-  subject(:command) { container.command(:users).update }
-
-  it_behaves_like 'a command'
-end

data/spec/integration/multi_env_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Setting up ROM with multiple environments' do
-  let(:configuration) do
-    {
-      one: ROM::Configuration.new(:memory),
-      two: ROM::Configuration.new(:memory)
-    }
-  end
-
-  let(:container) do
-    {
-      one: ROM.container(configuration[:one]),
-      two: ROM.container(configuration[:two]),
-    }
-  end
-
-  context 'without :auto_registration plugin' do
-    before do
-      module Test
-        class Users < ROM::Relation[:memory]
-          dataset :users
-        end
-
-        class CreateUser < ROM::Commands::Create[:memory]
-          register_as :create
-          relation :users
-          result :one
-        end
-
-        class UserMapper < ROM::Mapper
-          relation :users
-          register_as :entity
-        end
-      end
-    end
-
-    it 'registers items independently of other environments' do
-      configuration[:one].register_relation(Test::Users)
-      configuration[:one].register_command(Test::CreateUser)
-      configuration[:one].register_mapper(Test::UserMapper)
-
-      expect(container[:one].relations[:users]).to be_kind_of Test::Users
-      expect(container[:one].commands[:users].create).to be_kind_of Test::CreateUser
-      expect(container[:one].mappers[:users].entity).to be_kind_of Test::UserMapper
-
-      expect { container[:two].relations[:users] }.to raise_error(
-        ROM::Registry::ElementNotFoundError
-      )
-      expect { container[:two].commands[:users].create }.to raise_error(
-        ROM::Registry::ElementNotFoundError
-      )
-      expect { container[:two].commands[:users].create }.to raise_error(
-        ROM::Registry::ElementNotFoundError
-      )
-    end
-
-    it 'allows use of the same identifiers in different environments' do
-      configuration[:one].register_relation(Test::Users)
-      configuration[:one].register_command(Test::CreateUser)
-      configuration[:one].register_mapper(Test::UserMapper)
-
-      expect { configuration[:two].register_relation(Test::Users) }.to_not raise_error
-      expect { configuration[:two].register_command(Test::CreateUser) }.to_not raise_error
-      expect { configuration[:two].register_mapper(Test::UserMapper) }.to_not raise_error
-    end
-  end
-end

data/spec/integration/multi_repo_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Using in-memory gateways for cross-repo access' do
-  let(:configuration) do
-    ROM::Configuration.new(left: :memory, right: :memory, main: :memory)
-  end
-
-  let(:container) { ROM.container(configuration) }
-  let(:gateways) { container.gateways }
-
-  it 'works' do
-    configuration.relation(:users, gateway: :left) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    configuration.relation(:tasks, gateway: :right)
-
-    configuration.relation(:users_and_tasks, gateway: :main) do
-      def by_user(name)
-        join(users.by_name(name), tasks)
-      end
-    end
-
-    configuration.mappers do
-      define(:users_and_tasks) do
-        group tasks: [:title]
-      end
-    end
-
-    gateways[:left][:users] << { user_id: 1, name: 'Joe' }
-    gateways[:left][:users] << { user_id: 2, name: 'Jane' }
-    gateways[:right][:tasks] << { user_id: 1, title: 'Have fun' }
-    gateways[:right][:tasks] << { user_id: 2, title: 'Have fun' }
-
-    user_and_tasks = container.relation(:users_and_tasks)
-      .by_user('Jane')
-      .as(:users_and_tasks)
-
-    expect(user_and_tasks).to match_array([
-      { user_id: 2, name: 'Jane', tasks: [{ title: 'Have fun' }] }
-    ])
-  end
-end

data/spec/integration/relations/default_dataset_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Relation, '.dataset' do
-  include_context 'container'
-
-  it 'injects configured dataset when block was provided' do
-    configuration.relation(:users) do
-      dataset do
-        insert(id: 2, name: 'Joe')
-        insert(id: 1, name: 'Jane')
-
-        restrict(name: 'Jane')
-      end
-    end
-
-    expect(container.relation(:users).to_a).to eql([{ id: 1, name: 'Jane' }])
-  end
-
-  it 'yields relation class for setting custom dataset proc' do
-    configuration.relation(:users) do
-      schema do
-        attribute :id, ROM::Memory::Types::Int.meta(primary_key: true)
-        attribute :name, ROM::Memory::Types::String
-      end
-
-      dataset do |rel_klass|
-        insert(id: 2, name: 'Joe')
-        insert(id: 1, name: 'Jane')
-
-        order(*rel_klass.schema.primary_key.map { |t| t.meta[:name] })
-      end
-    end
-
-    expect(container.relation(:users).to_a).to eql([
-      { id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }
-    ])
-  end
-end

data/spec/integration/relations/inheritance_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Inheritance relation hierarchy' do
-  include_context 'container'
-
-  before do
-    module Test
-      class Users < ROM::Relation[:memory]
-        dataset :users
-
-        def by_email(email)
-          restrict(email: email)
-        end
-      end
-
-      class OtherUsers < Users
-        register_as :other_users
-      end
-    end
-
-    configuration.register_relation(Test::Users, Test::OtherUsers)
-  end
-
-  it 'registers parent and descendant relations' do
-    users = container.relation(:users)
-    other_users = container.relation(:other_users)
-
-    expect(users).to be_instance_of(Test::Users)
-    expect(other_users).to be_instance_of(Test::OtherUsers)
-
-    jane = { name: 'Jane', email: 'jane@doe.org' }
-
-    other_users.insert(jane)
-
-    expect(other_users.by_email('jane@doe.org').one).to eql(jane)
-  end
-end

data/spec/integration/relations/reading_spec.rb

@@ -1,169 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Reading relations' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration.relation(:tasks)
-
-    configuration.relation(:users) do
-      def by_name(name)
-        restrict(name: name)
-      end
-
-      def with_task
-        join(tasks)
-      end
-
-      def with_tasks
-        join(tasks)
-      end
-
-      def sorted
-        order(:name, :email)
-      end
-    end
-  end
-
-
-  it 'exposes a relation reader' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :name
-        attribute :email
-      end
-    end
-
-    users = users_relation.sorted.by_name('Jane').as(:users)
-    user = users.first
-
-    expect(user).to be_an_instance_of(Test::User)
-    expect(user.name).to eql 'Jane'
-    expect(user.email).to eql 'jane@doe.org'
-  end
-
-  it 'maps grouped relations' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :name
-        attribute :email
-      end
-
-      define(:with_tasks, parent: :users) do
-        model name: 'Test::UserWithTasks'
-
-        group tasks: [:title, :priority]
-      end
-    end
-
-    container
-
-    Test::User.send(:include, Dry::Equalizer(:name, :email))
-    Test::UserWithTasks.send(:include, Dry::Equalizer(:name, :email, :tasks))
-
-    user = container.relation(:users).sorted.as(:users).first
-
-    expect(user).to eql(
-      Test::User.new(name: "Jane", email: "jane@doe.org")
-    )
-
-    user = container.relation(:users).with_tasks.sorted.as(:with_tasks).first
-
-    expect(user).to eql(
-      Test::UserWithTasks.new(
-        name: "Jane",
-        email: "jane@doe.org",
-        tasks: [{ title: "be cool", priority: 2 }])
-    )
-  end
-
-  it 'maps wrapped relations' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :name
-        attribute :email
-      end
-
-      define(:with_task, parent: :users) do
-        model name: 'Test::UserWithTask'
-
-        wrap task: [:title, :priority]
-      end
-    end
-
-    container
-
-    Test::User.send(:include, Dry::Equalizer(:name, :email))
-    Test::UserWithTask.send(:include, Dry::Equalizer(:name, :email, :task))
-
-    user = container.relation(:users).sorted.with_task.as(:with_task).first
-
-    expect(user).to eql(
-      Test::UserWithTask.new(name: "Jane", email: "jane@doe.org",
-                             task: { title: "be cool", priority: 2 })
-    )
-  end
-
-  it 'maps hashes' do
-    configuration.mappers do
-      define(:users)
-    end
-
-    user = container.relation(:users).by_name("Jane").as(:users).first
-
-    expect(user).to eql(name: "Jane", email: "jane@doe.org")
-  end
-
-  it 'allows cherry-picking of a mapper' do
-    configuration.mappers do
-      define(:users) do
-        attribute :name
-        attribute :email
-      end
-
-      define(:prefixer, parent: :users) do
-        attribute :user_name, from: :name
-        attribute :user_email, from: :email
-      end
-    end
-
-    user = container.relation(:users).map_with(:prefixer).first
-
-    expect(user).to eql(user_name: 'Joe', user_email: "joe@doe.org")
-  end
-
-  it 'allows passing a block to retrieve relations for mapping' do
-    configuration.mappers do
-      define(:users) do
-        attribute :name
-        attribute :email
-      end
-
-      define(:prefixer, parent: :users) do
-        attribute :user_name, from: :name
-        attribute :user_email, from: :email
-      end
-    end
-
-    expect {
-      container.relation(:users, &:not_here)
-    }.to raise_error(NoMethodError, /not_here/)
-
-    expect {
-      container.relation(:users) { |users| users.by_name('Joe') }.as(:not_here)
-    }.to raise_error(ROM::MapperMissingError, /not_here/)
-
-    user = container.relation(:users) { |users|
-      users.by_name('Joe')
-    }.map_with(:prefixer).call.first
-
-    expect(user).to eql(user_name: 'Joe', user_email: "joe@doe.org")
-  end
-end