diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml
index 4bde8eb617..0389a8b0d1 100644
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -160,7 +160,6 @@ Metrics/ModuleLength:
     - 'app/helpers/spree/admin/orders_helper.rb'
     - 'app/models/spree/order/checkout.rb'
     - 'app/models/spree/payment/processing.rb'
-    - 'engines/order_management/spec/services/order_management/subscriptions/variants_list_spec.rb'
     - 'lib/open_food_network/column_preference_defaults.rb'
     - 'spec/lib/open_food_network/address_finder_spec.rb'
     - 'spec/lib/open_food_network/order_cycle_form_applicator_spec.rb'
diff --git a/engines/order_management/spec/services/order_management/subscriptions/variants_list_spec.rb b/engines/order_management/spec/services/order_management/subscriptions/variants_list_spec.rb
index f932ad36aa..e5bccdf42b 100644
--- a/engines/order_management/spec/services/order_management/subscriptions/variants_list_spec.rb
+++ b/engines/order_management/spec/services/order_management/subscriptions/variants_list_spec.rb
@@ -2,163 +2,159 @@
 
 require "spec_helper"
 
-module OrderManagement
-  module Subscriptions
-    RSpec.describe VariantsList do
-      describe "variant eligibility for subscription" do
-        let!(:shop) { create(:distributor_enterprise) }
-        let!(:producer) { create(:supplier_enterprise) }
-        let!(:variant) { create(:variant, supplier: producer) }
+RSpec.describe OrderManagement::Subscriptions::VariantsList do
+  describe "variant eligibility for subscription" do
+    let!(:shop) { create(:distributor_enterprise) }
+    let!(:producer) { create(:supplier_enterprise) }
+    let!(:variant) { create(:variant, supplier: producer) }
 
-        let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
-        let!(:subscription) { create(:subscription, shop:, schedule:) }
-        let!(:subscription_line_item) do
-          create(:subscription_line_item, subscription:, variant:)
-        end
+    let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
+    let!(:subscription) { create(:subscription, shop:, schedule:) }
+    let!(:subscription_line_item) do
+      create(:subscription_line_item, subscription:, variant:)
+    end
 
-        let(:current_order_cycle) do
-          create(:simple_order_cycle, coordinator: shop, orders_open_at: 1.week.ago,
-                                      orders_close_at: 1.week.from_now)
-        end
+    let(:current_order_cycle) do
+      create(:simple_order_cycle, coordinator: shop, orders_open_at: 1.week.ago,
+                                  orders_close_at: 1.week.from_now)
+    end
 
-        let(:future_order_cycle) do
-          create(:simple_order_cycle, coordinator: shop, orders_open_at: 1.week.from_now,
-                                      orders_close_at: 2.weeks.from_now)
-        end
+    let(:future_order_cycle) do
+      create(:simple_order_cycle, coordinator: shop, orders_open_at: 1.week.from_now,
+                                  orders_close_at: 2.weeks.from_now)
+    end
 
-        let(:past_order_cycle) do
-          create(:simple_order_cycle, coordinator: shop, orders_open_at: 2.weeks.ago,
-                                      orders_close_at: 1.week.ago)
-        end
+    let(:past_order_cycle) do
+      create(:simple_order_cycle, coordinator: shop, orders_open_at: 2.weeks.ago,
+                                  orders_close_at: 1.week.ago)
+    end
 
-        let!(:order_cycle) { current_order_cycle }
+    let!(:order_cycle) { current_order_cycle }
 
-        context "if the shop is the supplier for the product" do
-          let!(:producer) { shop }
+    context "if the shop is the supplier for the product" do
+      let!(:producer) { shop }
 
-          it "is eligible" do
-            expect(described_class.eligible_variants(shop)).to include(variant)
-          end
-        end
+      it "is eligible" do
+        expect(described_class.eligible_variants(shop)).to include(variant)
+      end
+    end
 
-        context "if the supplier is permitted for the shop" do
-          let!(:enterprise_relationship) {
-            create(:enterprise_relationship, child: shop,
-                                             parent: variant.supplier,
-                                             permissions_list: [:add_to_order_cycle])
-          }
+    context "if the supplier is permitted for the shop" do
+      let!(:enterprise_relationship) {
+        create(:enterprise_relationship, child: shop,
+                                         parent: variant.supplier,
+                                         permissions_list: [:add_to_order_cycle])
+      }
 
-          it "is eligible" do
-            expect(described_class.eligible_variants(shop)).to include(variant)
-          end
-        end
+      it "is eligible" do
+        expect(described_class.eligible_variants(shop)).to include(variant)
+      end
+    end
 
-        context "if the variant is involved in an exchange" do
-          let!(:order_cycle) { create(:simple_order_cycle, coordinator: shop) }
-          let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
+    context "if the variant is involved in an exchange" do
+      let!(:order_cycle) { create(:simple_order_cycle, coordinator: shop) }
+      let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
 
-          context "if it is an incoming exchange where the shop is the receiver" do
-            let!(:incoming_exchange) {
-              order_cycle.exchanges.create(sender: variant.supplier,
-                                           receiver: shop,
-                                           incoming: true, variants: [variant])
-            }
+      context "if it is an incoming exchange where the shop is the receiver" do
+        let!(:incoming_exchange) {
+          order_cycle.exchanges.create(sender: variant.supplier,
+                                       receiver: shop,
+                                       incoming: true, variants: [variant])
+        }
 
