rails_workflow 0.3.9 → 0.4.0

data/spec/lib/operation_builder_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module RailsWorkflow
+  RSpec.describe OperationBuilder do
+    let(:operation_runner) { OperationRunner }
+    let(:manager) { ProcessManager.new(process) }
+    let(:process) { create :process }
+    let(:operation) { described_class.new(process, template).create_operation }
+
+    let(:template) do
+      create :operation_template,
+             operation_class: 'RailsWorkflow::UserByGroupOperation'
+    end
+
+    before do
+      allow_any_instance_of(RailsWorkflow::Process)
+        .to receive(:manager).and_return(manager)
+    end
+
+    it { expect(operation.title).to eq template.title }
+    it { expect(operation.async).to eq template.async }
+    it { expect(operation.is_background).to eq template.is_background }
+    it { expect(operation).to be_kind_of UserByGroupOperation }
+    it { expect(operation.template).to eq template }
+    it { expect(operation.process).to eq process }
+    it { expect(operation.manager).to eq manager }
+    it { expect(operation.status).to eq Status::NOT_STARTED }
+    it { expect(operation.persisted?).to be true }
+
+    context 'sets dependencies' do
+      context 'from template' do
+        let(:operation) { create :operation, status: Status::ERROR }
+        let(:dependencies) do
+          [
+            { 'operation_id' => operation.id, 'status' => operation.status }
+          ]
+        end
+        let(:operation_with_dependencies) do
+          described_class.new(process, template, [operation]).create_operation
+        end
+
+        it do
+          expect(operation_with_dependencies.dependencies).to eq dependencies
+        end
+      end
+
+      it 'when no dependencies' do
+        expect(operation.dependencies).to eq []
+      end
+    end
+
+    context 'should build child process' do
+      let(:parent_template) { create :parent_operation_template }
+
+      let(:parent_operation) do
+        described_class.new(
+          process, parent_template, [operation]
+        ).create_operation
+      end
+
+      it do
+        expect(parent_operation.child_process)
+          .to be_a_kind_of RailsWorkflow::Process
+      end
+    end
+  end
+end

data/spec/lib/process_builder_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module RailsWorkflow
+  RSpec.describe ProcessBuilder do
+    let(:template) do
+      create :process_template, process_class: 'RailsWorkflow::TestProcess'
+    end
+
+    let(:new_process) { described_class.new(template, {}).create_process! }
+
+    it { expect(new_process).to be_instance_of TestProcess }
+    it { expect(new_process.template).to eq template }
+  end
+
+  class TestProcess < RailsWorkflow::Process
+  end
+end

data/spec/{core/rails_workflow → lib}/process_manager_spec.rb

@@ -1,4 +1,7 @@
-require_relative 'prepare_template'
+# frozen_string_literal: true
+
+require 'rails_helper'
+require_relative '../support/rails_workflow/prepare_template'
 
 module RailsWorkflow
   RSpec.describe ProcessManager do
@@ -6,13 +9,14 @@ module RailsWorkflow
 
     let(:template) { prepare_template }
 
-    subject(:process) { described_class.build_process template.id, msg: 'Test' }
+    let(:process) { described_class.create_process template.id, msg: 'Test' }
+    let(:operation_runner) { RailsWorkflow::OperationRunner }
 
     context 'build process' do
       it 'should create new process' do
         expect(process).to be
         expect(process).to be_kind_of(Process)
-        expect(process.status).to eq RailsWorkflow::Process::NOT_STARTED
+        expect(process.status).to eq RailsWorkflow::Status::NOT_STARTED
       end
 
       it 'with reference to template' do
@@ -22,7 +26,7 @@ module RailsWorkflow
       it 'should create new process operations' do
         expect(process.operations.size).to eq 1
         expect(process.operations.first.status)
-          .to eq RailsWorkflow::Operation::NOT_STARTED
+          .to eq RailsWorkflow::Status::NOT_STARTED
       end
 
       it 'should create process context' do
@@ -35,21 +39,6 @@ module RailsWorkflow
         expect(context).to be
         expect(context.data[:msg]).to eq 'Test'
       end
