Change Result pattern to exceptions

ecommerce/processes/lib/processes/reservation_process.rb

@@ -10,7 +10,7 @@ def call(event)
       state = build_state(event)
       case event.event_type
       when 'Ordering::OrderSubmitted'
-        order_side_effects(state) { reserve_stock(state) }
+        update_order_state(state) { reserve_stock(state) }
       when 'Fulfillment::OrderCancelled'
         release_stock(state)
       when 'Fulfillment::OrderConfirmed'
@@ -38,7 +38,7 @@ def reserve_stock(state)
       event_store.publish(event, stream_name: stream_name(state.order_id))
     end
 
-    def order_side_effects(state)
+    def update_order_state(state)
       event_store
       .within { yield }
       .subscribe(to: ReservationProcessFailed) { reject_order(state) }

rails_application/app/controllers/client/orders_controller.rb

@@ -12,12 +12,17 @@ def new
     end
 
     def create
-      Orders::SubmitService.new(order_id: params[:order_id], customer_id: cookies[:client_id]).call.then do |result|
-        result.path(:success) { redirect_to client_order_path(params[:order_id]), notice: "Your order is being submitted" }
-        result.path(:products_out_of_stock) { |unavailable_products| redirect_to edit_client_order_path(params[:order_id]),
-            alert: "Order can not be submitted! #{unavailable_products.join(", ")} not available in requested quantity!"}
-        result.path(:order_is_empty) { redirect_to edit_client_order_path(params[:order_id]), alert: "You can't submit an empty order" }
-      end
+      Orders::SubmitService.new(order_id: params[:order_id], customer_id: cookies[:client_id]).call
+    rescue Orders::OrderHasUnavailableProducts => e
+      unavailable_products = e.unavailable_products.join(", ")
+      redirect_to edit_client_order_path(params[:order_id]), alert: "Order can not be submitted! #{unavailable_products} not available in requested quantity!"
+    rescue Ordering::Order::IsEmpty
+      redirect_to edit_client_order_path(params[:order_id]), alert: "You can't submit an empty order"
+    rescue StandardError => e
+      byebug
+      1
+    else
+      redirect_to client_order_path(params[:order_id]), notice: "Your order is being submitted"
     end
 
     def show

rails_application/app/controllers/orders_controller.rb

@@ -74,13 +74,19 @@ def remove_item
   end
 
   def create
-    Orders::SubmitService.new(order_id: params[:order_id], customer_id: params[:customer_id]).call.then do |result|
-      result.path(:success) { redirect_to order_path(params[:order_id]), notice: "Your order is being submitted" }
-      result.path(:products_out_of_stock) { |unavailable_products| redirect_to edit_order_path(params[:order_id]),
-          alert: "Order can not be submitted! #{unavailable_products.join(", ")} not available in requested quantity!"}
-      result.path(:order_is_empty) { redirect_to edit_order_path(params[:order_id]), alert: "You can't submit an empty order" }
-      result.path(:customer_not_exists) { redirect_to order_path(params[:order_id]), alert: "Order can not be submitted! Customer does not exist." }
-    end
+    Orders::SubmitService.new(order_id: params[:order_id], customer_id: params[:customer_id]).call
+  rescue Orders::OrderHasUnavailableProducts => e
+    unavailable_products = e.unavailable_products.join(", ")
+    redirect_to edit_order_path(params[:order_id]), alert: "Order can not be submitted! #{unavailable_products} not available in requested quantity!"
+  rescue Ordering::Order::IsEmpty
+    redirect_to edit_order_path(params[:order_id]), alert: "You can't submit an empty order"
+  rescue Crm::Customer::NotExists
+    redirect_to order_path(params[:order_id]), alert: "Order can not be submitted! Customer does not exist."
+  rescue StandardError => e
+    byebug
+    1
+  else
+    redirect_to order_path(params[:order_id]), notice: "Your order is being submitted"
   end
 
   def expire

rails_application/app/services/orders/submit_service.rb

@@ -1,31 +1,28 @@
 module Orders
+  class OrderHasUnavailableProducts < StandardError
+    attr_reader :unavailable_products
+
+    def initialize(unavailable_products)
+      @unavailable_products = unavailable_products
+    end
+  end
+
   class SubmitService < ApplicationService
     def initialize(order_id:, customer_id:)
       @order_id = order_id
       @customer_id = customer_id
     end
 
     def call
-      success = true
-      unavailable_products = nil
-
       event_store
         .within { submit_order }
         .subscribe(to: Processes::ReservationProcessFailed) do |event|
-          success = false
           unavailable_products = Products::Product.where(id: event.data.fetch(:unavailable_products)).pluck(:name)
+          raise OrderHasUnavailableProducts.new(unavailable_products)
         end
         .call
 
-      if success
-        Result.new(:success)
-      else
-        Result.new(:products_out_of_stock, unavailable_products)
-      end
-      rescue Ordering::Order::IsEmpty
-        Result.new(:order_is_empty)
-      rescue Crm::Customer::NotExists
-        Result.new(:customer_not_exists)
+      true
     end
 
     private

rails_application/test/services/orders/submit_service_test.rb

@@ -13,9 +13,7 @@ def test_successful_order_submission
       prepare_product(product_id, "Async Remote", 49)
       run_command(Ordering::AddItemToBasket.new(order_id: order_id, product_id: product_id))
 
-      result = Orders::SubmitService.new(order_id: order_id, customer_id: customer_id).call
-
-      assert_equal result.status, :success
+      assert_equal true, Orders::SubmitService.new(order_id: order_id, customer_id: customer_id).call
     end
 
     def test_order_submission_with_unavailable_products
@@ -32,32 +30,11 @@ def test_order_submission_with_unavailable_products
       prepare_product(another_product_id, "Fearless Refactoring", 49)
       run_command(Ordering::AddItemToBasket.new(order_id: order_id, product_id: another_product_id))
 
-      result = Orders::SubmitService.new(order_id: order_id, customer_id: customer_id).call
-
-      assert_equal result.status, :products_out_of_stock
-      assert_equal result.args, [["Async Remote"]]
-    end
-
-    def test_order_submission_with_empty_order
-      order_id = SecureRandom.uuid
-      customer_id = SecureRandom.uuid
-
-      result = Orders::SubmitService.new(order_id: order_id, customer_id: customer_id).call
-
-      assert_equal result.status, :order_is_empty
-    end
-
-    def test_order_submission_with_non_existing_customer
-      order_id = SecureRandom.uuid
-      customer_id = SecureRandom.uuid
-      product_id = SecureRandom.uuid
-
-      prepare_product(product_id, "Async Remote", 49)
-      run_command(Ordering::AddItemToBasket.new(order_id: order_id, product_id: product_id))
-
-      result = Orders::SubmitService.new(order_id: order_id, customer_id: customer_id).call
+      error = assert_raises(Orders::OrderHasUnavailableProducts) do
+        Orders::SubmitService.new(order_id: order_id, customer_id: customer_id).call
+      end
 
-      assert_equal result.status, :customer_not_exists
+      assert_equal ["Async Remote"], error.unavailable_products
     end
 
     private