Use public project in UpdateAllMirrorsWorker specs

This public project allows us to test the next change effectively.

ee/spec/workers/update_all_mirrors_worker_spec.rb

@@ -126,7 +126,7 @@ describe UpdateAllMirrorsWorker do
       projects.each { |project| expect_import_status(project, 'none') }
     end
 
-    context 'unlicensed' do
+    context 'when the instance is unlicensed' do
       it 'does not schedule when project does not have repository mirrors available' do
         project = create(:project, :mirror)
 
@@ -138,110 +138,116 @@ describe UpdateAllMirrorsWorker do
       end
     end
 
-    context 'licensed' do
-      def scheduled_mirror(at:, licensed:)
-        namespace = create(:group, :public)
+    context 'on GitLab.com' do
+      def scheduled_mirror(at:, licensed:, public: false, subgroup: nil)
+        group_args = [:group, :public, subgroup && :nested].compact
+        namespace = create(*group_args)
         project = create(:project, :public, :mirror, namespace: namespace)
 
-        create(:gitlab_subscription, (licensed ? :bronze : :free), namespace: namespace)
+        create(:gitlab_subscription, (licensed ? :bronze : :free), namespace: namespace.root_ancestor)
 
         project.import_state.update!(next_execution_timestamp: at)
-        project.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
+        project.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE) unless public
         project
       end
 
       before do
-        stub_licensed_features(repository_mirrors: true)
         stub_application_setting(check_namespace_plan: true)
-        allow(Gitlab).to receive_messages(com?: true)
-        stub_const('License::ANY_PLAN_FEATURES', [])
       end
 
-      let!(:unlicensed_project1) { scheduled_mirror(at: 8.weeks.ago, licensed: false) }
-      let!(:unlicensed_project2) { scheduled_mirror(at: 7.weeks.ago, licensed: false) }
-      let!(:licensed_project1)   { scheduled_mirror(at: 6.weeks.ago, licensed: true) }
-      let!(:unlicensed_project3) { scheduled_mirror(at: 5.weeks.ago, licensed: false) }
-      let!(:licensed_project2)   { scheduled_mirror(at: 4.weeks.ago, licensed: true) }
-      let!(:unlicensed_project4) { scheduled_mirror(at: 3.weeks.ago, licensed: false) }
-      let!(:licensed_project3)   { scheduled_mirror(at: 1.week.ago, licensed: true) }
+      let_it_be(:unlicensed_project1) { scheduled_mirror(at: 8.weeks.ago, licensed: false) }
+      let_it_be(:unlicensed_project2) { scheduled_mirror(at: 7.weeks.ago, licensed: false) }
+      let_it_be(:licensed_project1)   { scheduled_mirror(at: 6.weeks.ago, licensed: true, subgroup: true) }
+      let_it_be(:unlicensed_project3) { scheduled_mirror(at: 5.weeks.ago, licensed: false) }
+      let_it_be(:licensed_project2)   { scheduled_mirror(at: 4.weeks.ago, licensed: true) }
+      let_it_be(:unlicensed_project4) { scheduled_mirror(at: 3.weeks.ago, licensed: false) }
+      let_it_be(:public_project)      { scheduled_mirror(at: 1.week.ago, licensed: false, public: true) }
 
       let(:unlicensed_projects) { [unlicensed_project1, unlicensed_project2, unlicensed_project3, unlicensed_project4] }
 
-      context 'when capacity is in excess' do
-        it "schedules all available mirrors" do
-          schedule_mirrors!(capacity: 4)
-
-          expect_import_scheduled(licensed_project1, licensed_project2, licensed_project3)
-          expect_import_not_scheduled(*unlicensed_projects)
+      context 'during the free period for pull mirroring' do
+        before do
+          stub_const('License::ANY_PLAN_FEATURES', [])
         end
 
-        it 'requests as many batches as necessary' do
-          # The first batch will only contain 3 licensed mirrors, but since we have
-          # fewer than 8 mirrors in total, there's no need to request another batch
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 8)).and_call_original
+        context 'when capacity is in excess' do
+          it "schedules all available mirrors" do
+            schedule_mirrors!(capacity: 4)
 
-          schedule_mirrors!(capacity: 4)
-        end
+            aggregate_failures do
+              expect_import_scheduled(licensed_project1, licensed_project2, public_project)
+              expect_import_not_scheduled(*unlicensed_projects)
+            end
+          end
 
