Rework org_admin_plans spec

Redesign org_admin_plans tests for clarity and maintainability:

- Introduce helper methods for plan creation and role deactivation.
- Organize plans into native vs affiliated hashes for clearer context.
- Use shared examples to consolidate repetitive expectations.

Author: aaronskiba

spec/models/org_spec.rb

@@ -343,126 +343,103 @@
   end
 
   describe '#org_admin_plans' do
-    Rails.configuration.x.plans.org_admins_read_all = true
-    # Two Orgs
-    let!(:org1) { create(:org) }
-    let!(:org2) { create(:org) }
-
-    # Plans for org1
-    let!(:org1plan1) { create(:plan, :creator, :organisationally_visible, org: org1) }
-    let!(:org1plan2) { create(:plan, :creator, :privately_visible, org: org1) }
-    let!(:org1plan3) { create(:plan, :creator, :publicly_visible, org: org1) }
-    let!(:org1plan4) { create(:plan, :creator, :organisationally_visible, org: org1) }
-
-    # Plans for org2
-    let!(:org2plan1) { create(:plan, :creator, :organisationally_visible, org: org2) }
-
-    subject { org1.org_admin_plans }
-
-    context 'when user belongs to Org and plan owner with role :creator' do
-      before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-      end
-      it { is_expected.to include(org1plan1, org1plan2, org1plan3, org1plan4) }
-      it { is_expected.not_to include(org2plan1) }
+    # Helper for returning all plans from the `plans` hash
+    def all_plans
+      plans.values.flat_map(&:values)
     end
 
-    context 'when user belongs to Org and a plan removed by creator assuming there are no coowners' do
-      before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-        org1plan4.roles.map { |r| r.update(active: false) if r.user_id == org1plan4.owner.id }
-      end
+    # Helper for deactivating roles (creator or administrator) from plans
+    def deactivate_roles_for_plans(plans, role_condition)
+      Role.where(plan_id: plans.map(&:id)).where(role_condition).update_all(active: false)
+    end
 
-      it { is_expected.to include(org1plan1, org1plan2, org1plan3) }
-      it { is_expected.not_to include(org1plan4) }
+    def create_plans_for(org)
+      {
+        public: create(:plan, :creator, :publicly_visible, org: org),
+        org: create(:plan, :creator, :organisationally_visible, org: org),
+        private: create(:plan, :creator, :privately_visible, org: org),
+        test: create(:plan, :creator, :is_test, org: org)
+      }
     end
 
-    context 'when user belongs to Org and a plan removed by creator, but coowner still active.' do
-      before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-        coowner = create(:user, org: org1)
-        #  Add coowner to the plan by giving user the role administrator
-        org1plan4.add_user!(coowner.id, :administrator)
-        owner_id = org1plan4.owner.id
-        org1plan4.roles.map { |r| r.update(active: false) if r.user_id == owner_id }
+    let!(:org) { create(:org) }
+    let!(:org_user) { create(:user, org: org) }
+    let!(:other_org) { create(:org) }
+
+    # org_admin_plans consists of "native" and "affiliated" plans
+    # - native plans have plan.org == org
+    # - affiliated plans have an active administrator role for a user where user.org == org
+    let!(:plans) do
+      {
+        native: create_plans_for(org),
+        affiliated: create_plans_for(other_org)
+      }.tap do |hash|
+        # Add the required administrator role for the `affiliated` plans
+        hash[:affiliated].each_value do |plan|
+          plan.add_user!(org_user.id, :administrator)
+        end
       end
-
-      it { is_expected.to include(org1plan1, org1plan2, org1plan3) }
-      it { is_expected.not_to include(org1plan4) }
     end
 
-    context 'when user belongs to Org, plan user with role :administrator, but plan creator from a different Org' do
-      before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-        # Creator belongs to different org
-        @plan = create(:plan, :creator, :organisationally_visible, org: create(:org))
-        @plan.add_user!(create(:user, org: org1).id, :administrator)
-      end
+    let!(:other_org_plan) { create(:plan, :creator, :publicly_visible, org: other_org) }
 
-      it {
-        is_expected.to include(org1plan1, org1plan2, org1plan3, org1plan4, @plan)
-      }
-    end
+    subject { org.org_admin_plans }
 
