light-service-ext 0.1.1 → 0.1.2

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

@@ -0,0 +1,189 @@
+# rubocop:disable Metrics/ModuleLength
+module LightServiceExt
+  RSpec.describe ApplicationContext do
+    let(:input) { { key: 'some-value' } }
+    let(:key) { :key }
+    let(:value) { 'some-value' }
+
+    subject(:ctx) { described_class.make_with_defaults(input) }
+
+    describe '#add_errors!' do
+      before { allow(ctx).to receive(:fail_and_return!) }
+
+      it 'fails the context' do
+        ctx.add_errors!(key => value)
+
+        expect(ctx).to have_received(:fail_and_return!)
+      end
+
+      it 'adds errors to context' do
+        ctx.add_errors!(key => value)
+
+        expect(ctx.errors).to eql(key => value)
+      end
+
+      it 'updates older values' do
+        ctx.add_errors!(key => value)
+
+        ctx.add_errors!(key => 'other-value')
+
+        expect(ctx.errors).to eql(key => 'other-value')
+      end
+
+      it 'preserves other keys' do
+        ctx.add_errors!(key => value)
+
+        ctx.add_errors!(other_key: 'other-value')
+
+        expect(ctx.errors).to include(key => value, :other_key => 'other-value')
+      end
+    end
+
+    describe '#add_errors' do
+      before { allow(ctx).to receive(:fail_and_return!) }
+
+      it 'does not fail the context' do
+        ctx.add_errors(key => value)
+
+        expect(ctx).not_to have_received(:fail_and_return!)
+      end
+
+      it 'adds errors to context' do
+        ctx.add_errors(key => value)
+
+        expect(ctx.errors).to eql(key => value)
+      end
+
+      it 'updates older values' do
+        ctx.add_errors(key => value)
+
+        ctx.add_errors(key => 'other-value')
+
+        expect(ctx.errors).to eql(key => 'other-value')
+      end
+
+      it 'preserves other keys' do
+        ctx.add_errors(key => value)
+
+        ctx.add_errors(other_key: 'other-value')
+
+        expect(ctx.errors).to include(key => value, :other_key => 'other-value')
+      end
+    end
+
+    describe '#add_params' do
+      it 'adds params to context' do
+        ctx.add_params(key => value)
+
+        expect(ctx.params).to eql(key => value)
+      end
+
+      it 'updates older values' do
+        ctx.add_params(key => value)
+
+        ctx.add_params(key => 'other-value')
+
+        expect(ctx.params).to eql(key => 'other-value')
+      end
+
+      it 'preserves other keys' do
+        ctx.add_params(key => value)
+
+        ctx.add_params(other_key: 'other-value')
+
+        expect(ctx.params).to include(key => value, :other_key => 'other-value')
+      end
+    end
+
+    describe '#add_internal_only' do
+      it 'adds params to context' do
+        ctx.add_internal_only(key => value)
+
+        expect(ctx.internal_only).to include(key => value)
+      end
+
+      it 'updates older values' do
+        ctx.add_internal_only(key => value)
+
+        ctx.add_internal_only(key => 'other-value')
+
+        expect(ctx.internal_only).to include(key => 'other-value')
+      end
+
+      it 'preserves other keys' do
+        ctx.add_internal_only(key => value)
+
+        ctx.add_internal_only(other_key: 'other-value')
+
+        expect(ctx.internal_only).to include(key => value, :other_key => 'other-value')
+      end
+    end
+
+    describe '.make_with_defaults' do
+      let(:input) { { key: 'some-value' } }
+      let(:overrides) { {} }
+
+      subject(:ctx_with_defaults) { described_class.make_with_defaults(input, overrides) }
+
+      context 'with non symbolized input keys' do
+        let(:input) { { "key" => 'some-value' } }
+
+        it 'symbolizes input attr keys' do
+          expect(ctx_with_defaults[:input].keys).to include(:key)
+        end
+      end
+
+      it 'returns context with default attrs' do
+        expect(ctx_with_defaults.keys).to match_array(%i[input
+                                                         errors
+                                                         params
+                                                         successful_actions
+                                                         api_responses
+                                                         allow_raise_on_failure
+                                                         internal_only])
+
+        expect(ctx_with_defaults[:input]).to eql(input)
+      end
+
+      describe 'overrideable attrs' do
+        { errors: { key: 'some-error' },
+          params: { key: 'value' },
+          allow_raise_on_failure: false }.each_pair do |overridable_key, value|
+          it "allows for default #{overridable_key.inspect} to be changed" do
+            ctx_with_defaults = described_class.make_with_defaults(input, **{ overridable_key => value })
+            expect(ctx_with_defaults[overridable_key]).to eql(value)
+          end
+        end
+
+        context 'with successful_actions set' do
+          subject(:ctx_with_defaults) do
+            described_class.make_with_defaults(input, successful_actions: ['some-action-class-name'])
+          end
+
+          it 'prevents successful_actions to change from default' do
+            expect(ctx_with_defaults[:successful_actions]).to be_empty
+          end
+        end
+
+        context 'with api_responses set' do
+          subject(:ctx_with_defaults) do
+            described_class.make_with_defaults(input, api_responses: ['some-api-response'])
+          end
+
+          it 'prevents successful_actions to change from default' do
+            expect(ctx_with_defaults[:api_responses]).to be_empty
+          end
+        end
+
+        context 'with unexpected override' do
+          subject(:ctx_with_defaults) { described_class.make_with_defaults(input, unknown_key: 'some-value') }
+
+          it 'prevents successful_actions to change from default' do
+            expect(ctx_with_defaults.keys).not_to include(:unknown_key)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/spec/{light_service_ext → light-service-ext}/application_organizer_spec.rb

