rom 2.0.2 → 4.2.1

data/spec/integration/commands/graph_spec.rb

@@ -1,288 +0,0 @@
-require 'spec_helper'
-
-describe 'Building up a command graph for nested input' do
-  include_context 'command graph'
-
-  it 'creates a command graph for nested input :one result as root' do
-    configuration.commands(:tasks) do
-      define(:create) do
-        result :one
-
-        def execute(tuple, user)
-          super(tuple.merge(user: user.fetch(:name)))
-        end
-      end
-    end
-
-    input = {
-      user: {
-        name: 'Jane',
-        task: {
-          title: 'Task One',
-          tags: [
-            { name: 'red' }, { name: 'green' }, { name: 'blue' }
-          ]
-        },
-        books: [
-          { title: 'Book One' },
-          { title: 'Book Two' }
-        ]
-      }
-    }
-
-    options = [
-      { user: :users }, [
-        :create, [
-          [{ task: :tasks }, [:create, [:tags, [:create]]]],
-          [:books, [:create]]
-        ]
-      ]
-    ]
-
-    command = container.command(options)
-
-    command.call(input)
-
-    expect(container.relation(:users)).to match_array([
-      { name: 'Jane' }
-    ])
-
-    expect(container.relation(:tasks)).to match_array([
-      { title: 'Task One', user: 'Jane' }
-    ])
-
-    expect(container.relation(:books)).to match_array([
-      { title: 'Book One', user: 'Jane' },
-      { title: 'Book Two', user: 'Jane' }
-    ])
-
-    expect(container.relation(:tags)).to match_array([
-      { name: 'red', task: 'Task One' },
-      { name: 'green', task: 'Task One' },
-      { name: 'blue', task: 'Task One' }
-    ])
-  end
-
-  it 'creates a command graph for nested input with :many results as root' do
-    configuration.commands(:tasks) do
-      define(:create) do
-        def execute(tuples, user)
-          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
-        end
-      end
-    end
-
-    input = {
-      user: {
-        name: 'Jane',
-        tasks: [
-          {
-            title: 'Task One',
-            tags: [{ name: 'red' }, { name: 'green' }]
-          },
-          {
-            title: 'Task Two',
-            tags: [{ name: 'blue' }]
-          }
-        ]
-      }
-    }
-
-    options = [
-      { user: :users }, [
-        :create, [
-          [:tasks, [:create, [:tags, [:create]]]]
-        ]
-      ]
-    ]
-
-    command = container.command(options)
-
-    command.call(input)
-
-    expect(container.relation(:users)).to match_array([
-      { name: 'Jane' }
-    ])
-
-    expect(container.relation(:tasks)).to match_array([
-      { title: 'Task One', user: 'Jane' },
-      { title: 'Task Two', user: 'Jane' }
-    ])
-
-    expect(container.relation(:tags)).to match_array([
-      { name: 'red', task: 'Task One' },
-      { name: 'green', task: 'Task One' },
-      { name: 'blue', task: 'Task Two' }
-    ])
-  end
-
-
-  it 'updates graph elements cleanly' do
-    configuration.commands(:tasks) do
-      define(:create) do
-        def execute(tuples, user)
-          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
-        end
-      end
-
-      define(:update) do
-        result :one
-
-        def execute(tuple, user)
-          super(tuple.merge(user: user.fetch(:name)))
-        end
-      end
-
-      define(:delete) do
-        register_as :complete
-        result :one
-      end
-    end
-
-    configuration.commands(:users) do
-      define(:update) do
-        result :one
-      end
-    end
-
-    initial = {
-      user: {
-        name: 'Johnny',
-        email: 'johnny@doe.org',
-        tasks: [
-          { title: 'Change Name' },
-          { title: 'Finish that novel' }
-        ]
-      }
-    }
-
-    updated = {
-      user: {
-        name: 'Johnny',
-        email: 'johnathan@doe.org',
-        completed: [{ title: 'Change Name' }],
-        tasks: [{ title: 'Finish that novel', priority: 1 }]
-      }
-    }
-
-    create = container.command([{ user: :users }, [:create, [:tasks, [:create]]]])
-
-    update = container.command([
-      { user: :users },
-      [
-        { update: -> cmd, user { cmd.by_name(user[:name]) } },
-        [
-          [
-            { completed: :tasks },
-            [{ complete: -> cmd, user, task { cmd.by_user_and_title(user[:name], task[:title]) } }]
-          ],
-          [
-            :tasks,
-            [{ update: -> cmd, user, task { cmd.by_user_and_title(user[:name], task[:title]) } }]
-          ]
-        ]
-      ]
-    ])
-
-    create.call(initial)
-
-    container.command(:tasks).create.call(
-      [{ title: 'Task One'}], { name: 'Jane' }
-    )
-
-    expect(container.relation(:tasks)).to match_array([
-      { title: 'Change Name', user: 'Johnny' },
-      { title: 'Finish that novel', user: 'Johnny' },
-      { title: 'Task One', user: 'Jane' }
-    ])
-
-    update.call(updated)
-
-    expect(container.relation(:users)).to match_array([
-      { name: 'Johnny', email: 'johnathan@doe.org' }
-    ])
-
-    expect(container.relation(:tasks)).to match_array([
-      { title: 'Task One', user: 'Jane' },
-      { title: 'Finish that novel', priority: 1, user: 'Johnny' }
-    ])
-  end
-
-
-  it 'works with auto-mapping' do
-    configuration.mappers do
-      define(:users) do
-        register_as :entity
-        reject_keys true
-
-        model name: 'Test::User'
-
-        attribute :name
-
-        combine :tasks, on: { name: :user } do
-          model name: 'Test::Task'
-          attribute :title
-
-          combine :tags, on: { title: :task } do
-            model name: 'Test::Tag'
-            attribute :name
-          end
-        end
-      end
-    end
-
-    configuration.commands(:tasks) do
-      define(:create) do
-        def execute(tuples, user)
-          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
-        end
-      end
-    end
-
-    input = {
-      user: {
-        name: 'Jane',
-        tasks: [
-          {
-            title: 'Task One',
-            tags: [{ name: 'red' }, { name: 'green' }]
-          },
-          {
-            title: 'Task Two',
-            tags: [{ name: 'blue' }]
-          }
-        ]
-      }
-    }
-
-    options = [
-      { user: :users }, [
-        :create, [
-          [:tasks, [:create, [:tags, [:create]]]]
-        ]
-      ]
-    ]
-
-    command = container.command(options).as(:entity)
-
-    result = command.call(input)
-
-    expect(result).to be_instance_of(Test::User)
-    expect(result.tasks.first).to be_instance_of(Test::Task)
-    expect(result.tasks.first.tags.first).to be_instance_of(Test::Tag)
-  end
-
-  it 'raises a proper error when the input has invalid structure' do
-    input = { user: { name: 'Jane' } }
-
-    options = [
-      { user: :users }, [:create, [{ book: :books }, [:create]]]
-    ]
-
-    command = container.command(options)
-
-    expect {
-      command.call(input)
-    }.to raise_error(ROM::KeyMissing, /book/)
-  end
-end

