Fix and DRY specs

engines/order_management/spec/services/order_management/subscriptions/proxy_order_syncer_spec.rb

@@ -18,59 +18,51 @@ module OrderManagement
 
       describe "#sync!" do
         let(:now) { Time.zone.now }
-        let(:schedule) { create(:schedule) }
-        let(:closed_oc) { # Closed
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now - 1.minute,
-                                      orders_close_at: now)
+        let(:schedule) { create(:schedule, order_cycles: [oc]) }
+
+        let(:closed_oc) {
+          create(:simple_order_cycle, orders_open_at: now - 1.minute, orders_close_at: now)
         }
         let(:open_oc_closes_before_begins_at_oc) { # Open, but closes before begins at
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now - 1.minute,
-                                      orders_close_at: now + 59.seconds)
+          create(:simple_order_cycle, orders_open_at: now - 1.minute, orders_close_at: now + 59.seconds)
         }
         let(:open_oc) { # Open & closes between begins at and ends at
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now - 1.minute,
-                                      orders_close_at: now + 90.seconds)
+          create(:simple_order_cycle, orders_open_at: now - 1.minute, orders_close_at: now + 90.seconds)
         }
         let(:upcoming_closes_before_begins_at_oc) { # Upcoming, but closes before begins at
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now + 30.seconds,
-                                      orders_close_at: now + 59.seconds)
+          create(:simple_order_cycle, orders_open_at: now + 30.seconds, orders_close_at: now + 59.seconds)
         }
         let(:upcoming_closes_on_begins_at_oc) { # Upcoming & closes on begins at
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now + 30.seconds,
-                                      orders_close_at: now + 1.minute)
+          create(:simple_order_cycle, orders_open_at: now + 30.seconds, orders_close_at: now + 1.minute)
         }
         let(:upcoming_closes_on_ends_at_oc) { # Upcoming & closes on ends at
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now + 30.seconds,
-                                      orders_close_at: now + 2.minutes)
+          create(:simple_order_cycle, orders_open_at: now + 30.seconds, orders_close_at: now + 2.minutes)
         }
         let(:upcoming_closes_after_ends_at_oc) { # Upcoming & closes after ends at
-          create(:simple_order_cycle, schedules: [schedule],
-                                      orders_open_at: now + 30.seconds,
-                                      orders_close_at: now + 121.seconds)
+          create(:simple_order_cycle, orders_open_at: now + 30.seconds, orders_close_at: now + 121.seconds)
         }
+
         let(:subscription) {
-          build(:subscription, schedule: schedule,
-                               begins_at: now + 1.minute,
-                               ends_at: now + 2.minutes)
+          build(:subscription, begins_at: now + 1.minute, ends_at: now + 2.minutes)
         }
         let(:proxy_orders) { subscription.reload.proxy_orders }
         let(:order_cycles) { proxy_orders.map(&:order_cycle) }
         let(:syncer) { ProxyOrderSyncer.new(subscription) }
 
         context "when the subscription is not persisted" do
-          before do
-            oc # Ensure oc is created before we attempt to sync
-            expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(0)
+          let(:schedule) { create(:schedule, order_cycles: [oc]) }
+          let(:subscription) do
+            build(
+              :subscription,
+              begins_at: now + 1.minute,
+              ends_at: now + 2.minutes,
+              schedule: schedule
+            )
           end
 
           context "and the schedule includes a closed oc (ie. closed before opens_at)" do
-            let(:oc) { closed_oc }
+            let!(:oc) { closed_oc }
+
             it "does not create a new proxy order for that oc" do
               expect{ subscription.save! }.to_not change(ProxyOrder, :count).from(0)
               expect(order_cycles).to_not include oc
@@ -78,7 +70,8 @@ module OrderManagement
           end
 
           context "and the schedule includes an open oc that closes before begins_at" do
-            let(:oc) { open_oc_closes_before_begins_at_oc }
+            let!(:oc) { open_oc_closes_before_begins_at_oc }
+
             it "does not create a new proxy order for that oc" do
               expect{ subscription.save! }.to_not change(ProxyOrder, :count).from(0)
               expect(order_cycles).to_not include oc
