Add latest changes from gitlab-org/gitlab@master

2 files changed, 167 insertions, 17 deletions

diff --git a/spec/lib/gitlab/error_tracking/error_repository/open_api_strategy_spec.rb b/spec/lib/gitlab/error_tracking/error_repository/open_api_strategy_spec.rb
index 3a5df997f7c..c25cba704b3 100644
--- a/spec/lib/gitlab/error_tracking/error_repository/open_api_strategy_spec.rb
+++ b/spec/lib/gitlab/error_tracking/error_repository/open_api_strategy_spec.rb
@@ -97,10 +97,43 @@ RSpec.describe Gitlab::ErrorTracking::ErrorRepository::OpenApiStrategy do
             tags: { level: nil, logger: nil },
             external_url: "http://localhost/#{project.full_path}/-/error_tracking/#{error.fingerprint}/details",
             external_base_url: "http://localhost/#{project.full_path}",
-            integrated: true
+            integrated: true,
+            frequency: [[1, 2], [3, 4]]
           )
         end
 
+        context 'with missing stats' do
+          let(:error) { build(:error_tracking_open_api_error, project_id: project.id, stats: nil) }
+
+          it 'returns empty frequency' do
+            is_expected.to have_attributes(
+              frequency: []
+            )
+          end
+        end
+
+        context 'with missing frequency' do
+          let(:empty_freq) { build(:error_tracking_open_api_error_stats, { frequency: nil }) }
+          let(:error) { build(:error_tracking_open_api_error, project_id: project.id, stats: empty_freq) }
+
+          it 'returns empty frequency' do
+            is_expected.to have_attributes(
+              frequency: []
+            )
+          end
+        end
+
+        context 'with missing frequency data' do
+          let(:empty_freq) { build(:error_tracking_open_api_error_stats, { frequency: {} }) }
+          let(:error) { build(:error_tracking_open_api_error, project_id: project.id, stats: empty_freq) }
+
+          it 'returns empty frequency' do
+            is_expected.to have_attributes(
+              frequency: []
+            )
+          end
+        end
+
         it 'returns no first and last release version' do
           is_expected.to have_attributes(
             first_release_version: nil,
@@ -194,7 +227,8 @@ RSpec.describe Gitlab::ErrorTracking::ErrorRepository::OpenApiStrategy do
             last_seen: error.last_seen_at,
             status: error.status,
             count: error.event_count,
-            user_count: error.approximated_user_count
+            user_count: error.approximated_user_count,
+            frequency: [[1, 2], [3, 4]]
           ))
       end
 
diff --git a/spec/lib/gitlab/import_export/group/tree_restorer_spec.rb b/spec/lib/gitlab/import_export/group/tree_restorer_spec.rb
index a6afd0a36ec..9766d5d6d59 100644
--- a/spec/lib/gitlab/import_export/group/tree_restorer_spec.rb
+++ b/spec/lib/gitlab/import_export/group/tree_restorer_spec.rb
@@ -177,30 +177,146 @@ RSpec.describe Gitlab::ImportExport::Group::TreeRestorer, feature: :subgroups, f
     end
 
     context 'group visibility levels' do
-      let(:user) { create(:user) }
-      let(:shared) { Gitlab::ImportExport::Shared.new(group) }
-      let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+      context 'when the @top_level_group is the destination_group' do
+        let(:user) { create(:user) }
+        let(:shared) { Gitlab::ImportExport::Shared.new(group) }
+        let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+
+        shared_examples 'with visibility level' do |visibility_level, expected_visibilities|
+          context "when visibility level is #{visibility_level}" do
+            let(:group) { create(:group, visibility_level) }
+            let(:filepath) { "group_exports/visibility_levels/#{visibility_level}" }
+
+            before do
+              setup_import_export_config(filepath)
+              group_tree_restorer.restore
+            end
 
-      before do
-        setup_import_export_config(filepath)
+            it "imports all subgroups as #{visibility_level}" do
+              expect(group.children.map(&:visibility_level)).to match_array(expected_visibilities)
+            end
+          end
+        end
 
-        group_tree_restorer.restore
+        include_examples 'with visibility level', :public, [20, 10, 0]
+        include_examples 'with visibility level', :private, [0, 0, 0]
+        include_examples 'with visibility level', :internal, [10, 10, 0]
       end
 