-        it "does not schedule a mirror of an archived project" do
-          licensed_project1.update!(archived: true)
+          it 'requests as many batches as necessary' do
+            # The first batch will only contain 3 licensed mirrors, but since we have
+            # fewer than 8 mirrors in total, there's no need to request another batch
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 8)).and_call_original
 
-          schedule_mirrors!(capacity: 4)
+            schedule_mirrors!(capacity: 4)
+          end
 
-          expect_import_scheduled(licensed_project2, licensed_project3)
-          expect_import_not_scheduled(licensed_project1)
-          expect_import_not_scheduled(*unlicensed_projects)
-        end
-      end
+          it "does not schedule a mirror of an archived project" do
+            licensed_project1.update!(archived: true)
 
-      context 'when capacity is exacly sufficient' do
-        it "schedules all available mirrors" do
-          schedule_mirrors!(capacity: 3)
+            schedule_mirrors!(capacity: 4)
 
-          expect_import_scheduled(licensed_project1, licensed_project2, licensed_project3)
-          expect_import_not_scheduled(*unlicensed_projects)
+            expect_import_scheduled(licensed_project2, public_project)
+            expect_import_not_scheduled(licensed_project1)
+            expect_import_not_scheduled(*unlicensed_projects)
+          end
         end
 
-        it 'requests as many batches as necessary' do
-          # The first batch will only contain 2 licensed mirrors, so we need to request another batch
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 6)).ordered.and_call_original
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
+        context 'when capacity is exacly sufficient' do
+          it "schedules all available mirrors" do
+            schedule_mirrors!(capacity: 3)
 
-          schedule_mirrors!(capacity: 3)
-        end
-      end
+            expect_import_scheduled(licensed_project1, licensed_project2, public_project)
+            expect_import_not_scheduled(*unlicensed_projects)
+          end
 
-      context 'when capacity is insufficient' do
-        it 'schedules mirrors by next_execution_timestamp' do
-          schedule_mirrors!(capacity: 2)
+          it 'requests as many batches as necessary' do
+            # The first batch will only contain 2 licensed mirrors, so we need to request another batch
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 6)).ordered.and_call_original
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
 
-          expect_import_scheduled(licensed_project1, licensed_project2)
-          expect_import_not_scheduled(*unlicensed_projects, licensed_project3)
+            schedule_mirrors!(capacity: 3)
+          end
         end
 
-        it 'requests as many batches as necessary' do
-          # The first batch will only contain 1 licensed mirror, so we need to request another batch
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 4)).ordered.and_call_original
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
+        context 'when capacity is insufficient' do
+          it 'schedules mirrors by next_execution_timestamp' do
+            schedule_mirrors!(capacity: 2)
 
-          schedule_mirrors!(capacity: 2)
-        end
-      end
+            expect_import_scheduled(licensed_project1, licensed_project2)
+            expect_import_not_scheduled(*unlicensed_projects, public_project)
+          end
 
-      context 'when capacity is insufficient and the first batch is empty' do
-        it 'schedules mirrors by next_execution_timestamp' do
-          schedule_mirrors!(capacity: 1)
+          it 'requests as many batches as necessary' do
+            # The first batch will only contain 1 licensed mirror, so we need to request another batch
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 4)).ordered.and_call_original
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
 
-          expect_import_scheduled(licensed_project1)
-          expect_import_not_scheduled(*unlicensed_projects, licensed_project2, licensed_project3)
+            schedule_mirrors!(capacity: 2)
+          end
         end
 
-        it 'requests as many batches as necessary' do
-          # The first batch will not contain any licensed mirrors, so we need to request another batch
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
-          expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
+        context 'when capacity is insufficient and the first batch is empty' do
+          it 'schedules mirrors by next_execution_timestamp' do
+            schedule_mirrors!(capacity: 1)
+
+            expect_import_scheduled(licensed_project1)
+            expect_import_not_scheduled(*unlicensed_projects, licensed_project2, public_project)
+          end
+
+          it 'requests as many batches as necessary' do
+            # The first batch will not contain any licensed mirrors, so we need to request another batch
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
+            expect(subject).to receive(:pull_mirrors_batch).with(hash_including(batch_size: 2)).ordered.and_call_original
 
-          schedule_mirrors!(capacity: 1)
+            schedule_mirrors!(capacity: 1)
+          end
         end
       end
     end