rom 2.0.2 → 4.2.1

data/spec/unit/rom/commands/graph_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-require 'dry-struct'
-
-describe ROM::Commands::Graph do
-  shared_examples_for 'a persisted graph' do
-    it 'returns nested results' do
-      expect(command.call).to match_array([
-        # parent users
-        [
-          { name: 'Jane' }
-        ],
-        [
-          [
-            # user tasks
-            [
-              { title: 'One', user: 'Jane' }
-            ],
-            [
-              # task tags
-              [
-                { name: 'red', task: 'One' },
-                { name: 'green', task: 'One' },
-                { name: 'blue', task: 'One' }
-              ]
-            ]
-          ]
-        ]
-      ])
-    end
-
-    context 'persisted relations' do
-      before { command.call }
-
-      it 'inserts root' do
-        expect(container.relation(:users)).to match_array([{ name: 'Jane' }])
-      end
-
-      it 'inserts root nodes' do
-        expect(container.relation(:tasks)).to match_array([{ user: 'Jane', title: 'One' }])
-      end
-
-      it 'inserts nested graph nodes' do
-        expect(container.relation(:tags)).to match_array([
-          { name: 'red', task: 'One' },
-          { name: 'green', task: 'One' },
-          { name: 'blue', task: 'One' }
-        ])
-      end
-    end
-  end
-
-  include_context 'container'
-
-  let(:create_user) { container.command(:users).create }
-  let(:create_task) { container.command(:tasks).create }
-
-  let(:create_many_tasks) { container.command(:tasks).create_many }
-  let(:create_many_tags) { container.command(:tags).create_many }
-
-  let(:user) { { name: 'Jane' } }
-  let(:task) { { title: 'One' } }
-  let(:tags) { [{ name: 'red' }, { name: 'green' }, { name: 'blue' }] }
-
-  before do
-    configuration.relation(:users)
-    configuration.relation(:tasks)
-    configuration.relation(:tags)
-
-    configuration.commands(:users) do
-      define(:create) do
-        result :one
-      end
-    end
-
-    configuration.commands(:tasks) do
-      define(:create) do
-        result :one
-
-        def execute(task, user)
-          super(task.merge(user: user[:name]))
-        end
-      end
-
-      define(:create) do
-        register_as :create_many
-
-        def execute(tasks, user)
-          super(tasks.map { |t| t.merge(user: user[:name]) })
-        end
-      end
-    end
-
-    configuration.commands(:tags) do
-      define(:create) do
-        register_as :create_many
-
-        def execute(tags, tasks)
-          super(
-            Array([tasks]).flatten.map { |task|
-              tags.map { |tag| tag.merge(task: task[:title]) }
-            }.flatten
-          )
-        end
-      end
-    end
-  end
-
-  describe '#call' do
-    context 'when result is :one in root and its direct children' do
-      it_behaves_like 'a persisted graph' do
-        subject(:command) do
-          create_user.with(user)
-            .combine(create_task.with(task)
-            .combine(create_many_tags.with(tags)))
-        end
-      end
-    end
-
-    context 'when result is :many for root direct children' do
-      it_behaves_like 'a persisted graph' do
-        subject(:command) do
-          create_user.with(user)
-            .combine(create_many_tasks.with([task])
-            .combine(create_many_tags.with(tags)))
-        end
-      end
-    end
-  end
-
-  describe 'pipeline' do
-    subject(:command) do
-      container.command(:users).as(:entity).create.with(user)
-        .combine(create_task.with(task)
-        .combine(create_many_tags.with(tags)))
-    end
-
-    before do
-      Test::Tag = Class.new(Dry::Struct) {
-        attribute :name, Types::String
-      }
-
-      Test::Task = Class.new(Dry::Struct) {
-        attribute :title, Types::String
-        attribute :tags, Types::Array.member(Test::Tag)
-      }
-
-      Test::User = Class.new(Dry::Struct) {
-        attribute :name, Types::String
-        attribute :task, Test::Task
-      }
-
-      class Test::UserMapper < ROM::Mapper
-        relation :users
-        register_as :entity
-        reject_keys :true
-
-        model Test::User
-
-        attribute :name
-
-        combine :task, on: { name: :user }, type: :hash do
-          model Test::Task
-
-          attribute :title
-
-          combine :tags, on: { title: :task } do
-            model Test::Tag
-            attribute :name
-          end
-        end
-      end
-      configuration.register_mapper(Test::UserMapper)
-    end
-
-    it 'sends data through the pipeline' do
-      expect(command.call).to eql(
-        Test::User.new(
-          name: 'Jane',
-          task: Test::Task.new(
-            title: 'One',
-            tags: [
-              Test::Tag.new(name: 'red'),
-              Test::Tag.new(name: 'green'),
-              Test::Tag.new(name: 'blue')
-            ]
-          )
-        )
-      )
-    end
-  end
-end

data/spec/unit/rom/commands/lazy_spec.rb