@@ -86,15 +79,19 @@ module OrderManagement
           end
 
           context "and the schedule has an open OC that closes between begins_at and ends_at" do
-            let(:oc) { open_oc }
+            let!(:oc) { open_oc }
+
             it "creates a new proxy order for that oc" do
+              syncer.sync!
+
               expect{ subscription.save! }.to change(ProxyOrder, :count).from(0).to(1)
-              expect(order_cycles).to include oc
+              expect(subscription.reload.proxy_orders.map(&:order_cycle)).to include oc
             end
           end
 
           context "and the schedule includes upcoming oc that closes before begins_at" do
-            let(:oc) { upcoming_closes_before_begins_at_oc }
+            let!(:oc) { upcoming_closes_before_begins_at_oc }
+
             it "does not create a new proxy order for that oc" do
               expect{ subscription.save! }.to_not change(ProxyOrder, :count).from(0)
               expect(order_cycles).to_not include oc
@@ -102,23 +99,50 @@ module OrderManagement
           end
 
           context "and the schedule includes upcoming oc that closes on begins_at" do
-            let(:oc) { upcoming_closes_on_begins_at_oc }
+            let!(:oc) { upcoming_closes_on_begins_at_oc }
+
+            let(:schedule) { create(:schedule, order_cycles: [oc]) }
+            let(:subscription) do
+              build(
+                :subscription,
+                begins_at: now + 1.minute,
+                ends_at: now + 2.minutes,
+                schedule: schedule
+              )
+            end
+            let(:syncer) { ProxyOrderSyncer.new(subscription) }
+
             it "creates a new proxy order for that oc" do
+              syncer.sync!
+
               expect{ subscription.save! }.to change(ProxyOrder, :count).from(0).to(1)
-              expect(order_cycles).to include oc
+              expect(subscription.reload.proxy_orders.map(&:order_cycle)).to include oc
             end
           end
 
           context "and the schedule includes upcoming oc that closes after ends_at" do
-            let(:oc) { upcoming_closes_on_ends_at_oc }
+            let!(:oc) { upcoming_closes_on_ends_at_oc }
+
             it "creates a new proxy order for that oc" do
+              schedule = create(:schedule, order_cycles: [oc])
+              subscription = build(
+                :subscription,
+                begins_at: now + 1.minute,
+                ends_at: now + 2.minutes,
+                schedule: schedule
+              )
+
+              syncer = ProxyOrderSyncer.new(subscription)
+              syncer.sync!
+
               expect{ subscription.save! }.to change(ProxyOrder, :count).from(0).to(1)
-              expect(order_cycles).to include oc
+              expect(subscription.reload.proxy_orders.map(&:order_cycle)).to include oc
             end
           end
 
           context "and the schedule includes upcoming oc that closes after ends_at" do
-            let(:oc) { upcoming_closes_after_ends_at_oc }
+            let!(:oc) { upcoming_closes_after_ends_at_oc }
+
             it "does not create a new proxy order for that oc" do
               expect{ subscription.save! }.to_not change(ProxyOrder, :count).from(0)
               expect(order_cycles).to_not include oc
@@ -212,7 +236,19 @@ module OrderManagement
 
                 context "and the oc is open and closes between begins_at and ends_at" do
                   let(:oc) { open_oc }
+
                   it "keeps the proxy order" do
+                    schedule = create(:schedule, order_cycles: [oc])
+                    subscription = build(
+                      :subscription,
+                      begins_at: now + 1.minute,
+                      ends_at: now + 2.minutes,
+                      schedule: schedule
+                    )
+
+                    syncer = ProxyOrderSyncer.new(subscription)
+                    syncer.sync!
+
                     expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(1)
                     expect(proxy_orders).to include proxy_order
                   end
@@ -228,7 +264,19 @@ module OrderManagement
 
                 context "and the oc is upcoming and closes on begins_at" do
                   let(:oc) { upcoming_closes_on_begins_at_oc }
+
                   it "keeps the proxy order" do
