rom 0.9.1 → 1.0.0.beta1

data/spec/integration/commands/error_handling_spec.rb

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
-describe 'Commands / Error handling'  do
+describe 'Commands / Error handling' do
+  include_context 'container'
   include_context 'users and tasks'
 
   before do
-    setup.relation(:users)
-    setup.commands(:users) { define(:create) }
+    configuration.relation(:users)
+    configuration.commands(:users) { define(:create) }
   end
 
-  subject(:users) { rom.commands.users }
+  subject(:users) { container.commands.users }
 
   it 'rescues from ROM::CommandError' do
     result = false

data/spec/integration/commands/graph_builder_spec.rb

@@ -0,0 +1,213 @@
+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::Registry::ElementNotFoundError, /not_here/)
+  end
+end

data/spec/integration/commands/graph_spec.rb

@@ -1,40 +1,10 @@
 require 'spec_helper'
 
 describe 'Building up a command graph for nested input' do
-  let(:rom) { setup.finalize }
-  let(:setup) { ROM.setup(:memory) }
-
-  before do
-    setup.relation :users
-    setup.relation :tasks
-    setup.relation :books
-    setup.relation :tags
-
-    setup.commands(:users) do
-      define(:create) do
-        result :one
-      end
-    end
-
-    setup.commands(:books) do
-      define(:create) do
-        def execute(tuples, user)
-          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
-        end
-      end
-    end
-
-    setup.commands(:tags) do
-      define(:create) do
-        def execute(tuples, task)
-          super(tuples.map { |t| t.merge(task: task.fetch(:title)) })
-        end
-      end
-    end
-  end
+  include_context 'command graph'
 
   it 'creates a command graph for nested input :one result as root' do
-    setup.commands(:tasks) do
+    configuration.commands(:tasks) do
       define(:create) do
         result :one
 
@@ -69,24 +39,24 @@ describe 'Building up a command graph for nested input' do
       ]
     ]
 
-    command = rom.command(options)
+    command = container.command(options)
 
     command.call(input)
 
-    expect(rom.relation(:users)).to match_array([
+    expect(container.relation(:users)).to match_array([
       { name: 'Jane' }
     ])
 
-    expect(rom.relation(:tasks)).to match_array([
+    expect(container.relation(:tasks)).to match_array([
       { title: 'Task One', user: 'Jane' }
     ])
 
-    expect(rom.relation(:books)).to match_array([
+    expect(container.relation(:books)).to match_array([
       { title: 'Book One', user: 'Jane' },
       { title: 'Book Two', user: 'Jane' }
     ])
 
-    expect(rom.relation(:tags)).to match_array([
+    expect(container.relation(:tags)).to match_array([
       { name: 'red', task: 'Task One' },
       { name: 'green', task: 'Task One' },
       { name: 'blue', task: 'Task One' }
@@ -94,7 +64,7 @@ describe 'Building up a command graph for nested input' do
   end
 
   it 'creates a command graph for nested input with :many results as root' do
-    setup.commands(:tasks) do
+    configuration.commands(:tasks) do
       define(:create) do
         def execute(tuples, user)
           super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
@@ -121,33 +91,126 @@ describe 'Building up a command graph for nested input' do
     options = [
       { user: :users }, [
         :create, [
-          [:tasks, [:create, [:tags, [:create]]]],
+          [:tasks, [:create, [:tags, [:create]]]]
         ]
       ]
     ]
 
-    command = rom.command(options)
+    command = container.command(options)
 
     command.call(input)
 
-    expect(rom.relation(:users)).to match_array([
+    expect(container.relation(:users)).to match_array([
       { name: 'Jane' }
     ])
 
-    expect(rom.relation(:tasks)).to match_array([
+    expect(container.relation(:tasks)).to match_array([
       { title: 'Task One', user: 'Jane' },
       { title: 'Task Two', user: 'Jane' }
     ])
 
-    expect(rom.relation(:tags)).to match_array([
+    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
-    setup.mappers do
+    configuration.mappers do
       define(:users) do
         register_as :entity
         reject_keys true
@@ -168,7 +231,7 @@ describe 'Building up a command graph for nested input' do
       end
     end
 
-    setup.commands(:tasks) do
+    configuration.commands(:tasks) do
       define(:create) do
         def execute(tuples, user)
           super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
@@ -195,12 +258,12 @@ describe 'Building up a command graph for nested input' do
     options = [
       { user: :users }, [
         :create, [
-          [:tasks, [:create, [:tags, [:create]]]],
+          [:tasks, [:create, [:tags, [:create]]]]
         ]
       ]
     ]
 
-    command = rom.command(options).as(:entity)
+    command = container.command(options).as(:entity)
 
     result = command.call(input).one
 
@@ -216,10 +279,10 @@ describe 'Building up a command graph for nested input' do
       { user: :users }, [:create, [{ book: :books }, [:create]]]
     ]
 
-    command = rom.command(options)
+    command = container.command(options)
 
     expect {
       command.call(input)
-    }.to raise_error(ROM::CommandFailure, /book/)
+    }.to raise_error(ROM::KeyMissing, /book/)
   end
 end