@@ -27,8 +27,15 @@ module LightServiceExt
     it 'adds inputted data as input key value pair' do
       ctx = subject_class.call(input)
 
-      expect(ctx.keys).to match_array(%i[api_responses errors input params allow_raise_on_failure
-                                         successful_actions])
+      expect(ctx.keys).to match_array(%i[
+                                        api_responses
+                                        errors
+                                        input
+                                        params
+                                        allow_raise_on_failure
+                                        successful_actions
+                                        internal_only
+                                      ])
       expect(ctx[:input]).to eql(input)
     end
 

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

@@ -0,0 +1,66 @@
+module LightServiceExt
+  RSpec.describe Configuration do
+    let(:error_class) { ArgumentError }
+    let(:default_error_class) { EncodingError }
+
+    subject(:config) { described_class.new }
+
+    describe '#new' do
+      context 'with non fatal error classes' do
+        before do
+          config.non_fatal_error_classes = [error_class]
+        end
+
+        describe '#non_fatal_error_classes' do
+          it 'returns set fatal error classes' do
+            expect(config.non_fatal_error_classes).to match_array([error_class])
+          end
+        end
+      end
+
+      context 'with default non fatal errors' do
+        before do
+          described_class.configure do |config|
+            config.default_non_fatal_error_classes = [default_error_class]
+          end
+        end
+
+        describe '#default_non_fatal_error_classes' do
+          it 'returns set non fatal error classes' do
+            expect(config.default_non_fatal_error_classes).to match_array([default_error_class])
+          end
+        end
+      end
+
+      context 'with default and non default non fatal errors' do
+        before do
+          described_class.configure do |config|
+            config.non_fatal_error_classes = [error_class, default_error_class, nil]
+            config.default_non_fatal_error_classes = [default_error_class]
+          end
+        end
+
+        describe '#non_fatal_errors' do
+          it 'returns non duplicate error classes' do
+            expect(config.non_fatal_errors).to match_array([error_class, default_error_class].map(&:to_s))
+          end
+        end
+      end
+
+      describe '#allow_raise_on_failure' do
+        it 'returns false' do
+          expect(config.allow_raise_on_failure?).to be_truthy
+        end
+
+        context 'with allow raise on failure unset' do
+          it 'returns true' do
+            described_class.configure { |config| config.allow_raise_on_failure = false }
+
+            expect(config.allow_raise_on_failure?).to be_falsey
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/{light_service_ext → light-service-ext}/error_info_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe LightServiceExt::ErrorInfo do
   let(:value) { 'some-value' }
   let(:message_override) { nil }
   let(:message) { 'some-error' }