@@ -1,307 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Commands::Lazy do
-  include_context 'container'
-
-  let(:create_user) { container.command(:users).create }
-  let(:update_user) { container.command(:users).update }
-  let(:delete_user) { container.command(:users).delete }
-
-  let(:create_task) { container.command(:tasks).create }
-  let(:create_tasks) { container.command(:tasks).create_many }
-  let(:update_task) { container.command(:tasks).update }
-
-  let(:input) { { user: { name: 'Jane', email: 'jane@doe.org' } } }
-  let(:jane) { input[:user] }
-  let(:evaluator) { -> input { input[:user] } }
-
-  before do
-    configuration.relation(:tasks) do
-      def by_user_and_title(user, title)
-        by_user(user).by_title(title)
-      end
-
-      def by_user(user)
-        restrict(user: user)
-      end
-
-      def by_title(title)
-        restrict(title: title)
-      end
-    end
-
-    configuration.relation(:users) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    configuration.commands(:users) do
-      define(:create) do
-        result :one
-      end
-
-      define(:update) do
-        result :one
-      end
-
-      define(:delete) do
-        result :one
-      end
-    end
-
-    configuration.commands(:tasks) do
-      define(:create) do
-        result :one
-      end
-
-      define(:create_many, type: :create) do
-        def execute(tuples, user)
-          super(tuples.map { |tuple| tuple.merge(user: user[:name]) })
-        end
-      end
-
-      define(:update) do
-        result :one
-
-        def execute(tuple, user)
-          super(tuple.merge(user: user[:name]))
-        end
-      end
-    end
-  end
-
-  describe '#call' do
-    context 'with a create command' do
-      subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
-
-      it 'evaluates the input and calls command' do
-        command.call(input)
-
-        expect(container.relation(:users)).to match_array([jane])
-      end
-    end
-
-    context 'with a create command for many child tuples' do
-      subject(:command) do
-        ROM::Commands::Lazy[create_tasks].new(create_tasks, evaluator)
-      end
-
-      let(:evaluator) { -> input, index { input[:users][index][:tasks] } }
-
-      let(:input) do
-        { users: [
-          {
-            name: 'Jane',
-            tasks: [{ title: 'Jane Task One' }, { title: 'Jane Task Two' }]
-          },
-          {
-            name: 'Joe',
-            tasks: [{ title: 'Joe Task One' }]
-          }
-        ]}
-      end
-
-      it 'evaluates the input and calls command' do
-        command.call(input, input[:users])
-
-        expect(container.relation(:tasks)).to match_array([
-          { user: 'Jane', title: 'Jane Task One' },
-          { user: 'Jane', title: 'Jane Task Two' },
-          { user: 'Joe', title: 'Joe Task One' }
-        ])
-      end
-    end
-
-    context 'with an update command' do
-      subject(:command) do
-        ROM::Commands::Lazy[update_user].new(
-          update_user, evaluator, -> cmd, user { cmd.by_name(user[:name]) })
-      end
-
-      before do
-        create_user[jane]
-      end
-
-      it 'evaluates the input, restricts the relation and calls its command' do
-        input = { user: { name: 'Jane', email: 'jane.doe@rom-rb.org' } }
-        command.call(input)
-
-        expect(container.relation(:users)).to match_array([input[:user]])
-      end
-    end
-
-    context 'with an update command for a child tuple' do
-      subject(:command) do
-        ROM::Commands::Lazy[update_task].new(
-          update_task,
-          evaluator,
-          -> cmd, user, task { cmd.by_user(user[:name]).by_title(task[:title]) }
-        )
-      end
-
-      let(:evaluator) { -> input { input[:user][:task] } }
-
-      let(:jane) { { name: 'Jane' } }
-      let(:jane_task) { { user: 'Jane', title: 'Jane Task', priority: 1 } }
-
-      let(:input) { { user: jane.merge(task: jane_task) } }
-
-      before do
-        create_user[jane]
-        create_task[user: 'Jane', title: 'Jane Task', priority: 2]
-      end
-
-      it 'evaluates the input, restricts the relation and calls its command' do
-        command.call(input, input[:user])
-
-        expect(container.relation(:users)).to match_array([jane])
-
-        expect(container.relation(:tasks)).to match_array([jane_task])
-      end
-    end
-
-    context 'with an update command for child tuples' do
-      subject(:command) do
-        ROM::Commands::Lazy[update_task].new(
-          update_task,
-          evaluator,
-          -> cmd, user, task { cmd.by_user(user[:name]).by_title(task[:title]) }
-        )
-      end
-
-      let(:evaluator) { -> input { input[:user][:tasks] } }
-
-      let(:jane) { { name: 'Jane' } }
-      let(:jane_tasks) {
-        [
-          { user: 'Jane', title: 'Jane Task One', priority: 2 },
-          { user: 'Jane', title: 'Jane Task Two', priority: 3 }
-        ]
-      }
-
-      let(:input) { { user: jane.merge(tasks: jane_tasks) } }
-
-      before do
-        create_user[jane]
-        create_task[user: 'Jane', title: 'Jane Task One', priority: 3]
-        create_task[user: 'Jane', title: 'Jane Task Two', priority: 4]
-      end
-
-      it 'evaluates the input, restricts the relation and calls its command' do
-        command.call(input, input[:user])
-
-        expect(container.relation(:users)).to match_array([jane])
-
-        expect(container.relation(:tasks)).to match_array(jane_tasks)
-      end
-    end
-
-    context 'with an update command for many parents and their children' do
-      subject(:command) do
-        ROM::Commands::Lazy[update_task].new(
-          update_task,
-          evaluator,
-          -> cmd, user, task { cmd.by_user(user[:name]).by_title(task[:title]) }
-        )
-      end
-
-      let(:evaluator) { -> input, index { input[:users][index][:tasks] } }
-
-      let(:input) do
-        { users: [
-          {
-            name: 'Jane',
-            tasks: [
-              { title: 'Jane Task One', priority: 1 },
-              { title: 'Jane Task Two', priority: 2 }
-            ]
-          },
-          {
-            name: 'Joe',
-            tasks: [{ title: 'Joe Task One', priority: 1 }]
-          }
-        ]}
-      end
-
-      before do
-        create_user[name: 'Jane']
-        create_user[name: 'Joe']
-
-        create_task[user: 'Jane', title: 'Jane Task One']
-        create_task[user: 'Jane', title: 'Jane Task Two']
-        create_task[user: 'Joe', title: 'Joe Task One']
-      end
-
-      it 'evaluates the input and calls its command' do
-        command.call(input, input[:users])
-
-        expect(container.relation(:tasks)).to match_array([
-          { user: 'Jane', title: 'Jane Task One', priority: 1 },
-          { user: 'Jane', title: 'Jane Task Two', priority: 2 },
-          { user: 'Joe', title: 'Joe Task One', priority: 1 }
-        ])
-      end
-    end
-
-    context 'with a delete command' do
-      subject(:command) do
-        ROM::Commands::Lazy[delete_user].new(
-          delete_user,
-          evaluator,
-          -> cmd, user { cmd.by_name(user[:name]) }
-        )
-      end
-
-      let(:joe) { { name: 'Joe' } }
-
-      before do
-        create_user[jane]
-        create_user[joe]
-      end
-
-      it 'restricts the relation and calls its command' do
-        command.call(input)
-
-        expect(container.relation(:users)).to match_array([joe])
-      end
-    end
-  end
-
-  describe '#>>' do
-    subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
-
-    it 'composes with another command' do
-      expect(command >> create_task).to be_instance_of(ROM::Commands::Composite)
-    end
-  end
-
-  describe '#combine' do
-    subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
-
-    it 'combines with another command' do
-      expect(command.combine(create_task)).to be_instance_of(ROM::Commands::Graph)
-    end
-  end
-
-  describe '#unwrap' do
-    subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
-
-    it 'returns wrapped command' do
-      expect(command.unwrap).to be(create_user)
-    end
-  end
-
-  describe '#method_missing' do
-    subject(:command) { ROM::Commands::Lazy[update_user].new(update_user, evaluator) }
-
-    it 'returns original response if it was not a command' do
-      response = command.result
-      expect(response).to be(:one)
-    end
-
-    it 'raises error when message is unknown' do
-      expect { command.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-end

data/spec/unit/rom/commands/result_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Commands::Result do
-  describe '#value' do
-    subject(:result) { ROM::Commands::Result::Success }
-
-    it 'bubble up nested values' do
-      data = double(to_ary: ['foo'])
-      r = result.new(result.new(result.new(data)))
-
-      expect(r.value).to eq(data)
-    end
-  end
-
-  describe '#success?' do
-    context 'not launched command' do
-      subject(:command) { ROM::Commands::Result }
-
-      it 'returns false' do
-        expect(command.new.success?).to eq(false)
-      end
-    end
-
-    context 'successful command' do
-      subject(:result) { ROM::Commands::Result::Success }
-
-      it 'returns true' do
-        data = double(to_ary: ['foo'])
-        expect(result.new(data).success?).to eq(true)
-      end
-    end
-
-    context 'failed command' do
-      subject(:result) { ROM::Commands::Result::Failure }
-
-      it 'returns false' do
-        error = double(:error)
-        expect(result.new(error).success?).to eq(false)
-      end
-    end
-  end
-
-  describe '#failure?' do
-    context 'not launched command' do
-      subject(:command) { ROM::Commands::Result }
-
-      it 'returns false' do
-        expect(command.new.success?).to eq(false)
-      end
-    end
-
-    context 'successful command' do
-      subject(:result) { ROM::Commands::Result::Success }
-
-      it 'returns false' do
-        data = double(to_ary: ['foo'])
-        expect(result.new(data).failure?).to eq(false)
-      end
-    end
-
-    context 'failed command' do
-      subject(:result) { ROM::Commands::Result::Failure }
-
-      it 'returns true' do
-        error = double(:error)
-        expect(result.new(error).failure?).to eq(true)
-      end
-    end
-  end
-end