rom 2.0.2 → 4.2.1

data/spec/integration/commands/create_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-require 'dry-struct'
-
-describe 'Commands / Create' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  let(:users) { container.commands.users }
-  let(:tasks) { container.commands.tasks }
-
-  before do
-    module Test
-      UserValidator = Class.new do
-        ValidationError = Class.new(ROM::CommandError)
-
-        def self.call(params)
-          unless params[:name] && params[:email]
-            raise ValidationError, ":name and :email are required"
-          end
-        end
-      end
-    end
-
-    configuration.relation(:users)
-    configuration.relation(:tasks)
-
-    class Test::CreateUser < ROM::Commands::Create[:memory]
-      relation :users
-      register_as :create
-      result :one
-      validator Test::UserValidator
-    end
-
-    class Test::CreateTask < ROM::Commands::Create[:memory]
-      relation :tasks
-      register_as :create
-      result :one
-
-      def execute(task, user)
-        super(task.merge(name: user.to_h[:name]))
-      end
-    end
-
-    Test::User = Class.new(Dry::Struct) do
-      attribute :name, Types::String
-      attribute :email, Types::String
-    end
-
-    Test::Task = Class.new(Dry::Struct) do
-      attribute :name, Types::String
-      attribute :title, Types::String
-    end
-
-    class Test::UserMapper < ROM::Mapper
-      relation :users
-      register_as :entity
-      model Test::User
-      attribute :name
-      attribute :email
-    end
-
-    class Test::TaskMapper < ROM::Mapper
-      relation :tasks
-      register_as :entity
-      model Test::Task
-      attribute :name
-      attribute :title
-    end
-
-    configuration.register_command(Test::CreateUser, Test::CreateTask)
-    configuration.register_mapper(Test::UserMapper, Test::TaskMapper)
-  end
-
-  it 'inserts user on successful validation' do
-    result = users.try {
-      users.create.call(name: 'Piotr', email: 'piotr@solnic.eu')
-    }
-
-    expect(result.value).to eql(name: 'Piotr', email: 'piotr@solnic.eu')
-  end
-
-  it 'inserts user and associated task when things go well' do
-    result = users.try {
-      command = users.create.with(name: 'Piotr', email: 'piotr@solnic.eu')
-      command >>= tasks.create.with(title: 'Finish command-api')
-      command
-    }
-
-    expect(result.value).to eql(name: 'Piotr', title: 'Finish command-api')
-  end
-
-  it 'returns validation object with errors on failed validation' do
-    result = users.try { users.create.call(name: 'Piotr') }
-
-    expect(result.error).to be_instance_of(Test::ValidationError)
-    expect(result.error.message).to eql(":name and :email are required")
-    expect(container.relations.users.count).to be(2)
-  end
-
-  describe '"result" option' do
-    it 'returns a single tuple when set to :one' do
-      configuration.commands(:users) do
-        define(:create_one, type: :create) do
-          result :one
-        end
-      end
-
-      tuple = { name: 'Piotr', email: 'piotr@solnic.eu' }
-
-      result = users.try {
-        users.create_one.call(tuple)
-      }
-
-      expect(result.value).to eql(tuple)
-    end
-
-    it 'allows only valid result types' do
-      expect {
-        configuration.commands(:users) do
-          define(:create_one, type: :create) do
-            result :invalid_type
-          end
-        end
-        container
-      }.to raise_error(ROM::Options::InvalidOptionValueError)
-    end
-  end
-
-  describe 'sending result through a mapper' do
-    let(:attributes) do
-      { name: 'Jane', email: 'jane@doe.org' }
-    end
-
-    it 'uses registered mapper to process the result for :one result' do
-      command = container.command(:users).as(:entity).create
-      result = command[attributes]
-
-      expect(result).to eql(Test::User.new(attributes))
-    end
-
-    it 'with two composed commands respects the :result option' do
-      mapper_input = nil
-
-      mapper = proc do |tuples|
-        mapper_input = tuples
-      end
-
-      left = container.command(:users).as(:entity).create.with(
-        name: 'Jane', email: 'jane@doe.org'
-      )
-
-      right = container.command(:tasks).as(:entity).create.with(
-        title: 'Jane task'
-      )
-
-      command = left >> right >> mapper
-
-      result = command.call
-
-      task = Test::Task.new(name: 'Jane', title: 'Jane task')
-
-      expect(mapper_input).to eql([task])
-      expect(result).to eql(task)
-    end
-
-    it 'uses registered mapper to process the result for :many results' do
-      configuration.commands(:users) do
-        define(:create_many, type: :create)
-      end
-
-      command = container.command(:users).as(:entity).create_many
-      result = command[attributes]
-
-      expect(result).to eql([Test::User.new(attributes)])
-    end
-  end
-end