+                    schedule = create(:schedule, order_cycles: [oc])
+                    subscription = build(
+                      :subscription,
+                      begins_at: now + 1.minute,
+                      ends_at: now + 2.minutes,
+                      schedule: schedule
+                    )
+
+                    syncer = ProxyOrderSyncer.new(subscription)
+                    syncer.sync!
+
                     expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(1)
                     expect(proxy_orders).to include proxy_order
                   end
@@ -236,7 +284,19 @@ module OrderManagement
 
                 context "and the oc is upcoming and closes on ends_at" do
                   let(:oc) { upcoming_closes_on_ends_at_oc }
+
                   it "keeps the proxy order" do
+                    schedule = create(:schedule, order_cycles: [oc])
+                    subscription = build(
+                      :subscription,
+                      begins_at: now + 1.minute,
+                      ends_at: now + 2.minutes,
+                      schedule: schedule
+                    )
+
+                    syncer = ProxyOrderSyncer.new(subscription)
+                    syncer.sync!
+
                     expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(1)
                     expect(proxy_orders).to include proxy_order
                   end
@@ -376,8 +436,20 @@ module OrderManagement
           end
 
           context "when a proxy order does not exist" do
+            let(:schedule) { create(:schedule, order_cycles: [oc]) }
+            let(:subscription) do
+              create(
+                :subscription,
+                begins_at: now + 1.minute,
+                ends_at: now + 2.minutes,
+                schedule: schedule
+              )
+            end
+            let(:syncer) { ProxyOrderSyncer.new(subscription) }
+
             context "and the schedule includes a closed oc (ie. closed before opens_at)" do
               let!(:oc) { closed_oc }
+
               it "does not create a new proxy order for that oc" do
                 expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(0)
                 expect(order_cycles).to_not include oc
@@ -386,6 +458,7 @@ module OrderManagement
 
             context "and the schedule includes an open oc that closes before begins_at" do
               let(:oc) { open_oc_closes_before_begins_at_oc }
+
               it "does not create a new proxy order for that oc" do
                 expect{ subscription.save! }.to_not change(ProxyOrder, :count).from(0)
                 expect(order_cycles).to_not include oc
@@ -394,14 +467,16 @@ module OrderManagement
 
             context "and the schedule has an open oc that closes between begins_at and ends_at" do
               let!(:oc) { open_oc }
+
               it "creates a new proxy order for that oc" do
                 expect{ syncer.sync! }.to change(ProxyOrder, :count).from(0).to(1)
-                expect(order_cycles).to include oc
+                expect(subscription.reload.proxy_orders.map(&:order_cycle)).to include oc
               end
             end
 
             context "and the schedule includes upcoming oc that closes before begins_at" do
               let!(:oc) { upcoming_closes_before_begins_at_oc }
+
               it "does not create a new proxy order for that oc" do
                 expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(0)
                 expect(order_cycles).to_not include oc
@@ -410,22 +485,25 @@ module OrderManagement
 
             context "and the schedule includes upcoming oc that closes on begins_at" do
               let!(:oc) { upcoming_closes_on_begins_at_oc }
+
               it "creates a new proxy order for that oc" do
                 expect{ syncer.sync! }.to change(ProxyOrder, :count).from(0).to(1)
-                expect(order_cycles).to include oc
+                expect(subscription.reload.proxy_orders.map(&:order_cycle)).to include oc
               end
             end
 
             context "and the schedule includes upcoming oc that closes on ends_at" do
               let!(:oc) { upcoming_closes_on_ends_at_oc }
+
               it "creates a new proxy order for that oc" do
                 expect{ syncer.sync! }.to change(ProxyOrder, :count).from(0).to(1)
-                expect(order_cycles).to include oc
+                expect(subscription.reload.proxy_orders.map(&:order_cycle)).to include oc
               end
             end
 
             context "and the schedule includes upcoming oc that closes after ends_at" do
               let!(:oc) { upcoming_closes_after_ends_at_oc }
+
               it "does not create a new proxy order for that oc" do
                 expect{ syncer.sync! }.to_not change(ProxyOrder, :count).from(0)
                 expect(order_cycles).to_not include oc