-    context 'user belongs to Org and plan user with role :editor, but not :creator and :admin' do
+    shared_examples 'org_admin_plans expectations' do |org_admins_read_all: true|
       before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-        # Creator and admin belongs to different orgs
-        @plan = create(:plan, :creator, :organisationally_visible, org: create(:org))
-        @plan.add_user!(create(:org).id, :administrator)
-        # Editor belongs to org1
-        @plan.add_user!(create(:user, org: org1).id, :editor)
+        Rails.configuration.x.plans.org_admins_read_all = org_admins_read_all
       end
 
-      it { is_expected.not_to include(@plan) }
+      it 'includes/excludes the expected plans' do
+        expect(subject).to include(*Array(included))
+        expect(subject).not_to include(*Array(excluded))
+      end
     end
 
-    context 'user belongs to Org and plan user with role :commenter, but not :creator and :admin' do
-      before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-        # Creator and admin belongs to different orgs
-        @plan = create(:plan, :creator, :organisationally_visible, org: create(:org))
-        @plan.add_user!(create(:org).id, :administrator)
-        # Commenter belongs to org1
-        @plan.add_user!(create(:user, org: org1).id, :commentor)
+    context 'default context with org_admins_read_all = true' do
+      include_examples 'org_admin_plans expectations' do
+        let(:included) { all_plans }
+        let(:excluded) { other_org_plan }
       end
-
-      it { is_expected.not_to include(@plan) }
     end
 
-    context 'user belongs to Org and plan user with role :reviewer, but not :creator and :admin' do
-      before do
-        Rails.configuration.x.plans.org_admins_read_all = true
-        # Creator and admin belongs to different orgs
-        @plan = create(:plan, :creator, :organisationally_visible, org: create(:org))
-        @plan.add_user!(create(:org).id, :administrator)
-        # Reviewer belongs to org1
-        @plan.add_user!(create(:user, org: org1).id, :reviewer)
+    context 'default context with org_admins_read_all = false' do
+      let(:private_and_test_plans) do
+        plans.fetch_values(:native, :affiliated).flat_map do |h|
+          h.values_at(:private, :test)
+        end
       end
 
-      it { is_expected.not_to include(@plan) }
+      include_examples 'org_admin_plans expectations', org_admins_read_all: false do
+        let(:included) { (all_plans - private_and_test_plans).flatten }
+        let(:excluded) { private_and_test_plans + [other_org_plan] }
+      end
     end
 
-    context 'read_all is false, visibility private and user org_admin' do
+    context 'creator role is deactivated for some native and affiliated plans' do
+      # Deactivate the creator role for both a native and an affiliated plan
+      let(:plans_to_deactivate) { [plans[:native][:public], plans[:affiliated][:public]] }
       before do
-        Rails.configuration.x.plans.org_admins_read_all = false
-        @user = create(:user, :org_admin, org: org1)
-        @plan = create(:plan, :creator, :privately_visible, org: org1)
-        @plan.add_user!(@user.id, :reviewer)
+        deactivate_roles_for_plans(plans_to_deactivate, Role.creator_condition)
       end
 
-      it { is_expected.not_to include(@plan) }
+      include_examples 'org_admin_plans expectations' do
+        let(:included) { (all_plans - plans_to_deactivate).flatten }
+        let(:excluded) { plans_to_deactivate + [other_org_plan] }
+      end
     end
 
-    context 'read_all is false, visibility public and user org_admin' do
+    context 'administrator role is deactivated for some affiliated plans' do
+      # Deactivate the administrator role for some affiliated plans
+      let(:plans_to_deactivate) { [plans[:affiliated][:public], plans[:affiliated][:org]] }
       before do
-        Rails.configuration.x.plans.org_admins_read_all = false
-        @user = create(:user, :org_admin, org: org1)
-        @plan = create(:plan, :creator, :publicly_visible, org: org1)
-        @plan.add_user!(@user.id, :reviewer)
+        deactivate_roles_for_plans(plans_to_deactivate, Role.administrator_condition)
       end
 
-      it { is_expected.to include(@plan) }
+      include_examples 'org_admin_plans expectations' do
+        let(:included) { (all_plans - plans_to_deactivate).flatten }
+        let(:excluded) { plans_to_deactivate + [other_org_plan] }
+      end
     end
   end