data/spec/integration/commands/delete_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe 'Commands / Delete' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  subject(:users) { container.commands.users }
-
-  before do
-    configuration.relation(:users) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-  end
-
-  it 'deletes all tuples when there is no restriction' do
-    configuration.commands(:users) do
-      define(:delete)
-    end
-
-    result = users.try { users.delete.call }
-
-    expect(result).to match_array([
-      { name: 'Jane', email: 'jane@doe.org' },
-      { name: 'Joe', email: 'joe@doe.org' }
-    ])
-
-    expect(container.relation(:users)).to match_array([])
-  end
-
-  it 'deletes tuples matching restriction' do
-    configuration.commands(:users) do
-      define(:delete)
-    end
-
-    result = users.try { users.delete.by_name('Joe').call }
-
-    expect(result).to match_array([{ name: 'Joe', email: 'joe@doe.org' }])
-
-    expect(container.relation(:users)).to match_array([
-      { name: 'Jane', email: 'jane@doe.org' }
-    ])
-  end
-
-  it 'returns untouched relation if there are no tuples to delete' do
-    configuration.commands(:users) do
-      define(:delete)
-    end
-
-    result = users.try { users.delete.by_name('Not here').call }
-
-    expect(result).to match_array([])
-  end
-
-  it 'returns deleted tuple when result is set to :one' do
-    configuration.commands(:users) do
-      define(:delete_one, type: :delete) do
-        result :one
-      end
-    end
-
-    result = users.try { users.delete_one.by_name('Jane').call }
-
-    expect(result.value).to eql(name: 'Jane', email: 'jane@doe.org')
-  end
-end

data/spec/integration/commands/error_handling_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe 'Commands / Error handling' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration.relation(:users)
-    configuration.commands(:users) { define(:create) }
-  end
-
-  subject(:users) { container.commands.users }
-
-  it 'rescues from ROM::CommandError' do
-    result = false
-    expect(users.try { raise ROM::CommandError } >-> _test { result = true })
-      .to be_instance_of(ROM::Commands::Result::Failure)
-    expect(result).to be(false)
-  end
-
-  it 'raises other errors' do
-    expect { users.try { raise ArgumentError, 'test' } }
-      .to raise_error(ArgumentError, 'test')
-  end
-end

data/spec/integration/commands/graph_builder_spec.rb

