Integrate standing order summarizer into placement job

app/jobs/standing_order_placement_job.rb

@@ -1,4 +1,15 @@
+require 'open_food_network/standing_order_summarizer'
+
 class StandingOrderPlacementJob
+  attr_accessor :summarizer
+
+  delegate :record_order, :record_success, :record_issue, to: :summarizer
+  delegate :record_failure, :send_placement_summary_emails, to: :summarizer
+
+  def initialize
+    @summarizer = OpenFoodNetwork::StandingOrderSummarizer.new
+  end
+
   def perform
     ids = proxy_orders.pluck(:id)
     proxy_orders.update_all(placed_at: Time.zone.now)
@@ -6,6 +17,8 @@ class StandingOrderPlacementJob
       proxy_order.initialise_order!
       process(proxy_order.order)
     end
+
+    send_placement_summary_emails
   end
 
   private
@@ -18,11 +31,14 @@ class StandingOrderPlacementJob
   end
 
   def process(order)
-    return if order.completed?
+    record_order(order)
+    return record_issue(:complete, order) if order.completed?
+
     changes = cap_quantity_and_store_changes(order)
     if order.line_items.where('quantity > 0').empty?
       return send_empty_email(order, changes)
     end
+
     move_to_completion(order)
     send_placement_email(order, changes)
   end
@@ -43,7 +59,7 @@ class StandingOrderPlacementJob
   def move_to_completion(order)
     until order.completed? do order.next! end
   rescue StateMachine::InvalidTransition
-    log_completion_issue(order)
+    record_failure(order)
   end
 
   def unavailable_stock_lines_for(order)
@@ -55,17 +71,13 @@ class StandingOrderPlacementJob
   end
 
   def send_placement_email(order, changes)
-    return unless order.completed?
+    record_issue(:changes, order) if changes.present?
+    record_success(order) if changes.blank?
     StandingOrderMailer.placement_email(order, changes).deliver
   end
 
   def send_empty_email(order, changes)
+    record_issue(:empty, order)
     StandingOrderMailer.empty_email(order, changes).deliver
   end
-
-  def log_completion_issue(order)
-    line1 = "StandingOrderPlacementError: Cannot process order #{order.number} due to errors"
-    line2 = "Errors: #{order.errors.full_messages.join(', ')}"
-    Rails.logger.info("#{line1}\n#{line2}")
-  end
 end

lib/open_food_network/standing_order_summarizer.rb

@@ -16,7 +16,7 @@ module OpenFoodNetwork
       summary_for(order).record_success(order)
     end
 
-    def record_issue(type, order, message)
+    def record_issue(type, order, message=nil)
       summary_for(order).record_issue(type, order, message)
     end
 

spec/jobs/standing_order_placement_job_spec.rb

@@ -132,8 +132,9 @@ describe StandingOrderPlacementJob do
     context "when the order is already complete" do
       before { while !order.completed? do break unless order.next! end }
 
-      it "ignores it" do
+      it "records an issue and ignores it" do
         ActionMailer::Base.deliveries.clear
+        expect(job).to receive(:record_issue).with(:complete, order).once
         expect{ job.send(:process, order) }.to_not change{ order.reload.state }
         expect(order.payments.first.state).to eq "checkout"
         expect(ActionMailer::Base.deliveries.count).to be 0
@@ -170,8 +171,8 @@ describe StandingOrderPlacementJob do
         context "when progression of the order fails" do
           before { allow(order).to receive(:next) { false } }
 
-          it "logs an error" do
-            expect(Rails.logger).to receive(:info)
+          it "records a failure and does not attempt to send an email" do
+            expect(job).to receive(:record_failure).once
             job.send(:process, order)
           end
         end
@@ -179,34 +180,51 @@ describe StandingOrderPlacementJob do
     end
   end
 
-  describe "sending placement email" do
-    let(:standing_order) { create(:standing_order, with_items: true) }
-    let(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
-    let!(:order) { proxy_order.initialise_order! }
-    let(:mail_mock) { double(:mailer_mock) }
-    let(:changes) { double(:changes) }
+  describe "#send_placement_email" do
+    let!(:order) { double(:order) }
+    let(:mail_mock) { double(:mailer_mock, deliver: true) }
 
     before do
       allow(StandingOrderMailer).to receive(:placement_email) { mail_mock }
-      allow(mail_mock).to receive(:deliver)
     end
 
-    context "when the order is complete" do
-      before { while !order.completed? do break unless order.next! end }
+    context "when changes are present" do
+      let(:changes) { double(:changes) }
 
-      it "sends the email" do
+      it "logs an issue and sends the email" do
+        expect(job).to receive(:record_issue).with(:changes, order).once
         job.send(:send_placement_email, order, changes)
         expect(StandingOrderMailer).to have_received(:placement_email).with(order, changes)
         expect(mail_mock).to have_received(:deliver)
       end
     end
 
-    context "when the order is incomplete" do
-      it "does not send the email" do
+    context "when no changes are present" do
+      let(:changes) { {} }
+
+      it "logs a success and sends the email" do
+        expect(job).to receive(:record_success).with(order).once
         job.send(:send_placement_email, order, changes)
-        expect(StandingOrderMailer).to_not have_received(:placement_email)
-        expect(mail_mock).to_not have_received(:deliver)
+        expect(StandingOrderMailer).to have_received(:placement_email)
+        expect(mail_mock).to have_received(:deliver)
       end
     end
   end
+
+  describe "#send_empty_email" do
+    let!(:order) { double(:order) }
+    let(:changes) { double(:changes) }
+    let(:mail_mock) { double(:mailer_mock, deliver: true) }
+
+    before do
+      allow(StandingOrderMailer).to receive(:empty_email) { mail_mock }
+    end
+
+    it "logs an issue and sends the email" do
+      expect(job).to receive(:record_issue).with(:empty, order).once
+      job.send(:send_empty_email, order, changes)
+      expect(StandingOrderMailer).to have_received(:empty_email).with(order, changes)
+      expect(mail_mock).to have_received(:deliver)
+    end
+  end
 end