data/spec/integration/commands/update_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'dry-struct'
-
-describe 'Commands / Update' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  subject(:users) { container.commands.users }
-
-  before do
-    module Test
-      UserValidator = Class.new do
-        ValidationError = Class.new(ROM::CommandError)
-
-        def self.call(params)
-          raise ValidationError, ":email is required" unless params[:email]
-        end
-      end
-    end
-
-    configuration.relation(:users) do
-      register_as :users
-
-      def all(criteria)
-        restrict(criteria)
-      end
-
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    configuration.commands(:users) do
-      define(:update) do
-        validator Test::UserValidator
-      end
-    end
-  end
-
-  it 'update tuples on successful validation' do
-    result = users.try {
-      users.update.all(name: 'Jane').call(email: 'jane.doe@test.com')
-    }
-
-    expect(result)
-      .to match_array([{ name: 'Jane', email: 'jane.doe@test.com' }])
-  end
-
-  it 'returns validation object with errors on failed validation' do
-    result = users.try { users.update.all(name: 'Jane').call(email: nil) }
-
-    expect(result.error).to be_instance_of(Test::ValidationError)
-    expect(result.error.message).to eql(':email is required')
-
-    expect(container.relations.users.restrict(name: 'Jane')).to match_array([
-      { name: 'Jane', email: 'jane@doe.org' }
-    ])
-  end
-
-  describe '"result" option' do
-    it 'returns a single tuple when set to :one' do
-      configuration.commands(:users) do
-        define(:update_one, type: :update) do
-          result :one
-        end
-      end
-
-      result = users.try {
-        users.update_one.by_name('Jane').call(email: 'jane.doe@test.com')
-      }
-
-      expect(result.value).to eql(name: 'Jane', email: 'jane.doe@test.com')
-    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 'piping results through mappers' do
-    it 'allows scoping to a virtual relation' do
-      user_model = Class.new(Dry::Struct) {
-        attribute :name, Types::String
-        attribute :email, Types::String
-      }
-
-      configuration.mappers do
-        define(:users) do
-          model user_model
-          register_as :entity
-        end
-      end
-
-      command = container.command(:users).as(:entity).update.by_name('Jane')
-
-      attributes = { name: 'Jane Doe', email: 'jane@doe.org' }
-      result = command[attributes]
-
-      expect(result).to eql([user_model.new(attributes)])
-    end
-  end
-end