-  let(:fatal) { nil }
+  let(:fatal) { false }
   let(:backtrace) { ['some-backtrace-item'] }
   let(:error) { StandardError.new(message) }
   let(:error_info_class) { Class.new(described_class) }
@@ -53,8 +53,6 @@ RSpec.describe LightServiceExt::ErrorInfo do
     context 'with non fatal error' do
       let(:error) { ArgumentError.new(message) }
 
-      before { error_info_class.non_fatal_errors = [ArgumentError] }
-
       context 'with fatal passed as arg' do
         let(:fatal) { true }
 
@@ -63,8 +61,20 @@ RSpec.describe LightServiceExt::ErrorInfo do
         end
       end
 
-      it 'returns false' do
-        expect(instance.fatal_error?).to be_falsey
+      context 'with error set as non fatal' do
+        before { LightServiceExt.configure { |c| c.non_fatal_error_classes = [ArgumentError] } }
+
+        it 'returns false' do
+          expect(instance.fatal_error?).to be_falsey
+        end
+
+        context 'with fatal passed as arg' do
+          let(:fatal) { true }
+
+          it 'returns true' do
+            expect(instance.fatal_error?).to be_truthy
+          end
+        end
       end
     end
   end
@@ -87,7 +97,7 @@ RSpec.describe LightServiceExt::ErrorInfo do
     subject(:hash) { instance.to_h }
 
     it 'returns custom key value pairs' do
-      expect(hash.keys).to match_array(%i[type message exception backtrace error fatal_error?])
+      expect(hash.keys).to match_array(%i[type message exception backtrace error errors fatal_error?])
 
       expect(hash[:type]).to eql(error.class.name)
       expect(hash[:message]).to eql(message)
@@ -95,12 +105,13 @@ RSpec.describe LightServiceExt::ErrorInfo do
       expect(hash[:backtrace]).to eql(backtrace.join)
       expect(hash[:error]).to eql(error)
       expect(hash[:fatal_error?]).to be_truthy
+      expect(hash[:errors]).to eql({ base: "some-error" })
     end
 
     context 'with non fatal error' do
       let(:error) { ArgumentError.new(message) }
 
-      before { error_info_class.non_fatal_errors = [ArgumentError] }
+      before { LightServiceExt.configure { |c| c.non_fatal_error_classes = [ArgumentError] } }
 
       it 'returns non fatal error' do
         expect(hash[:fatal_error?]).to be_falsey

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

@@ -0,0 +1,62 @@
+module LightServiceExt
+  RSpec.describe WithErrorHandler do
+    unless defined? Rails
+      module Rails
+      end
+    end
+
+    unless defined? Rails::ActiveRecordError
+      module Rails
+        class ActiveRecordError < StandardError
+          def model; end
+        end
+      end
+    end
+
+    let(:implementor_class) do
+      Class.new do
+        extend WithErrorHandler
+      end
+    end
+
+    let(:key) { :key }
+    let(:key_error) { 'invalid' }
+    let(:messages) { { key => [key_error] } }
+    let(:error_message) { 'some-error' }
+    let(:errors) { OpenStruct.new(messages: messages) }
+    let(:model) { OpenStruct.new(errors: errors) }
+    let(:results_ctx_proc) { -> { ApplicationContext.make_with_defaults } }
+    let(:ctx) { ApplicationContext.make_with_defaults }
+    let(:error) { Rails::ActiveRecordError.new(error_message) }
+
+    before { allow(LightServiceExt.config.logger).to receive(:error) }
+
+    describe '.with_error_handler' do
+      subject(:errors_handled_ctx) do
+        implementor_class.with_error_handler(ctx: ctx, &results_ctx_proc)
+      end
+
+      context 'with active record error' do
+        let(:results_ctx_proc) { -> { raise error } }
+
+        context 'with error including model' do
+          before { allow(error).to receive(:model) { model } }
+
+          it 'adds model errors' do
+            expect(errors_handled_ctx.failure?).to be_truthy
+            expect(errors_handled_ctx.errors).to eql({ key => key_error })
+            expect(errors_handled_ctx.internal_only[:error_info]).to be_an_instance_of(ErrorInfo)
+            expect(LightServiceExt.config.logger).to have_received(:error)
+          end
+        end
+
+        it 'adds errors to context' do
+          expect(errors_handled_ctx.failure?).to be_truthy
+          expect(errors_handled_ctx.errors).to eql({ base: error_message })
+          expect(errors_handled_ctx.internal_only[:error_info]).to be_an_instance_of(ErrorInfo)
+          expect(LightServiceExt.config.logger).to have_received(:error)
+        end
+      end
+    end
+  end
+end