-
-    end
-
-    context 'caching' do
-      before do
-        RailsWorkflow.config.cache.clear
-      end
-
-      it 'should use cached templates version' do
-        relation = RailsWorkflow::ProcessTemplate.eager_load(:operations)
-        allow(RailsWorkflow::ProcessTemplate).to receive(:eager_load).and_return(relation)
-
-        expect(relation).to receive(:find).once.and_call_original
-        described_class.build_process template.id, msg: 'Test'
-      end
     end
 
     context 'start process' do
@@ -57,18 +46,18 @@ module RailsWorkflow
         before :each do
           allow_any_instance_of(RailsWorkflow::ProcessManager)
             .to receive(:complete_process)
-          allow_any_instance_of(RailsWorkflow::Operation).to receive(:complete)
+          allow_any_instance_of(RailsWorkflow::OperationRunner).to receive(:complete)
           process_manager = RailsWorkflow::ProcessManager.new process
           process_manager.start_process
         end
 
         it 'should start new process' do
-          expect(process.status).to eq RailsWorkflow::Process::IN_PROGRESS
+          expect(process.status).to eq RailsWorkflow::Status::IN_PROGRESS
         end
 
         it 'should start first operations' do
           expect(process.operations.first.status)
-            .to eq RailsWorkflow::Operation::IN_PROGRESS
+            .to eq RailsWorkflow::Status::IN_PROGRESS
         end
       end
     end
@@ -81,12 +70,13 @@ module RailsWorkflow
           allow_any_instance_of(RailsWorkflow::OperationTemplate)
             .to receive(:resolve_dependency).and_return(false)
           manager.start_process
-          process.operations.first.complete
+          operation_runner.new(process.operations.first).complete
           expect(process.operations.size).to eq 1
         end
+
         it 'should not be created when dependencies is not sutisfied' do
           manager.start_process
-          process.operations.first.complete
+          operation_runner.new(process.operations.first).complete
           expect(process.operations.size).to eq 2
         end
       end
@@ -94,13 +84,13 @@ module RailsWorkflow
       context 'after first operation done' do
         before do
           manager.start_process
-          process.operations.first.complete
+          operation_runner.new(process.operations.first).complete
         end
 
-        [:complete, :skip, :cancel].each do |method_name|
+        %i[complete skip cancel].each do |method_name|
           new_method = <<-METHOD
             it 'should complete process if last operation #{method_name}' do
-              process.operations.last.#{method_name}
+              operation_runner.new(process.operations.last).#{method_name}
               expect(process.status).to eq Process::DONE
             end
           METHOD

data/spec/models/rails_workflow/context_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
 
 module RailsWorkflow
@@ -80,10 +82,11 @@ module RailsWorkflow
     end
 
     it 'should be build using operation dependencies contexts' do
-      operation = create :operation_with_context, status: RailsWorkflow::Operation::ERROR
+      operation = create :operation_with_context, status: RailsWorkflow::Status::ERROR
 
-      child_operation =
-        template.build_operation! process, [operation]
+      child_operation = OperationBuilder.new(
+        process, template, [operation]
+      ).create_operation
 
       expect(child_operation.context.data).to match(msg: 'Test')
     end

data/spec/models/rails_workflow/error_spec.rb

@@ -1,153 +1,26 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
 
 module RailsWorkflow
   RSpec.describe Error, type: :model do