data/spec/integration/commands_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe 'Commands' 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)
-      define(:create)
-    end
-  end
-
-  let(:create) { container.command(:users)[:create] }
-  let(:update) { container.command(:users)[:update] }
-
-  describe '#method_missing' do
-    it 'forwards known relation view methods' do
-      expect(update.by_id(1).relation).to eql(users_relation.by_id(1))
-    end
-
-    it 'raises no-method error when a non-view relation method was sent' do
-      expect { update.as(:foo) }.to raise_error(NoMethodError, /as/)
-    end
-
-    it 'does not forward relation view methods to non-restrictable commands' do
-      expect { create.by_id(1) }.to raise_error(NoMethodError, /by_id/)
-    end
-  end
-
-  describe 'extending command with a db-specific behavior' do
-    before do
-      gateway.instance_exec do
-        def extend_command_class(klass, _)
-          klass.class_eval do
-            def super_command?
-              true
-            end
-          end
-          klass
-        end
-      end
-    end
-
-    it 'applies to defined classes' do
-      klass = Class.new(ROM::Commands::Create[:memory]) { relation :users }
-      configuration.register_command(klass)
-      container
-      command = klass.build(users_relation)
-      expect(command).to be_super_command
-    end
-
-    it 'applies to generated classes' do
-      klass = ROM::ConfigurationDSL::Command.build_class(:create, :users, adapter: :memory)
-      configuration.register_command(klass)
-      container
-      command = klass.build(users_relation)
-      expect(command).to be_super_command
-    end
-  end
-end

data/spec/integration/mappers/combine_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe 'Mapper definition DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  describe 'combine' do
-    before do
-      configuration.relation(:tasks) do
-        def for_users(users)
-          names = users.map { |user| user[:name] }
-          restrict { |task| names.include?(task[:name]) }
-        end
-
-        def tags(_tasks)
-          [{ name: 'blue', task: 'be cool' }]
-        end
-      end
-
-      configuration.relation(:users) do
-        def addresses(_users)
-          [{ city: 'NYC', user: 'Jane' }, { city: 'Boston', user: 'Joe' }]
-        end
-
-        def books(_users)
-          [{ title: 'Book One', user: 'Jane' }, { title: 'Book Two', user: 'Joe' }]
-        end
-      end
-
-      configuration.mappers do
-        define(:users) do
-          register_as :entity
-
-          model name: 'Test::User'
-
-          attribute :name
-          attribute :email
-
-          combine :tasks, on: { name: :name } do
-            model name: 'Test::Task'
-
-            attribute :title
-
-            wrap :meta do
-              attribute :user, from: :name
-              attribute :priority
-            end
-
-            combine :tags, on: { title: :task } do
-              model name: 'Test::Tag'
-
-              attribute :name
-            end
-          end
-
-          combine :address, on: { name: :user }, type: :hash do
-            model name: 'Test::Address'
-
-            attribute :city
-          end
-
-          combine :book, on: { name: :user }, type: :hash
-        end
-      end
-    end
-
-    let(:users) { container.relation(:users) }
-    let(:tasks) { container.relation(:tasks) }
-
-    let(:joe) {
-      Test::User.new(
-        name: 'Joe',
-        email: 'joe@doe.org',
-        tasks: [
-          Test::Task.new(title: 'be nice', meta: { user: 'Joe', priority: 1 },
-                         tags: []),
-          Test::Task.new(title: 'sleep well', meta: { user: 'Joe', priority: 2 },
-                         tags: [])
-        ],
-        address: Test::Address.new(city: 'Boston'),
-        book: { title: 'Book Two', user: 'Joe' }
-      )
-    }
-
-    let(:jane) {
-      Test::User.new(
-        name: 'Jane',
-        email: 'jane@doe.org',
-        tasks: [
-          Test::Task.new(
-            title: 'be cool',
-            meta: { user: 'Jane', priority: 2 },
-            tags: [Test::Tag.new(name: 'blue')]
-          )
-        ],
-        address: Test::Address.new(city: 'NYC'),
-        book: { title: 'Book One', user: 'Jane' }
-      )
-    }
-
-    it 'works' do
-      container
-
-      Test::User.send(:include, Dry::Equalizer(:name, :email, :tasks, :address, :book))
-      Test::Task.send(:include, Dry::Equalizer(:title, :meta))
-      Test::Address.send(:include, Dry::Equalizer(:city))
-
-      result = users.combine(
-        tasks.for_users.combine(tasks.tags),
-        users.addresses,
-        users.books
-      ).as(:entity)
-
-      expect(result).to match_array([joe, jane])
-    end
-  end
-end

data/spec/integration/mappers/deep_embedded_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Mappers / deeply embedded tuples' do
-  include_context 'container'
-
-  it 'allows mapping embedded tuples' do
-    configuration.relation(:users)
-
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :name, from: 'name'
-
-        embedded :tasks, from: 'tasks' do
-          attribute :title, from: 'title'
-
-          embedded :priority, from: 'priority', type: :hash do
-            attribute :value, from: 'value'
-            attribute :desc, from: 'desc'
-          end
-        end
-      end
-    end
-
-    container.relations.users << {
-      'name' => 'Jane',
-      'tasks' => [
-        { 'title' => 'Task One', 'priority' => { 'value' => 1, 'desc' => 'high' } },
-        { 'title' => 'Task Two', 'priority' => { 'value' => 3, 'desc' => 'low' } }
-      ]
-    }
-
-    jane = container.relation(:users).as(:users).first
-
-    expect(jane.name).to eql('Jane')
-
-    expect(jane.tasks).to eql([
-      { title: 'Task One', priority: { value: 1, desc: 'high' } },
-      { title: 'Task Two', priority: { value: 3, desc: 'low' } }
-    ])
-  end
-end