-            it "is not eligible" do
-              expect(described_class.eligible_variants(shop)).not_to include(variant)
-            end
-          end
-
-          context "if it is an outgoing exchange where the shop is the receiver" do
-            let!(:outgoing_exchange) {
-              order_cycle.exchanges.create(sender: variant.supplier,
-                                           receiver: shop,
-                                           incoming: false,
-                                           variants: [variant])
-            }
-
-            context "if the order cycle is currently open" do
-              let!(:order_cycle) { current_order_cycle }
-
-              it "is eligible" do
-                expect(described_class.eligible_variants(shop)).to include(variant)
-              end
-            end
-
-            context "if the order cycle opens in the future" do
-              let!(:order_cycle) { future_order_cycle }
-
-              it "is eligible" do
-                expect(described_class.eligible_variants(shop)).to include(variant)
-              end
-            end
-
-            context "if the order cycle closed in the past" do
-              let!(:order_cycle) { past_order_cycle }
-
-              it "is eligible" do
-                expect(described_class.eligible_variants(shop)).to include(variant)
-              end
-            end
-          end
-        end
-
-        context "if the variant is unrelated" do
-          it "is not eligible" do
-            expect(described_class.eligible_variants(shop)).not_to include(variant)
-          end
+        it "is not eligible" do
+          expect(described_class.eligible_variants(shop)).not_to include(variant)
         end
       end
 
-      describe "checking if variant in open and upcoming order cycles" do
-        let!(:shop) { create(:enterprise) }
-        let!(:product) { create(:product) }
-        let!(:variant) { product.variants.first }
-        let!(:schedule) { create(:schedule) }
+      context "if it is an outgoing exchange where the shop is the receiver" do
+        let!(:outgoing_exchange) {
+          order_cycle.exchanges.create(sender: variant.supplier,
+                                       receiver: shop,
+                                       incoming: false,
+                                       variants: [variant])
+        }
 
-        context "if the variant is involved in an exchange" do
-          let!(:order_cycle) { create(:simple_order_cycle, coordinator: shop) }
-          let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
+        context "if the order cycle is currently open" do
+          let!(:order_cycle) { current_order_cycle }
 
-          context "if it is an incoming exchange where the shop is the receiver" do
-            let!(:incoming_exchange) {
-              order_cycle.exchanges.create(sender: variant.supplier,
-                                           receiver: shop,
-                                           incoming: true,
-                                           variants: [variant])
-            }
-
-            it "is is false" do
-              expect(described_class).not_to be_in_open_and_upcoming_order_cycles(shop,
-                                                                                  schedule,
-                                                                                  variant)
-            end
-          end
-
-          context "if it is an outgoing exchange where the shop is the receiver" do
-            let!(:outgoing_exchange) {
-              order_cycle.exchanges.create(sender: variant.supplier,
-                                           receiver: shop,
-                                           incoming: false,
-                                           variants: [variant])
-            }
-
-            it "is true" do
-              expect(described_class).to be_in_open_and_upcoming_order_cycles(shop,
-                                                                              schedule,
-                                                                              variant)
-            end
+          it "is eligible" do
+            expect(described_class.eligible_variants(shop)).to include(variant)
           end
         end
 
-        context "if the variant is unrelated" do
-          it "is false" do
-            expect(described_class).not_to be_in_open_and_upcoming_order_cycles(shop,
-                                                                                schedule,
-                                                                                variant)
+        context "if the order cycle opens in the future" do
+          let!(:order_cycle) { future_order_cycle }
+
+          it "is eligible" do
+            expect(described_class.eligible_variants(shop)).to include(variant)
+          end
+        end
+
+        context "if the order cycle closed in the past" do
+          let!(:order_cycle) { past_order_cycle }
+
+          it "is eligible" do
+            expect(described_class.eligible_variants(shop)).to include(variant)
           end
         end
       end
     end
+
+    context "if the variant is unrelated" do
+      it "is not eligible" do
+        expect(described_class.eligible_variants(shop)).not_to include(variant)
+      end
+    end
+  end
+
+  describe "checking if variant in open and upcoming order cycles" do
+    let!(:shop) { create(:enterprise) }
+    let!(:product) { create(:product) }
+    let!(:variant) { product.variants.first }
+    let!(:schedule) { create(:schedule) }
+
+    context "if the variant is involved in an exchange" do
+      let!(:order_cycle) { create(:simple_order_cycle, coordinator: shop) }
+      let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
+
+      context "if it is an incoming exchange where the shop is the receiver" do
+        let!(:incoming_exchange) {
+          order_cycle.exchanges.create(sender: variant.supplier,
+                                       receiver: shop,
+                                       incoming: true,
+                                       variants: [variant])
+        }
+
+        it "is is false" do
+          expect(described_class).not_to be_in_open_and_upcoming_order_cycles(shop,
+                                                                              schedule,
+                                                                              variant)
+        end
+      end
+
+      context "if it is an outgoing exchange where the shop is the receiver" do
+        let!(:outgoing_exchange) {
+          order_cycle.exchanges.create(sender: variant.supplier,
+                                       receiver: shop,
+                                       incoming: false,
+                                       variants: [variant])
+        }
+
+        it "is true" do
+          expect(described_class).to be_in_open_and_upcoming_order_cycles(shop,
+                                                                          schedule,
+                                                                          variant)
+        end
+      end
+    end
+
+    context "if the variant is unrelated" do
+      it "is false" do
+        expect(described_class).not_to be_in_open_and_upcoming_order_cycles(shop,
+                                                                            schedule,
+                                                                            variant)
+      end
+    end
   end
 end