data/spec/light_service_ext_spec.rb

@@ -2,6 +2,72 @@
 
 RSpec.describe LightServiceExt do
   it "has a version number" do
-    expect(LightServiceExt::VERSION).not_to be_nil
+    expect(described_class::VERSION).not_to be_nil
+  end
+
+  describe '.configure' do
+    subject(:config) { described_class.configuration }
+
+    let(:error_class) { ArgumentError }
+    let(:default_error_class) { EncodingError }
+
+    after do
+      # rubocop:disable Style/ClassVars
+      described_class.class_variable_set(:@@configuration, described_class::Configuration.new)
+      # rubocop:enable Style/ClassVars
+    end
+
+    context 'with non fatal error classes' do
+      before do
+        described_class.configure do |config|
+          config.non_fatal_error_classes = [error_class]
+        end
+      end
+
+      describe '#non_fatal_error_classes' do
+        it 'returns set fatal error classes' do
+          expect(config.non_fatal_error_classes).to match_array([error_class])
+        end
+      end
+    end
+
+    context 'with default non fatal errors' do
+      before do
+        described_class.configure do |config|
+          config.default_non_fatal_error_classes = [default_error_class]
+        end
+      end
+
+      describe '#default_non_fatal_error_classes' do
+        it 'returns set non fatal error classes' do
+          expect(config.default_non_fatal_error_classes).to match_array([default_error_class])
+        end
+      end
+    end
+
+    context 'with default and non default non fatal errors' do
+      before do
+        described_class.configure do |config|
+          config.non_fatal_error_classes = [error_class, default_error_class, nil]
+          config.default_non_fatal_error_classes = [default_error_class]
+        end
+      end
+
+      describe '#non_fatal_errors' do
+        it 'returns non duplicate error classes' do
+          expect(config.non_fatal_errors).to match_array([error_class, default_error_class].map(&:to_s))
+        end
+      end
+    end
+
+    describe '#allow_raise_on_failure' do
+      context 'with allow raise on failure unset' do
+        it 'returns true' do
+          described_class.configure { |config| config.allow_raise_on_failure = false }
+
+          expect(config.allow_raise_on_failure?).to be_falsey
+        end
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 require File.join(__dir__, "..", 'dev', 'setup')
+require Pathname.new(__dir__).realpath.join('coverage_helper').to_s
 
-require 'coverage_helper'
 require 'light-service/testing'
 
-require "light-service-ext"
-
 RSpec.configure do |config|
+  config.before do
+    # rubocop:disable Style/ClassVars
+    LightServiceExt.class_variable_set(:@@configuration, LightServiceExt::Configuration.new)
+    # rubocop:enable Style/ClassVars
+  end
+
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = ".rspec_status"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service-ext
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Desmond O'Leary
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-15 00:00:00.000000000 Z
+date: 2023-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: light-service
@@ -78,6 +78,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.6.3
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -164,24 +178,28 @@ files:
 - lib/light-service-ext/application_organizer.rb
 - lib/light-service-ext/application_validator_action.rb
 - lib/light-service-ext/around_action_execute_extension.rb
+- lib/light-service-ext/configuration.rb
 - lib/light-service-ext/constants.rb
 - lib/light-service-ext/context_error.rb
 - lib/light-service-ext/error_info.rb
 - lib/light-service-ext/regex.rb
 - lib/light-service-ext/version.rb
