ADD finisher service alternative break method #secure_alternative

lib/carioca/services/finisher.rb

@@ -12,6 +12,17 @@ def initialize(*arg, error_case: :status_ko)
       end
     end
 
+
+    class AlternativeCatcher < StandardError
+      attr_reader :return_case, :data
+
+      def initialize(*arg, return_case: :status_ko, data: nil)
+        super(*arg)
+        @return_case = return_case
+        @data = data
+      end
+    end
+
     # Exiter namespace
     class Finisher
       DEFAULT_FINISHERS_SPECS = {
@@ -95,12 +106,15 @@ def secure_api_return(data: nil, return_case: nil, structured: false, json: true
           data = yield if block_given?
           result = structured ? do_return(return_case:).merge({ data: }) : data
         rescue StandardError => e
-          key = e.respond_to?(:error_case) ? e.error_case : :status_ko
-          more = e.respond_to?(:error_case) ? e.message : "#{e.class} : #{e.message}"
-          result = do_return return_case: key, more:
+          key = :status_ko
+          more = "#{e.class} : #{e.message}"
+          if e.respond_to?(:error_case)
+            result = do_return(return_case: e.error_case, more: e.message)
+          elsif e.respond_to?(:return_case)
+            result = structured ? do_return(return_case: e.return_case, more: e.message).merge({ data: e.data}) : e.data
+          end
         end
         if status && structured && json
-          p result
           { status: result[:code], data: JSON.pretty_generate(JSON.parse(result.to_json)) }
         elsif json
           JSON.pretty_generate(JSON.parse(result.to_json)) if json
@@ -109,6 +123,11 @@ def secure_api_return(data: nil, return_case: nil, structured: false, json: true
         end
       end
 
+      def secure_alternative(message: , return_case: :accepted, data: )
+        raise AlternativeCatcher.new(message, return_case: return_case, data: data)
+      end
+
+
       def secure_execute!(exit_case: :success_exit)
         begin
           more = yield

samples/test.rb

@@ -182,18 +182,39 @@ def test3
 output.item 'api return, json, structured but with secure_raise'
 test = finisher.secure_api_return(return_case: :status_ok, structured: true, json: true) do
   finisher.secure_raise message: 'error !', error_case: :status_ko
-  { test: 'test'}
+  test = { test: 'test'}
+  test
 end
 puts test[:status]
 puts test[:data]
 
 output.item 'api return, json, structured'
 test = finisher.secure_api_return(return_case: :status_ok, structured: true, json: true) do
-  { test: 'test' }
+  test = { test: 'test' }
+  test
+end
+puts test[:status]
+puts test[:data]
+
+
+output.item 'api return, json, structured with alternative'
+test = finisher.secure_api_return(return_case: :status_ok, structured: true, json: true) do
+  test = { test: 'test' }
+  finisher.secure_alternative message: "test alernative", return_case: :accepted, data: test
+  test
 end
 puts test[:status]
 puts test[:data]
 
+
+output.item 'api return, json, structured with alternative'
+test = finisher.secure_api_return(return_case: :status_ok, structured: false, json: false) do
+  test = { test: 'test' }
+  finisher.secure_alternative message: "test alernative", return_case: :accepted, data: test
+  test
+end
+puts test
+
 output.item 'api return, json, structured with status=false'
 test = finisher.secure_api_return(return_case: :status_ok, structured: true, json: true, status: false) do
   { test: 'test'}

spec/carioca_spec.rb

@@ -234,6 +234,28 @@
       end
       expect(JSON.parse(result, symbolize_names: true)).to eq({:code=>200, :message=>"Status OK", :data=>"test"})
     end
+
+    it "must be possible to use Service finisher for api return, json, structured with alternative" do 
+      finisher = Carioca::Registry.get.get_service name: :finisher 
+      test = finisher.secure_api_return(return_case: :status_ok, structured: true, json: true) do
+        data = { test: 'test' }
+        finisher.secure_alternative message: "test alernative", return_case: :accepted, data: data
+        data
+      end
+      expect(test[:status]).to eq 202
+      expect(JSON.parse(test[:data], symbolize_names: true)).to eq({:code=>202, :message=>"Request accepted", :data => {:test=>"test"},:more => "test alernative"})
+    end
+
+    it "must be possible to use Service finisher for api return, no json, not structured with alternative" do 
+      finisher = Carioca::Registry.get.get_service name: :finisher 
+      test = finisher.secure_api_return(return_case: :status_ok, structured: false, json: false) do
+        data = { test: 'test' }
+        finisher.secure_alternative message: "test alernative", return_case: :accepted, data: data
+        data
+      end
+      expect(test).to eq({:test=>"test"})
+    end
+
   end
 
 end