light-service-ext 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aad64b8f2360c7b9e4576bcfe6e167f10a87424392b9677ca620b973ba3dc8ef
-  data.tar.gz: 18a7ff6bde7fab9b58eb1e883fbb79cc346be9d98e9516135de3b5e6eabd570c
+  metadata.gz: ce41945d8919b3cef73709b2a43f77621fb19019d35f22b6719de3d4c4af7948
+  data.tar.gz: 1f899858676cc260d26d381a4d2c8dbb19688b3aedd666d5e3380c164bf6f495
 SHA512:
-  metadata.gz: c0f1d41f1530c3b8e9624f0c3ef360464b9a67d8c7e21893b4ecea3db8b09d19b967e7a0dbbc6d66cc1e90677186954c62ab1d734e026ca434b183d7ad3bbdc8
-  data.tar.gz: d81ae82181b451ad2330dc42ccbf33f11cab6b99a0afaa47ba77d4a8bf88bcb6903b486439be926ea408fc2dc06b8e27626843f45a69e6053c9afb4d3dd4f401
+  metadata.gz: 7a60af56510f4c620b78d97f2609c668b69fd595e6ed6f1acd50056a963ffd9a499e8843ff0147c533f184901f3e636d2e397bfc536b7eeb68af0ec19f970dee
+  data.tar.gz: e0c0bcb40521c6ea56cec36a555f1ffc6ebb11b7942b4709d616e7ce75ddb34aa79132f4396602cdacb534338e72d7f37a8e62b51f0609ad636fbae5564a18fb

data/lib/light-service-ext/application_action.rb

@@ -4,9 +4,31 @@ module LightServiceExt
   class ApplicationAction
     extend LightService::Action
 
+
     def self.inherited(base)
+      base.extend LifecycleMethods
       base.singleton_class.prepend AroundActionExecuteExtension
       super
     end
+
+    module LifecycleMethods
+      attr_writer :before_execute_block, :after_execute_block, :after_success_block, :after_failure_block
+
+      def before_execute_block
+        @before_execute_block ||= ->(_context) {}
+      end
+
+      def after_execute_block
+        @after_execute_block ||= ->(_context) {}
+      end
+
+      def after_success_block
+        @after_success_block ||= ->(_context) {}
+      end
+
+      def after_failure_block
+        @after_failure_block ||= ->(_context) {}
+      end
+    end
   end
 end

data/lib/light-service-ext/around_action_execute_extension.rb

@@ -3,10 +3,17 @@
 module LightServiceExt
   module AroundActionExecuteExtension
     def execute(context)
+      return context if context.status == Status::COMPLETE
+      self.before_execute_block.call(context)
+
       result = super(context.merge(invoked_action: self))
 
       context.merge!(result)
       context.fail! if result.errors.present?
+
+      self.after_execute_block.call(context)
+      self.after_success_block.call(context) if result.success?
+      self.after_failure_block.call(context) if result.failure?
       result
     end
   end

data/lib/light-service-ext/record_actions.rb

@@ -6,44 +6,26 @@ module LightServiceExt
 
     def self.call(context)
       with_error_handler(ctx: context) do
-        self.before_execute_block.call(context)
-
         result = yield || context
+        return context if outcomes_complete?(ctx: context, result: result)
 
-        self.after_execute_block.call(context)
-        self.after_success_block.call(context) if result.success?
-        self.after_failure_block.call(context) if result.failure?
+        invoked_action = result.invoked_action
+        return context if invoked_action.nil?
+
+        context.add_to_successful_actions(invoked_action.name)
 
-        return context if outcomes_complete?(ctx: context, result: result)
         merge_api_responses!(ctx: context, result: result)
+        context
       end
     end
 
     class << self
-      attr_writer :before_execute_block, :after_execute_block, :after_success_block, :after_failure_block
-
-      def before_execute_block
-        @before_execute_block ||= ->(_context) {}
-      end
-
-      def after_execute_block
-        @after_execute_block ||= ->(_context) {}
-      end
-
-      def after_success_block
-        @after_success_block ||= ->(_context) {}
-      end
-
-      def after_failure_block
-        @after_failure_block ||= ->(_context) {}
-      end
       def merge_api_responses!(ctx:, result:)