-      shared_examples 'with visibility level' do |visibility_level, expected_visibilities|
-        context "when visibility level is #{visibility_level}" do
-          let(:group) { create(:group, visibility_level) }
-          let(:filepath) { "group_exports/visibility_levels/#{visibility_level}" }
+      context 'when the destination_group is the @top_level_group.parent' do
+        let(:user) { create(:user) }
+        let(:shared) { Gitlab::ImportExport::Shared.new(group) }
+        let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+
+        shared_examples 'with visibility level' do |visibility_level, expected_visibilities, group_visibility|
+          context "when source level is #{visibility_level}" do
+            let(:parent) { create(:group, visibility_level) }
+            let(:group) { create(:group, visibility_level, parent: parent) }
+            let(:filepath) { "group_exports/visibility_levels/#{visibility_level}" }
+
+            before do
+              setup_import_export_config(filepath)
+              parent.add_maintainer(user)
+              group_tree_restorer.restore
+            end
 
-          it "imports all subgroups as #{visibility_level}" do
-            expect(group.children.map(&:visibility_level)).to match_array(expected_visibilities)
+            it "imports all subgroups as #{visibility_level}" do
+              expect(group.visibility_level).to eq(group_visibility)
+              expect(group.children.map(&:visibility_level)).to match_array(expected_visibilities)
+            end
           end
         end
+
+        include_examples 'with visibility level', :public, [20, 10, 0], 20
+        include_examples 'with visibility level', :private, [0, 0, 0], 0
+        include_examples 'with visibility level', :internal, [10, 10, 0], 10
+      end
+
+      context 'when the visibility level is restricted' do
+        let(:user) { create(:user) }
+        let(:shared) { Gitlab::ImportExport::Shared.new(group) }
+        let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+        let(:group) { create(:group, :internal) }
+        let(:filepath) { "group_exports/visibility_levels/internal" }
+
+        before do
+          setup_import_export_config(filepath)
+          Gitlab::CurrentSettings.restricted_visibility_levels = [10]
+          group_tree_restorer.restore
+        end
+
+        after do
+          Gitlab::CurrentSettings.restricted_visibility_levels = []
+        end
+
+        it 'updates the visibility_level' do
+          expect(group.children.map(&:visibility_level)).to match_array([0, 0, 0])
+        end
       end
+    end
+
+    context 'when there are nested subgroups' do
+      let(:filepath) { "group_exports/visibility_levels/nested_subgroups" }
 
-      include_examples 'with visibility level', :public, [20, 10, 0]
-      include_examples 'with visibility level', :private, [0, 0, 0]
-      include_examples 'with visibility level', :internal, [10, 10, 0]
+      context "when destination level is :public" do
+        let(:user) { create(:user) }
+        let(:shared) { Gitlab::ImportExport::Shared.new(group) }
+        let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+        let(:parent) { create(:group, :public) }
+        let(:group) { create(:group, :public, parent: parent) }
+
+        before do
+          setup_import_export_config(filepath)
+          parent.add_maintainer(user)
+          group_tree_restorer.restore
+        end
+
+        it "imports all subgroups with original visibility_level" do
+          expect(group.visibility_level).to eq(Gitlab::VisibilityLevel::PUBLIC)
+          expect(group.descendants.map(&:visibility_level))
+            .to match_array([0, 0, 0, 10, 10, 10, 20, 20])
+        end
+      end
+
+      context "when destination level is :internal" do
+        let(:user) { create(:user) }
+        let(:shared) { Gitlab::ImportExport::Shared.new(group) }
+        let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+        let(:parent) { create(:group, :internal) }
+        let(:group) { create(:group, :internal, parent: parent) }
+
+        before do
+          setup_import_export_config(filepath)
+          parent.add_maintainer(user)
+          group_tree_restorer.restore
+        end
+
+        it "imports non-public subgroups with original level and public subgroups as internal" do
+          expect(group.visibility_level).to eq(Gitlab::VisibilityLevel::INTERNAL)
+          expect(group.descendants.map(&:visibility_level))
+            .to match_array([0, 0, 0, 10, 10, 10, 10, 10])
+        end
+      end
+
+      context "when destination level is :private" do
+        let(:user) { create(:user) }
+        let(:shared) { Gitlab::ImportExport::Shared.new(group) }
+        let(:group_tree_restorer) { described_class.new(user: user, shared: shared, group: group) }
+        let(:parent) { create(:group, :private) }
+        let(:group) { create(:group, :private, parent: parent) }
+
+        before do
+          setup_import_export_config(filepath)
+          parent.add_maintainer(user)
+          group_tree_restorer.restore
+        end
+
+        it "imports all subgroups as private" do
+          expect(group.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
+          expect(group.descendants.map(&:visibility_level))
+            .to match_array([0, 0, 0, 0, 0, 0, 0, 0])
+        end
+      end
     end
   end