rom 3.3.3 → 4.0.0.beta1

data/spec/unit/rom/association_set_spec.rb

@@ -1,48 +0,0 @@
-RSpec.describe ROM::AssociationSet do
-  describe '#try' do
-    it 'returns association when it exists' do
-      assoc = spy(:assoc)
-      assoc_set = ROM::AssociationSet.new(users: assoc)
-
-      assoc_set.try(:users, &:done)
-
-      expect(assoc).to have_received(:done)
-
-      assoc_set.try(:user, &:done)
-
-      expect(assoc).to have_received(:done)
-    end
-
-    it 'returns false when assoc is not found' do
-      assoc = spy(:assoc)
-      fallback = spy(:fallback)
-      assoc_set = ROM::AssociationSet.new({})
-
-      assoc_set.try(:users, &:done) or fallback.done
-
-      expect(assoc).to_not have_received(:done)
-      expect(fallback).to have_received(:done)
-    end
-  end
-
-  describe '#[]' do
-    let(:users) { BasicObject.new }
-    let(:posts) { BasicObject.new }
-    let(:set) { ROM::AssociationSet.new(users: users, post: posts) }
-
-    it 'fetches association' do
-      expect(set[:users]).to be users
-    end
-
-    it 'tries to fetch under singularized key' do
-      expect(set[:post]).to be posts
-    end
-
-    it 'throws exception on missing association' do
-      expect { set[:labels] }.to raise_error(
-        ROM::Registry::ElementNotFoundError,
-        ":labels doesn't exist in ROM::AssociationSet registry"
-      )
-    end
-  end
-end

data/spec/unit/rom/auto_curry_spec.rb

@@ -1,71 +0,0 @@
-require 'rom/auto_curry'
-
-RSpec.describe ROM::AutoCurry do
-  subject(:object) { klass.new }
-
-  let(:klass) do
-    Class.new do
-      extend ROM::AutoCurry
-
-      def self.curried(*)
-        self
-      end
-
-      def initialize(*)
-      end
-
-      def arity_0
-        0
-      end
-
-      def arity_1(x)
-        x
-      end
-
-      def arity_2(x, y)
-        [x,y]
-      end
-
-      def arity_many(*args)
-        args
-      end
-
-      def yielding_block(arg)
-        yield(arg)
-      end
-
-      protected
-
-      def leave_me_alone(foo)
-        foo
-      end
-    end
-  end
-
-  it 'registers auto-curried methods' do
-    expect(object.class.auto_curried_methods).to eql(%i[arity_1 arity_2 arity_many yielding_block])
-  end
-
-  it 'auto-curries method with arity == 0' do
-    expect(object.arity_0).to be(0)
-  end
-
-  it 'auto-curries method with arity == 1' do
-    expect(object.arity_1).to be_instance_of(klass)
-    expect(object.arity_1(1)).to be(1)
-  end
-
-  it 'auto-curries method with arity > 0' do
-    expect(object.arity_2).to be_instance_of(klass)
-    expect(object.arity_2(1, 2)).to eql([1, 2])
-  end
-
-  it 'auto-curries method with arity < 0' do
-    expect(object.arity_many).to eql([])
-    expect(object.arity_many(1, 2)).to eql([1, 2])
-  end
-
-  it 'yields block' do
-    expect(object.yielding_block(1) { |arg| [arg, 2] }).to eql([1, 2])
-  end
-end

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

@@ -1,192 +0,0 @@
-require 'spec_helper'
-require 'dry-struct'
-
-RSpec.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
-        before :associate
-
-        def associate(task, user)
-          task.merge(user: user[:name])
-        end
-      end
-
-      define(:create) do
-        register_as :create_many
-        before :associate
-
-        def associate(tasks, user)
-          tasks.map { |t| t.merge(user: user[:name]) }
-        end
-      end
-    end
-
-    configuration.commands(:tags) do
-      define(:create) do
-        register_as :create_many
-        before :associate
-
-        def associate(tags, tasks)
-          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,310 +0,0 @@
-require 'spec_helper'
-
-RSpec.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
-        before :associate
-
-        def associate(tuples, user)
-          tuples.map { |tuple| tuple.merge(user: user[:name]) }
-        end
-      end
-
-      define(:update) do
-        result :one
-        before :associate
-
-        def associate(tuple, user)
-          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