-        invoked_action = result.invoked_action
-        return if invoked_action.nil?
+        api_response = result.current_api_response
+        return if api_response.blank?
 
-        ctx.add_to_successful_actions(invoked_action.name)
-        ctx.add_to_api_responses(result.current_api_response)
-        ctx
+        ctx.add_to_api_responses(api_response)
+        nil
       end
 
       def outcomes_complete?(ctx:, result:)

data/lib/light-service-ext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LightServiceExt
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

data/spec/light-service-ext/application_action_spec.rb

@@ -1,19 +1,17 @@
 module LightServiceExt
   RSpec.describe ApplicationAction do
-    FakeApplicationAction = Class.new(described_class) do
-      executed do |context|
-        value = context.dig(:input, :callback).call
-        context.add_params(value: value)
-        context.add_errors!(value: value)
+    let(:fake_action) do
+      Class.new(described_class) do
+        executed do |context|
+          value = context.dig(:input, :callback).call
+          context.add_params(value: value)
+          context.add_errors!(value: value)
+        end
       end
     end
 
     let(:organizer_class) do
-      Class.new(ApplicationOrganizer) do
-        def self.steps
-          [FakeApplicationAction]
-        end
-      end
+      Class.new(ApplicationOrganizer) do end
     end
 
     let(:value) { 'some-value' }
@@ -22,18 +20,54 @@ module LightServiceExt
     let(:ctx) do
       LightService::Testing::ContextFactory
         .make_from(organizer_class)
-        .for(FakeApplicationAction)
+        .for(fake_action)
         .with(callback: callback)
     end
 
-    subject(:context) do
-      FakeApplicationAction.execute(ctx)
+    subject(:executed_ctx) { fake_action.execute(ctx) }
+
+    before do
+      allow(organizer_class).to receive(:steps) { [fake_action] }
     end
 
     it 'adds value returned by callback to params' do
-      expect(context.keys).to include(:input, :errors, :params)
+      expect(executed_ctx.keys).to include(:input, :errors, :params)
+
+      expect(executed_ctx[:params]).to eql({ value: value })
+    end
+
+    describe 'lifecycle callbacks' do
+      before do
+        allow(fake_action.before_execute_block).to receive(:call)
+        allow(fake_action.after_execute_block).to receive(:call)
+        allow(fake_action.after_success_block).to receive(:call)
+        allow(fake_action.after_failure_block).to receive(:call)
+      end
 
-      expect(context[:params]).to eql({ value: value })
+      it 'calls appropriate lifecycle callbacks' do
+        executed_ctx
+
+        expect(fake_action.before_execute_block).to have_received(:call).with(kind_of(ApplicationContext)).at_least(:once)
+        expect(fake_action.after_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
+        expect(fake_action.after_success_block).not_to have_received(:call).with(kind_of(ApplicationContext))
+        expect(fake_action.after_failure_block).to have_received(:call).at_least(:once)
+      end
+
+      context 'with failure' do
+        before do
+          allow_any_instance_of(ApplicationContext).to receive(:errors) { {} }
+          allow_any_instance_of(ApplicationContext).to receive(:success?) { true }
+        end
+
+        it 'calls appropriate lifecycle callbacks' do
+          executed_ctx
+
+          expect(fake_action.before_execute_block).to have_received(:call).with(kind_of(ApplicationContext)).at_least(:once)
+          expect(fake_action.after_execute_block).to have_received(:call).with(kind_of(ApplicationContext)).at_least(:once)
+          expect(fake_action.after_success_block).to have_received(:call).with(kind_of(ApplicationContext))
+          expect(fake_action.after_failure_block).to_not have_received(:call)
+        end
+      end
     end
   end
 end

data/spec/light-service-ext/application_context_spec.rb

@@ -361,6 +361,7 @@ module LightServiceExt
                                                         invoked_action
                                                         current_api_response
                                                         last_failed_context
+                                                        meta
                                                       ])
 
         expect(ctx_with_defaults[:input]).to eql(input)

data/spec/light-service-ext/record_actions_spec.rb

@@ -19,40 +19,6 @@ module LightServiceExt
 
       subject(:called_ctx) { described_class.call(ctx, &proc) }
 