+- lib/light-service-ext/with_error_handler.rb
 - light-service-ext.gemspec
 - sig/light_service_ext.rbs
 - spec/coverage_helper.rb
-- spec/light_service_ext/all_actions_complete_action_spec.rb
-- spec/light_service_ext/application_action_spec.rb
-- spec/light_service_ext/application_context_spec.rb
-- spec/light_service_ext/application_contract_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/context_error_spec.rb
-- spec/light_service_ext/error_info_spec.rb
-- spec/light_service_ext/regex_spec.rb
+- spec/light-service-ext/all_actions_complete_action_spec.rb
+- spec/light-service-ext/application_action_spec.rb
+- spec/light-service-ext/application_context_spec.rb
+- spec/light-service-ext/application_contract_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
+- spec/light-service-ext/regex_spec.rb
+- spec/light-service-ext/with_error_handler_spec.rb
 - spec/light_service_ext_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/omnitech-solutions/light-service-ext
@@ -212,15 +230,17 @@ specification_version: 4
 summary: Extends light-service with opinionated functionality
 test_files:
 - spec/coverage_helper.rb
-- spec/light_service_ext/all_actions_complete_action_spec.rb
-- spec/light_service_ext/application_action_spec.rb
-- spec/light_service_ext/application_context_spec.rb
-- spec/light_service_ext/application_contract_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/context_error_spec.rb
-- spec/light_service_ext/error_info_spec.rb
-- spec/light_service_ext/regex_spec.rb
+- spec/light-service-ext/all_actions_complete_action_spec.rb
+- spec/light-service-ext/application_action_spec.rb
+- spec/light-service-ext/application_context_spec.rb
+- spec/light-service-ext/application_contract_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
+- spec/light-service-ext/regex_spec.rb
+- spec/light-service-ext/with_error_handler_spec.rb
 - spec/light_service_ext_spec.rb
 - spec/spec_helper.rb

data/spec/light_service_ext/application_action_spec.rb

@@ -1,77 +0,0 @@
-module LightServiceExt
-  RSpec.describe ApplicationAction do
-    FakeApplicationAction = Class.new(described_class) do
-      executed do |context|
-        value = context.dig(:input, :callback).call
-        add_params(context, value: value)
-      end
-    end
-
-    let(:organizer_class) do
-      Class.new(ApplicationOrganizer) do
-        def self.steps
-          [FakeApplicationAction]
-        end
-      end
-    end
-
-    let(:value) { 'some-value' }
-    let(:callback) { -> { value } }
-    let(:input) { { callback: callback } }
-    let(:ctx) do
-      LightService::Testing::ContextFactory
-        .make_from(organizer_class)
-        .for(FakeApplicationAction)
-        .with(callback: callback)
-    end
-
-    subject(:context) do
-      FakeApplicationAction.execute(ctx)
-    end
-
-    it 'adds value returned by callback to params' do
-      expect(context.keys).to include(:input, :errors, :params)
-
-      expect(context[:params]).to eql({ value: value })
-    end
-
-    describe '.add_params' do
-      let(:params) { { key: 'some-value' } }
-      let(:ctx) { ApplicationContext.make_with_defaults }
-
-      subject(:params_added) { described_class.add_params(ctx, **params) }
-
-      it 'adds key value pairs to context params' do
-        params_added
-
-        expect(ctx[:params].keys).to include(:key)
-      end
-    end
-
-    describe '.add_errors' do
-      let(:ctx) { ApplicationContext.make_with_defaults }
-
-      subject(:errors_added) { described_class.add_errors(ctx, **errors) }
-
-      context 'without errors' do
-        let(:errors) { {} }
-
-        it 'does not raise error' do
-          expect { errors_added }.not_to raise_error
-
-          expect(ctx[:errors]).to be_empty
-        end
-      end
-
-      context 'with errors' do
-        let(:errors) { { key: 'not-found' } }
-
-        it 'raises jump when failed error and adds errors to context' do
-          expect { errors_added }.to raise_error UncaughtThrowError, 'uncaught throw :jump_when_failed'
-
-          expect(ctx[:errors].keys).to include(:key)
-        end
-      end
-    end
-  end
-end