-    # let(:process_template) { create :process_template }
-    # let(:process) {
-    #   process = create :process, template: process_template
-    #   process.create_context data: {msg: "Test"}
-    #   process
-    # }
-    # let(:test_message) { "Test message" }
-    # let(:operation) { create :operation, process: process }
-    #
-    #
-    # it 'should create error if process build raised exception' do
-    #   allow_any_instance_of(Workflow::OperationTemplate).to receive(:build_operation!).and_raise(test_message)
-    #
-    #   expect{
-    #       ProcessManager.start_process process_template.id, {}
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Process)
-    #   expect(error.parent.status).to eq Workflow::Process::ERROR
-    # end
-    #
-    # it 'should create error if process failed to start' do
-    #   manager = Workflow::ProcessManager.new process
-    #   allow(process).to receive(:start).and_raise(test_message)
-    #
-    #   expect {
-    #     manager.start_process
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to eq process
-    #   expect(error.parent.status).to eq Workflow::Process::ERROR
-    # end
-    #
-    # it 'should create error if process manager init fails' do
-    #   allow_any_instance_of(Workflow::OperationTemplate).to receive(:build_operation!).and_raise(test_message)
-    #
-    #   expect{
-    #     ProcessManager.start_process process_template.id, {}
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Process)
-    #   expect(error.parent.status).to eq Workflow::Process::ERROR
-    # end
-    #
-    # it 'should create error if process manager build process fails' do
-    #   allow_any_instance_of(Workflow::OperationTemplate).to receive(:build_operation!).and_raise(test_message)
-    #
-    #   expect{
-    #     ProcessManager.start_process process_template.id, {}
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Process)
-    #   expect(error.parent.status).to eq Workflow::Process::ERROR
-    # end
-    #
-    # it 'should creaete error if operation start fails' do
-    #   allow_any_instance_of(Workflow::Operation).to receive(:can_start?).and_raise(test_message)
-    #
-    #   expect{
-    #     operation.start
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Operation)
-    #   expect(error.parent.status).to eq Workflow::Operation::ERROR
-    #   operaiton.reload
-    #   expect(operation.process.status).to eq Workflow::Process::ERROR
-    # end
-    #
-    # it 'should create error if operation waiting fails' do
-    #   allow_any_instance_of(Workflow::Operation).to receive(:start_waiting).and_raise(test_message)
-    #
-    #   expect{
-    #     operation.waiting
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Operation)
-    #   expect(error.parent.status).to eq Workflow::Operation::ERROR
-    # end
-    #
-    # it 'should create error if operation execute fails' do
-    #   allow_any_instance_of(Workflow::Operation).to receive(:execute).and_raise(test_message)
-    #
-    #   expect{
-    #     operation.start
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Operation)
-    #   expect(error.parent.status).to eq Workflow::Operation::ERROR
-    # end
-    #
-    # it 'should create error if operation complete fails' do
-    #   allow_any_instance_of(Workflow::ProcessManager).to receive(:operation_complete).and_raise(test_message)
-    #
-    #   expect{
-    #     operation.manager = Workflow::ProcessManager.new process
-    #     operation.complete
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq test_message
-    #   expect(error.parent).to be_a_kind_of(Workflow::Operation)
-    #   expect(error.parent.status).to eq Workflow::Operation::ERROR
-    # end
-    #
-    # it 'should create error if operation build failed' do
-    #
-    #   operation_template = create :operation_template
-    #   allow_any_instance_of(Workflow::OperationTemplate).to receive(:operation_class).and_return("NotExistingClass")
-    #
-    #   expect {
-    #     operation =
-    #       operation_template.build_operation! process
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   error = Workflow::Error.last
-    #   expect(error.message).to eq "undefined method `create' for \"NotExistingClass\":String"
-    #   expect(error.parent).to be_a_kind_of(Workflow::Process)
-    #   expect(error.parent.status).to eq Workflow::Process::ERROR
-    #
-    # end
-    #
-    # it 'should set default class to parent operation' do
-    #
-    #   allow_any_instance_of(Workflow::CustomOperation).to receive(:execute).and_raise("Some exception")
-    #   operation = create :custom_operation
-    #
-    #   expect {
-    #     operation.start
-    #   }.to change { Workflow::Error.count }.by(1)
-    #
-    #   expect(operation.workflow_errors.first.parent_type).to eq "Workflow::Operation"
-    # end
-    #
+    describe '#can_restart_process?' do
+      let(:process) { RailsWorkflow::Process.create }
+      before do
+        allow(subject).to receive(:process).and_return(process)
+      end
+
+      it { expect(subject.can_restart_process?).to eq true }
+
+      context 'with errors' do
+        before do
+          allow(process).to receive(
+            :unresolved_errors
+          ).and_return ['some_error']
+        end
+
+        it { expect(subject.can_restart_process?).to eq false }
+      end
+    end
   end
 end