-      describe 'lifecycle callbacks' do
-        before do
-          allow(described_class.before_execute_block).to receive(:call)
-          allow(described_class.after_execute_block).to receive(:call)
-          allow(described_class.after_success_block).to receive(:call)
-          allow(described_class.after_failure_block).to receive(:call)
-        end
-
-        it 'calls appropriate lifecycle callbacks' do
-          called_ctx
-
-          expect(described_class.before_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
-          expect(described_class.after_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
-          expect(described_class.after_success_block).to have_received(:call).with(kind_of(ApplicationContext))
-          expect(described_class.after_failure_block).not_to have_received(:call)
-        end
-
-        context 'with failure' do
-          before do
-            allow_any_instance_of(ApplicationContext).to receive(:success?) { false }
-            allow_any_instance_of(ApplicationContext).to receive(:failure?) { true }
-          end
-
-          it 'calls appropriate lifecycle callbacks' do
-            called_ctx
-
-            expect(described_class.before_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
-            expect(described_class.after_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
-            expect(described_class.after_failure_block).to have_received(:call).with(kind_of(ApplicationContext))
-            expect(described_class.after_success_block).not_to have_received(:call)
-          end
-        end
-      end
-
       it 'returns expected context' do
         expect(called_ctx.success?).to be_truthy
         expect(called_ctx.successful_actions).to be_empty

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service-ext
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Desmond O'Leary
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-24 00:00:00.000000000 Z
+date: 2023-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: light-service
@@ -205,7 +205,6 @@ files:
 - spec/light-service-ext/application_orchestrator_spec.rb
 - spec/light-service-ext/application_organizer_spec.rb
 - spec/light-service-ext/application_validator_action_spec.rb
-- spec/light-service-ext/around_action_execute_extension_spec.rb
 - spec/light-service-ext/configuration_spec.rb
 - spec/light-service-ext/context_error_spec.rb
 - spec/light-service-ext/error_info_spec.rb
@@ -249,7 +248,6 @@ test_files:
 - spec/light-service-ext/application_orchestrator_spec.rb
 - spec/light-service-ext/application_organizer_spec.rb
 - spec/light-service-ext/application_validator_action_spec.rb
-- spec/light-service-ext/around_action_execute_extension_spec.rb
 - spec/light-service-ext/configuration_spec.rb
 - spec/light-service-ext/context_error_spec.rb
 - spec/light-service-ext/error_info_spec.rb

data/spec/light-service-ext/around_action_execute_extension_spec.rb

@@ -1,56 +0,0 @@
-module LightServiceExt
-  RSpec.describe AroundActionExecuteExtension do
-    let(:fake_action) do
-      Class.new do
-        prepend AroundActionExecuteExtension
-
-        def execute(_ctx)
-          fake_resultant_ctx # HACK: to allow us to control returned value from prepended execute method
-        end
-
-        def fake_resultant_ctx; end
-      end.new
-    end
-
-    describe '#execute' do
-      let(:input) { { key: 'some-value' } }
-      let(:orig_ctx) { ApplicationContext.make_with_defaults }
-      let(:errors) { {} }
-      let(:frozen_resultant_ctx) do
-        ApplicationContext.make_with_defaults.merge({ key: 'some-value', errors: errors }).freeze
-      end
-
-      subject(:executed_ctx) { fake_action.execute(orig_ctx) }
-
-      before do
-        allow(fake_action).to receive(:fake_resultant_ctx) { frozen_resultant_ctx }
-      end
-
-      it 'returns unmodified resultant context' do
-        expect(executed_ctx).to eql(frozen_resultant_ctx)
-      end
-
-      it 'calls underlying prepended execute method' do
-        executed_ctx
-
-        expect(fake_action).to have_received(:fake_resultant_ctx)
-      end
-
-      it 'merges key value pairs from underlying execute to original context' do
-        executed_ctx
-
-        expect(orig_ctx.keys).to include(:key)
-      end
-
-      context 'with resultant ctx with errors' do
-        let(:errors) { { key: 'must be filled' } }
-
-        it 'fails original context' do
-          executed_ctx
-
-          expect(orig_ctx.failure?).to be_truthy
-        end
-      end
-    end
-  end
-end