rails_workflow 0.3.9 → 0.4.0

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/7O/7O5OddMZvWFGpj71BCdc0vA55rhj4YPoL0XjBV4_OYk.cache

@@ -0,0 +1 @@
+"%����"m�J���S��E�j!�/�d�]�/[���

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/Cy/CyixQwp8QvorgpRadtYf6_zY35nZZp0JmrhkDN16XPM.cache

@@ -0,0 +1 @@
+"%�Q)��MI-���{�h�⃯�\�WUD ���

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/FW/FWR5Q7EP17cTcY35R1MscF6MX2HYiH5I2ZII89YLYxc.cache

@@ -0,0 +1 @@
+"%]���:ǚ	G�z#�X��oD^O��ެp8R

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/HQ/HQuQO1k4kOyLSDXJEc8p-XR2agdkPF7mIFyh2noiNrU.cache

@@ -0,0 +1 @@
+"%���NO|�Z�����?ʼ�P(v�o�J�9��1

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/Rs/RsIG_ias53xeb4WHWRodcMcDmVyz1QvLQNy4gV2iBSo.cache

@@ -0,0 +1 @@
+"%���}�Tk�d\��@H��`�vB�'B���I

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/WI/WI2XYMfwCaPWcjvvouKVltl9oKqKZL-BHePPLhC-rzw.cache

@@ -0,0 +1 @@
+"%������S��h�˯Wu;&�V�#
�Y��

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/Yc/YcbQRZWzddLfawePxNTEXcFFiS7asAyrujZzciT99l0.cache

@@ -0,0 +1 @@
+"%>��.��l�;T��_2��IT���Ɣc�ḩ

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/ai/aihcJWCIJGiHDpamul8bzy4jMsxnhewX6XWtkdsQ9dc.cache

@@ -0,0 +1 @@
+"%�U7��r���	����ڥ�2�)d*�d��/po�

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/fR/fRVQN4mU7z3MVJD9u1LMq8idpOH8o2tFh_YouMYGAM8.cache

@@ -0,0 +1 @@
+"%��P�k7}�i�Ur�����Փa!�����@�a

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/gU/gUFNMb7SgxFyz5ZZcGfp-VYRVIw711HUeiWonMzYrcU.cache

@@ -0,0 +1 @@
+"%���h��;����*���b(��n��Gn��L	

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/h8/h86FNb4MxO5dq40P8KcCgGwZ_uqd8nn_O2fMWGDApW8.cache

@@ -0,0 +1 @@
+"%K�@Ĝ(�2T�J��s�)iW�8���4�

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/q7/q7cZDJXZFXTklMF8JAQSMr-MBxOKc7q1vZAPPR5RBf4.cache

@@ -0,0 +1,2 @@
+"%~�n��Um�lr�+� Mp��
+���4v����

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/s9/s98GbJDqEe4PG3moRH6h-ukIZmQz9Frq4LO_Z9vCBLM.cache

@@ -0,0 +1 @@
+"%��}�������J�d���p�A,#G��  �j��

data/spec/dummy/tmp/cache/assets/sprockets/v3.0/xX/xXCd205lXu7u_BuyBL0kfZwkBGJLvocHDItBfU6tMm4.cache

@@ -0,0 +1,2 @@
+"%�h�
+��0��

data/spec/factories/context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :context, class: 'RailsWorkflow::Context'
 end

data/spec/factories/operation_templates.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :operation_template, class: 'RailsWorkflow::OperationTemplate' do
     title 'Operation Template'

data/spec/factories/operations.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :operation, class: 'RailsWorkflow::Operation' do
     title 'Test Operation'
-    status RailsWorkflow::Operation::NOT_STARTED
+    status RailsWorkflow::Status::NOT_STARTED
 
     factory :operation_with_context do
       context { create :context, data: { msg: 'Test' } }

data/spec/factories/process_templates.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :process_template, class: 'RailsWorkflow::ProcessTemplate' do
     title 'Process Template'

data/spec/factories/processes.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :process, class: 'RailsWorkflow::Process' do
-    status RailsWorkflow::Process::NOT_STARTED
+    status RailsWorkflow::Status::NOT_STARTED
     context { create :context, data: { msg: 'Test message' } }
   end
 end

data/spec/factories/user.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :user, class: User do
     email 'test@test.com'

data/spec/factories/workflow_errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 FactoryGirl.define do
   factory :workflow_error, class: 'RailsWorkflow::Error' do
     message 'MyString'

data/spec/features/operations_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
 require_relative '../support/pages/operations.rb'
 

data/spec/features/process_template_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
 
 feature 'Process Template' do

data/spec/lib/error_builder_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module RailsWorkflow
+  RSpec.describe ErrorBuilder do
+    # TODO: add process builder failures tests
+    let(:process_template) { create :process_template }
+    let(:process) { create(:process, template: process_template) }
+    let(:operation) { create :operation, process: process }
+    let(:operation_runner) { OperationRunner.new(operation) }
+    let(:test_message) { 'Test message' }
+
+    let(:error) { operation.workflow_errors.first }
+    let(:error_parent) { operation }
+    let(:error_target) { operation }
+    let(:error_args) { nil }
+    let(:error_parent_type) { RailsWorkflow::Operation }
+    let(:error_method) { 'start_process' }
+
+    shared_context 'workflow failed' do
+      specify do
+        expect { failing_method_call }
+          .to change { RailsWorkflow::Error.count }.by(1)
+      end
+
+      context 'manager creates error' do
+        before { failing_method_call }
+        it_behaves_like 'has workflow error'
+      end
+    end
+
+    shared_examples 'has workflow error' do
+      it { expect(process.reload.status).to eq RailsWorkflow::Status::ERROR }
+
+      it { expect(error_parent.workflow_errors.count).to eq 1 }
+      it { expect(error_parent.status).to eq RailsWorkflow::Status::ERROR }
+
+      it { expect(error.message).to eq test_message }
+
+      # TODO: check with custom operation / process types
+      it { expect(error.parent).to be_a_kind_of(error_parent_type) }
+
+      it { expect(error.data[:target]).to eq error_target }
+      it { expect(error.data[:method]).to eq error_method }
+      it { expect(error.data[:args]).to eq error_args }
+    end
+
+    def raise_error(target, method_name)
+      allow(target).to receive(method_name).and_raise(test_message)
+    end
+
+    context 'when operation fails to start' do
+      let(:error_target) { 'operation_runner' }
+      before { raise_error operation, :can_start? }
+      let(:failing_method_call) { operation.start }
+      let(:error_method) { 'start' }
+
+      it_behaves_like 'workflow failed'
+    end
+
+    context 'when operation fails to start waiting' do
+      let(:error_target) { 'operation_runner' }
+      before { raise_error operation, :update_attribute }
+      let(:failing_method_call) { operation_runner.waiting }
+      let(:error_method) { 'waiting' }
+
+      it_behaves_like 'workflow failed'
+    end
+
+    # TODO: cover other errors in execute_in_transitions
+    context 'when operation execution fails' do
+      let(:error_method) { 'execute_in_transaction' }
+      let(:error_target) { 'operation_runner' }
+      before { raise_error(operation, :execute) }
+      let(:failing_method_call) { operation_runner.execute_in_transaction }
+
+      it_behaves_like 'workflow failed'
+    end
+
+    context 'when operation build fails' do
+      let(:operation_template) { create :operation_template }
+      let(:error) { process.workflow_errors.first }
+      let(:error_target) { 'operation_builder' }
+      let(:error_parent) { process }
+      let(:error_parent_type) { RailsWorkflow::Process }
+      let(:error_method) { 'create_operation' }
+      let(:error_args) { [process, operation_template, []] }
+      let(:operation_builder) do
+        OperationBuilder.new(process, operation_template)
+      end
+
+      before { raise_error operation_builder, :create_operation! }
+      let(:failing_method_call) do
+        operation_builder.create_operation
+      end
+
+      it_behaves_like 'workflow failed'
+    end
+
+    context 'when new operations build fails' do
+      let(:error) { process.workflow_errors.first }
+      let(:error_target) { 'dependency_resolver' }
+      let(:error_parent) { process }
+      let(:error_method) { 'build_new_operations' }
+      let(:error_parent_type) { RailsWorkflow::Process }
+      let(:error_args) { [operation] }
+      let(:dependency_resolver) { DependencyResolver.new(process) }
+
+      before { raise_error dependency_resolver, :matched_templates }
+      let(:failing_method_call) do
+        dependency_resolver.build_new_operations(operation)
+      end
+
+      it_behaves_like 'workflow failed'
+    end
+
+    context 'when process manager fails to start process' do
+      let(:process_manager) { RailsWorkflow::ProcessManager.new(process) }
+      let(:process_runner) { RailsWorkflow::ProcessRunner.new(process) }
+      let(:error) { process.workflow_errors.first }
+      let(:error_target) { 'process_manager' }
+      let(:error_parent) { process }
+      let(:error_parent_type) { RailsWorkflow::Process }
+
+      let(:failing_method_call) { process_manager.start_process }
+      before do
+        allow(RailsWorkflow::ProcessRunner).to receive(:new)
+          .and_return(process_runner)
+
+        raise_error process_runner, :start
+      end
+
+      it_behaves_like 'workflow failed'
+    end
+  end
+end

data/spec/lib/error_resolver_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require_relative '../support/rails_workflow/prepare_template'
+
+module RailsWorkflow
+  RSpec.describe ErrorResolver do
+    include PrepareTemplate
+
+    let(:template) { prepare_template }
+    let(:process_manager) do
+      ProcessManager.new(
+        template_id: template.id, context: { msg: 'Test' }
+      )
+    end
+
+    let(:process) { process_manager.create_process }
+    let(:process_runner) { RailsWorkflow::ProcessRunner.new(process) }
+
+    context 'operation fails' do
+      let(:operation) { process.operations.first }
+      let(:error) { operation.workflow_errors.first }
+      let(:error_resolver) { described_class.new(error) }
+
+      context 'to start' do
+        before do
+          with_failing_instance(Operation, :execute) do
+            process_runner.start
+          end
+        end
+
+        it 'set proper process status after retry' do
+          expect { error_resolver.retry }
+            .to change { process.reload.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+
+        it 'set proper operation status after retry' do
+          expect { error_resolver.retry }
+            .to change { process.reload.operations.first.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+      end
+
+      context 'to wait' do
+        before do
+          allow_any_instance_of(Operation)
+            .to receive(:can_start?).and_return(false)
+
+          with_failing_instance(Operation, :update_attribute) do
+            process_runner.start
+          end
+        end
+
+        it 'set proper process status' do
+          expect { error_resolver.retry }
+            .to change { process.reload.status }
+            .from(Status::ERROR).to(Status::IN_PROGRESS)
+        end
+
+        it 'set proper operation status' do
+          expect { error_resolver.retry }
+            .to change { process.reload.operations.first.status }
+            .from(Status::ERROR).to(Status::WAITING)
+        end
+      end
+
+      context 'execution fails' do
+        before do
+          with_failing_instance(Operation, :execute) do
+            process_runner.start
+          end
+        end
+
+        it 'set proper process status' do
+          expect { error_resolver.retry }
+            .to change { process.reload.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+
+        it 'set proper operation status' do
+          expect { error_resolver.retry }
+            .to change { process.reload.operations.first.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+      end
+    end
+
+    context 'operation building fails' do
+      let(:operation) { process.operations.first }
+      let(:error) { process.workflow_errors.first }
+      let(:error_resolver) { described_class.new(error) }
+
+      context 'when operation build fails' do
+        before do
+          with_failing(Operation, :create) do
+            process_runner.start
+          end
+        end
+
+        it 'set proper process status' do
+          expect { error_resolver.retry }
+            .to change { process.reload.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+
+        it 'set proper operation status' do
+          expect { error_resolver.retry }
+            .to change { process.reload.operations&.first&.status }
+            .to(Status::DONE)
+        end
+      end
+    end
+
+    context 'process runner fails to start' do
+      let(:error) { Error.first }
+      let(:error_resolver) { described_class.new(error) }
+
+      context 'when operation build fails' do
+        before do
+          with_failing_instance(ProcessRunner, :start) do
+            process_manager.create_process
+            process_manager.start_process
+          end
+        end
+
+        it 'set proper process status' do
+          expect { error_resolver.retry }
+            .to change { Process.first.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+
+        it 'creates and completes operations' do
+          expect { error_resolver.retry }
+            .to change { Process.first.operations.count }
+            .from(1).to(2)
+        end
+      end
+    end
+
+    context 'dependency resolver' do
+      let(:operation) { process.operations.first }
+      let(:error) { process.workflow_errors.first }
+      let(:error_resolver) { described_class.new(error) }
+
+      context 'when operation build fails' do
+        before do
+          with_failing_instance(DependencyResolver, :matched_templates) do
+            process_runner.start
+          end
+        end
+
+        it 'set proper process status' do
+          expect { error_resolver.retry }
+            .to change { Process.first.status }
+            .from(Status::ERROR).to(Status::DONE)
+        end
+
+        it 'set proper operation status' do
+          expect { error_resolver.retry }
+            .to change { Process.first.operations.count }
+            .from(1).to(2)
+        end
+      end
+    end
+
+    def with_failing_instance(target_class, method)
+      allow_any_instance_of(target_class)
+        .to receive(method) { raise 'Some error' }
+
+      yield
+
+      allow_any_instance_of(target_class).to receive(method).and_call_original
+    end
+
+    def with_failing(target, method)
+      allow(target).to receive(method) { raise 'Some error' }
+      yield
+      allow(target).to receive(method).and_call_original
+    end
+  end
+end