data/spec/models/rails_workflow/operation_spec.rb

@@ -1,93 +1,39 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
+require_relative '../../concerns/status_spec.rb'
 
 module RailsWorkflow
   RSpec.describe Operation, type: :model do
-    context 'Default Builder' do
-      let(:template) do
-        create :operation_template, async: true, operation_class: 'RailsWorkflow::UserByGroupOperation'
-      end
-
-      let(:manager) { manager = RailsWorkflow::ProcessManager.new(process) }
-      let(:process) { process = create :process }
+    it_behaves_like 'Status'
+    let(:operation_runner) { OperationRunner }
 
-      let(:operation) { template.build_operation! process }
-
-      before :each do
-        allow_any_instance_of(RailsWorkflow::Process).to receive(:manager).and_return(manager)
+    context '#completable?' do
+      describe 'no child process' do
+        it { expect(subject).to be_completable }
       end
 
-      it 'sould fill title and async from template' do
-        expect(operation.title).to eq template.title
-        expect(operation.async).to eq template.async
-        expect(operation.is_background).to eq template.is_background
-      end
-
-      context 'should set dependencies' do
-        it 'from template' do
-          operation = create :operation, status: RailsWorkflow::Operation::ERROR
-
-          operation_with_dependencies =
-            template.build_operation! process, [operation]
-
-          dependencies = [
-            {
-              'operation_id' => operation.id,
-              'status' => operation.status
-            }
-          ]
-
-          expect(operation_with_dependencies.dependencies).to eq dependencies
-        end
-
-        it 'when template dependencies is blank' do
-          expect(operation.dependencies).to eq []
+      describe 'completed child process' do
+        before do
+          subject.child_process = Process.create(status: Status::DONE)
         end
-      end
-
-      it 'should build correct class' do
-        expect(operation).to be_kind_of RailsWorkflow::UserByGroupOperation
-      end
-
-      it 'should set reference to operation template' do
-        expect(operation.template).to eq template
-      end
-
-      it 'should set process' do
-        expect(operation.process).to eq process
-        expect(operation.process_id).to eq process.id
-      end
-
-      it 'should set manager' do
-        expect(operation.manager).to eq manager
-        operation.manager = manager
-      end
 
-      it 'should set status NOT STARTED' do
-        expect(operation.status).to eq RailsWorkflow::Operation::NOT_STARTED
+        it { expect(subject).to be_completable }
       end
 
-      it 'should build child process' do
-        parent_template = create :parent_operation_template
-
-        parent_operation = parent_template.build_operation! process, [operation]
-
-        expect(parent_operation.child_process).to be_a_kind_of RailsWorkflow::Process
-      end
+      describe 'non-completed child process' do
+        before do
+          subject.child_process = Process.create(status: Status::WAITING)
+        end
 
-      it 'should save operation' do
-        expect(operation.persisted?).to be true
+        it { expect(subject).not_to be_completable }
       end
     end
 
+    # TODO: move to separate spec for OperationAssignment
     context 'Operation Assignment' do
-      let(:operation) do
-        operation = create :operation
-      end
-
-      let(:other_user) do
-        create :user, email: 'other@user.com'
-      end
-
+      let(:operation) { create :operation }
+      let(:other_user) { create :user, email: 'other@user.com' }
       let(:user) { create :user }
 
       it 'should assigns operation to user' do
@@ -142,72 +88,93 @@ module RailsWorkflow
         role_template = create :operation_template, role: :admin
         group_template = create :operation_template, group: 'some_group'
 
-        group_operation = create :operation, status: Operation::WAITING, template: group_template
-        role_operation = create :operation, status: Operation::WAITING, template: role_template
+        group_operation = create :operation,
+                                 status: Status::WAITING,
+                                 template: group_template
+
+        role_operation = create :operation,
+                                status: Status::WAITING,
+                                template: role_template
 
         user = create :user, role: :admin
 