@@ -1,213 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Command graph builder' do
-  include_context 'command graph'
-
-  it 'allows defining a simple create command graph' do
-    command = container.command.create(user: :users)
-
-    other = container.command([{ user: :users }, [:create]])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows defining a create command graph with simple nesting' do
-    configuration.commands(:books) do
-      define(:create) { result :many }
-    end
-
-    command = container.command.create(user: :users) do |user|
-      user.create(:books)
-    end
-
-    other = container.command([{ user: :users }, [:create, [
-      [{ books: :books }, [:create]]
-    ]]])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows defining a create command graph with multiple levels of nesting' do
-    configuration.commands(:books) do
-      define(:create) { result :many }
-    end
-
-    configuration.commands(:tags) do
-      define(:create) { result :many }
-    end
-
-    command = container.command.create(user: :users) do |user|
-      user.create(novels: :books) do |novels|
-        novels.create(:tags)
-      end
-    end
-
-    other = container.command([{ user: :users }, [:create, [
-      [{ novels: :books }, [:create, [
-        [{ tags: :tags }, [:create]]
-      ]]]
-    ]]])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows defining a create command graph with multiple nested commands' do
-    configuration.commands(:books) do
-      define(:create) { result :many }
-    end
-
-    configuration.commands(:tags) do
-      define(:create) { result :many }
-    end
-
-    command = container.command.create(user: :users) do |user|
-      user.create(:books)
-      user.create(tag: :tags)
-    end
-
-    other = container.command([{ user: :users }, [:create, [
-      [{ books: :books }, [:create]],
-      [{ tag: :tags }, [:create]]
-    ]]])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows defining a create command graph with multiple nested commands in multiple levels' do
-    configuration.commands(:tasks) do
-      define(:create) { result :many }
-    end
-
-    configuration.commands(:books) do
-      define(:create) { result :many }
-    end
-
-    configuration.commands(:tags) do
-      define(:create) { result :many }
-    end
-
-    command = container.command.create(user: :users) do |user|
-      user.create(:tasks).each do |task|
-        task.create(:tags)
-      end
-      user.create(:books).each do |book|
-        book.create(:tags)
-        book.create(:tasks)
-      end
-    end
-
-    other = container.command([{ user: :users }, [:create, [
-      [{ tasks: :tasks }, [:create, [
-        [{ tags: :tags }, [:create]]
-      ]]],
-      [{ books: :books }, [:create, [
-        [{ tags: :tags }, [:create]],
-        [{ tasks: :tasks }, [:create]]
-      ]]]
-    ]]])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows defining a create command graph using the each sugar' do
-    configuration.commands(:books) do
-      define(:create) { result :many }
-    end
-
-    command = container.command.create(user: :users) do |user|
-      user.create(novels: :books).each do |novel|
-        novel.create(:tags)
-      end
-    end
-
-    other = container.command([{ user: :users }, [:create, [
-      [{ novels: :books }, [:create, [
-        [{ tags: :tags }, [:create]]
-      ]]]
-    ]]])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows restricting a relation with a proc' do
-    configuration.commands(:users) do
-      define(:update) { result :one }
-    end
-
-    configuration.commands(:tasks) do
-      define(:update) { result :many }
-    end
-
-    users_proc = -> users, user do
-      users.by_name(user[:name])
-    end
-
-    tasks_proc = -> tasks, user, task do
-      tasks.by_user_and_title(user[:name], task[:title])
-    end
-
-    users = container.command.restrict(:users, &users_proc)
-    command = container.command.update(user: users) do |user|
-      tasks = user.restrict(:tasks, &tasks_proc)
-      user.update(tasks)
-    end
-
-    other = container.command([
-      { user: :users },
-      [
-        { update: users_proc },
-        [
-          [
-            :tasks,
-            [{ update: tasks_proc }]
-          ]
-        ]
-      ]
-    ])
-
-    expect(command).to eql(other)
-  end
-
-  it 'allows chaining a command to a restriction' do
-    configuration.commands(:users) do
-      define(:update) { result :one }
-    end
-
-    configuration.commands(:tasks) do
-      define(:update) { result :many }
-    end
-
-    users_proc = -> users, user do
-      users.by_name(user[:name])
-    end
-
-    tasks_proc = -> tasks, user, task do
-      tasks.by_user_and_title(user[:name], task[:title])
-    end
-
-    command = container.command.restrict(:users, &users_proc).update(from: :user) do |user|
-      user.restrict(:tasks, &tasks_proc).update
-    end
-
-    other = container.command([
-      { user: :users },
-      [
-        { update: users_proc },
-        [
-          [
-            :tasks,
-            [{ update: tasks_proc }]
-          ]
-        ]
-      ]
-    ])
-
-    expect(command).to eql(other)
-  end
-
-  it 'raises when unknown command is accessed' do
-    expect {
-      container.command.not_here(:users)
-    }.to raise_error(ROM::CommandRegistry::CommandNotFoundError, /not_here/)
-  end
-end