-        role_operations = RailsWorkflow::Operation.available_for_user(user)
+        role_operations = Operation.available_for_user(user)
         expect(role_operations).to match_array([role_operation])
 
         fake_user = create :user, email: 'fake@email.com', role: 'fake'
-        expect(RailsWorkflow::Operation.available_for_user(fake_user)).to eq []
+        expect(Operation.available_for_user(fake_user)).to eq []
 
         role_operation.assign user
-        expect(RailsWorkflow::Operation.unassigned).to match_array [group_operation]
+        expect(Operation.unassigned)
+          .to match_array [group_operation]
       end
     end
 
+    # TODO: move to separate spec for Operation Runner
     context 'Operation Runner' do
       let(:operation) { create :operation_with_context }
-      let(:process) { process = create :process }
+      let(:process) { create :process }
 
       it 'should be set to WAITING if can not start' do
         allow(operation).to receive(:can_start?).and_return(false)
-        operation.start
-        expect(operation.status).to eq RailsWorkflow::Operation::WAITING
+        operation_runner.new(operation).start
+        expect(operation.status).to eq Status::WAITING
       end
 
       it 'should start child process' do
-        allow_any_instance_of(RailsWorkflow::Process).to receive(:can_start?).and_return(true)
-        allow_any_instance_of(RailsWorkflow::Process).to receive(:can_complete?).and_return(false)
+        allow_any_instance_of(RailsWorkflow::Process)
+          .to receive(:can_start?).and_return(true)
+
+        allow_any_instance_of(RailsWorkflow::ProcessRunner)
+          .to receive(:completable?).and_return(false)
 
         parent_operation = create :operation
 
         parent_operation.child_process = process
         parent_operation.save
-        parent_operation.start
+        operation_runner.new(parent_operation).start
 
-        expect(parent_operation.status).to eq RailsWorkflow::Operation::IN_PROGRESS
+        expect(parent_operation.status).to eq Status::IN_PROGRESS
         parent_operation.child_process.reload
-        expect(parent_operation.child_process.status).to eq RailsWorkflow::Process::IN_PROGRESS
-      end
 
-      it 'should not complete if child process is in progress'
+        expect(parent_operation.child_process.status).to eq Status::IN_PROGRESS
+      end
     end
 
     context 'complete operation ' do
       before :each do
-        @manager = RailsWorkflow::ProcessManager.new
-        allow_any_instance_of(RailsWorkflow::Operation).to receive(:manager).and_return(@manager)
+        @manager = ProcessManager.new
+        @process = RailsWorkflow::Process.new
+        @dependency_resolver = DependencyResolver.new(@process)
+
+        allow(@dependency_resolver).to receive(:build_new_operations)
+        allow(DependencyResolver).to receive(:new)
+          .and_return(@dependency_resolver)
+
+        # TODO: REWORK
+        allow_any_instance_of(Operation)
+          .to receive(:manager).and_return(@manager)
+
+        allow_any_instance_of(Operation)
+          .to receive(:process).and_return(@process)
       end
 
       it 'should change state to DONE on complete' do
-        expect(@manager).to receive(:operation_completed)
+        # expect(@manager).to receive(:operation_completed)
         subject.complete
-        expect(subject.status).to eq RailsWorkflow::Operation::DONE
+        expect(subject.status).to eq Status::DONE
       end
 
       it 'should change state to SKIP on skip' do
-        expect(@manager).to receive(:operation_completed)
+        # expect(@manager).to receive(:operation_completed)
         subject.skip
-        expect(subject.status).to eq RailsWorkflow::Operation::SKIPPED
+        expect(subject.status).to eq Status::SKIPPED
       end
 
       it 'should change state to DONE on complete' do
-        expect(@manager).to receive(:operation_completed)
+        # expect(@manager).to receive(:operation_completed)
         subject.cancel
-        expect(subject.status).to eq RailsWorkflow::Operation::CANCELED
+        expect(subject.status).to eq Status::CANCELED
       end
     end
   end