Add latest changes from gitlab-org/gitlab@13-0-stable-ee

4 files changed, 276 insertions, 59 deletions

diff --git a/spec/services/groups/create_service_spec.rb b/spec/services/groups/create_service_spec.rb
index 5cde9a3ed45..c0e876cce33 100644
--- a/spec/services/groups/create_service_spec.rb
+++ b/spec/services/groups/create_service_spec.rb
@@ -24,6 +24,27 @@ describe Groups::CreateService, '#execute' do
     end
   end
 
+  context 'creating a group with `default_branch_protection` attribute' do
+    let(:params) { group_params.merge(default_branch_protection: Gitlab::Access::PROTECTION_NONE) }
+    let(:service) { described_class.new(user, params) }
+    let(:created_group) { service.execute }
+
+    context 'for users who have the ability to create a group with `default_branch_protection`' do
+      it 'creates group with the specified branch protection level' do
+        expect(created_group.default_branch_protection).to eq(Gitlab::Access::PROTECTION_NONE)
+      end
+    end
+
+    context 'for users who do not have the ability to create a group with `default_branch_protection`' do
+      it 'does not create the group with the specified branch protection level' do
+        allow(Ability).to receive(:allowed?).and_call_original
+        allow(Ability).to receive(:allowed?).with(user, :create_group_with_default_branch_protection) { false }
+
+        expect(created_group.default_branch_protection).not_to eq(Gitlab::Access::PROTECTION_NONE)
+      end
+    end
+  end
+
   describe 'creating a top level group' do
     let(:service) { described_class.new(user, group_params) }
 
diff --git a/spec/services/groups/import_export/export_service_spec.rb b/spec/services/groups/import_export/export_service_spec.rb
index 56c7121cc34..7bad68b4e00 100644
--- a/spec/services/groups/import_export/export_service_spec.rb
+++ b/spec/services/groups/import_export/export_service_spec.rb
@@ -11,7 +11,7 @@ describe Groups::ImportExport::ExportService do
       let(:export_service) { described_class.new(group: group, user: user) }
 
       it 'enqueues an export job' do
-        expect(GroupExportWorker).to receive(:perform_async).with(user.id, group.id, {})
+        allow(GroupExportWorker).to receive(:perform_async).with(user.id, group.id, {})
 
         export_service.async_execute
       end
@@ -49,12 +49,36 @@ describe Groups::ImportExport::ExportService do
       FileUtils.rm_rf(archive_path)
     end
 
-    it 'saves the models' do
+    it 'saves the version' do
+      expect(Gitlab::ImportExport::VersionSaver).to receive(:new).and_call_original
+
+      service.execute
+    end
+
+    it 'saves the models using ndjson tree saver' do
+      stub_feature_flags(group_export_ndjson: true)
+
+      expect(Gitlab::ImportExport::Group::TreeSaver).to receive(:new).and_call_original
+
+      service.execute
+    end
+
+    it 'saves the models using legacy tree saver' do
+      stub_feature_flags(group_export_ndjson: false)
+
       expect(Gitlab::ImportExport::Group::LegacyTreeSaver).to receive(:new).and_call_original
 
       service.execute
     end
 
+    it 'notifies the user' do
+      expect_next_instance_of(NotificationService) do |instance|
+        expect(instance).to receive(:group_was_exported)
+      end
+
+      service.execute
+    end
+
     context 'when saver succeeds' do
       it 'saves the group in the file system' do
         service.execute
@@ -98,16 +122,26 @@ describe Groups::ImportExport::ExportService do
 
     context 'when export fails' do
       context 'when file saver fails' do
-        it 'removes the remaining exported data' do
+        before do
           allow_next_instance_of(Gitlab::ImportExport::Saver) do |saver|
             allow(saver).to receive(:save).and_return(false)
           end
+        end
 
+        it 'removes the remaining exported data' do
           expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
 
           expect(group.import_export_upload).to be_nil
           expect(File.exist?(shared.archive_path)).to eq(false)
         end
+
+        it 'notifies the user about failed group export' do
+          expect_next_instance_of(NotificationService) do |instance|
+            expect(instance).to receive(:group_was_not_exported)
+          end
+
+          expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
+        end
       end
 
       context 'when file compression fails' do
diff --git a/spec/services/groups/import_export/import_service_spec.rb b/spec/services/groups/import_export/import_service_spec.rb
index d95bba38b3e..256e0a1b3c5 100644
--- a/spec/services/groups/import_export/import_service_spec.rb
+++ b/spec/services/groups/import_export/import_service_spec.rb
@@ -3,17 +3,16 @@
 require 'spec_helper'
 
 describe Groups::ImportExport::ImportService do
-  describe '#execute' do
+  context 'with group_import_ndjson feature flag disabled' do
     let(:user) { create(:admin) }
     let(:group) { create(:group) }
-    let(:service) { described_class.new(group: group, user: user) }
-    let(:import_file) { fixture_file_upload('spec/fixtures/group_export.tar.gz') }
-
     let(:import_logger) { instance_double(Gitlab::Import::Logger) }
 
-    subject { service.execute }
+    subject(:service) { described_class.new(group: group, user: user) }
 
     before do
+      stub_feature_flags(group_import_ndjson: false)
+
       ImportExportUpload.create(group: group, import_file: import_file)
 
       allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
@@ -21,84 +20,227 @@ describe Groups::ImportExport::ImportService do
       allow(import_logger).to receive(:info)
     end
 
-    context 'when user has correct permissions' do
-      it 'imports group structure successfully' do
-        expect(subject).to be_truthy
-      end
+    context 'with a json file' do
+      let(:import_file) { fixture_file_upload('spec/fixtures/legacy_group_export.tar.gz') }
 
-      it 'removes import file' do
-        subject
+      it 'uses LegacyTreeRestorer to import the file' do
+        expect(Gitlab::ImportExport::Group::LegacyTreeRestorer).to receive(:new).and_call_original
 
-        expect(group.import_export_upload.import_file.file).to be_nil
+        service.execute
       end
+    end
 
-      it 'logs the import success' do
-        expect(import_logger).to receive(:info).with(
-          group_id:   group.id,
-          group_name: group.name,
-          message:    'Group Import/Export: Import succeeded'
-        ).once
+    context 'with a ndjson file' do
+      let(:import_file) { fixture_file_upload('spec/fixtures/group_export.tar.gz') }
 
-        subject
+      it 'fails to import' do
+        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error, 'Incorrect JSON format')
       end
     end
+  end
+
+  context 'with group_import_ndjson feature flag enabled' do
+    before do
+      stub_feature_flags(group_import_ndjson: true)
+    end
+
+    context 'when importing a ndjson export' do
+      let(:user) { create(:admin) }
+      let(:group) { create(:group) }
+      let(:service) { described_class.new(group: group, user: user) }
+      let(:import_file) { fixture_file_upload('spec/fixtures/group_export.tar.gz') }
 
-    context 'when user does not have correct permissions' do
-      let(:user) { create(:user) }
+      let(:import_logger) { instance_double(Gitlab::Import::Logger) }
 
-      it 'logs the error and raises an exception' do
-        expect(import_logger).to receive(:error).with(
-          group_id:   group.id,
-          group_name: group.name,
-          message:    a_string_including('Errors occurred')
-        )
+      subject { service.execute }
 
-        expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+      before do
+        ImportExportUpload.create(group: group, import_file: import_file)
+
+        allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
+        allow(import_logger).to receive(:error)
+        allow(import_logger).to receive(:info)
       end
 
-      it 'tracks the error' do
-        shared = Gitlab::ImportExport::Shared.new(group)
-        allow(Gitlab::ImportExport::Shared).to receive(:new).and_return(shared)
+      context 'when user has correct permissions' do
+        it 'imports group structure successfully' do
+          expect(subject).to be_truthy
+        end
+
+        it 'removes import file' do
+          subject
 
-        expect(shared).to receive(:error) do |param|
-          expect(param.message).to include 'does not have required permissions for'
+          expect(group.import_export_upload.import_file.file).to be_nil
         end
 
-        expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        it 'logs the import success' do
+          expect(import_logger).to receive(:info).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    'Group Import/Export: Import succeeded'
+          ).once
+
+          subject
+        end
       end
-    end
 
-    context 'when there are errors with the import file' do
-      let(:import_file) { fixture_file_upload('spec/fixtures/symlink_export.tar.gz') }
+      context 'when user does not have correct permissions' do
+        let(:user) { create(:user) }
 
-      it 'logs the error and raises an exception' do
-        expect(import_logger).to receive(:error).with(
-          group_id:   group.id,
-          group_name: group.name,
-          message:    a_string_including('Errors occurred')
-        ).once
+        it 'logs the error and raises an exception' do
+          expect(import_logger).to receive(:error).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    a_string_including('Errors occurred')
+          )
 
-        expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+          expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        end
+
+        it 'tracks the error' do
+          shared = Gitlab::ImportExport::Shared.new(group)
+          allow(Gitlab::ImportExport::Shared).to receive(:new).and_return(shared)
+
+          expect(shared).to receive(:error) do |param|
+            expect(param.message).to include 'does not have required permissions for'
+          end
+
+          expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        end
       end
-    end
 
-    context 'when there are errors with the sub-relations' do
-      let(:import_file) { fixture_file_upload('spec/fixtures/group_export_invalid_subrelations.tar.gz') }
+      context 'when there are errors with the import file' do
+        let(:import_file) { fixture_file_upload('spec/fixtures/symlink_export.tar.gz') }
+
+        it 'logs the error and raises an exception' do
+          expect(import_logger).to receive(:error).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    a_string_including('Errors occurred')
+          ).once
+
+          expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        end
+      end
+
+      context 'when there are errors with the sub-relations' do
+        let(:import_file) { fixture_file_upload('spec/fixtures/group_export_invalid_subrelations.tar.gz') }
+
+        it 'successfully imports the group' do
+          expect(subject).to be_truthy
+        end
+
+        it 'logs the import success' do
+          allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
+
+          expect(import_logger).to receive(:info).with(
+            group_id: group.id,
+            group_name: group.name,
+            message: 'Group Import/Export: Import succeeded'
+          )
 
-      it 'successfully imports the group' do
-        expect(subject).to be_truthy
+          subject
+        end
       end
+    end
+
+    context 'when importing a json export' do
+      let(:user) { create(:admin) }
+      let(:group) { create(:group) }
+      let(:service) { described_class.new(group: group, user: user) }
+      let(:import_file) { fixture_file_upload('spec/fixtures/legacy_group_export.tar.gz') }
+
+      let(:import_logger) { instance_double(Gitlab::Import::Logger) }
+
+      subject { service.execute }
+
+      before do
+        ImportExportUpload.create(group: group, import_file: import_file)
 
-      it 'logs the import success' do
         allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
+        allow(import_logger).to receive(:error)
+        allow(import_logger).to receive(:info)
+      end
 
-        expect(import_logger).to receive(:info).with(
-          group_id:   group.id,
-          group_name: group.name,
-          message:    'Group Import/Export: Import succeeded'
-        )
+      context 'when user has correct permissions' do
+        it 'imports group structure successfully' do
+          expect(subject).to be_truthy
+        end
+
+        it 'removes import file' do
+          subject
+
+          expect(group.import_export_upload.import_file.file).to be_nil
+        end
+
+        it 'logs the import success' do
+          expect(import_logger).to receive(:info).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    'Group Import/Export: Import succeeded'
+          ).once
+
+          subject
+        end
+      end
+
+      context 'when user does not have correct permissions' do
+        let(:user) { create(:user) }
+
+        it 'logs the error and raises an exception' do
+          expect(import_logger).to receive(:error).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    a_string_including('Errors occurred')
+          )
+
+          expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        end
 
-        subject
+        it 'tracks the error' do
+          shared = Gitlab::ImportExport::Shared.new(group)
+          allow(Gitlab::ImportExport::Shared).to receive(:new).and_return(shared)
+
+          expect(shared).to receive(:error) do |param|
+            expect(param.message).to include 'does not have required permissions for'
+          end
+
+          expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        end
+      end
+
+      context 'when there are errors with the import file' do
+        let(:import_file) { fixture_file_upload('spec/fixtures/legacy_symlink_export.tar.gz') }
+
+        it 'logs the error and raises an exception' do
+          expect(import_logger).to receive(:error).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    a_string_including('Errors occurred')
+          ).once
+
+          expect { subject }.to raise_error(Gitlab::ImportExport::Error)
+        end
+      end
+
+      context 'when there are errors with the sub-relations' do
+        let(:import_file) { fixture_file_upload('spec/fixtures/legacy_group_export_invalid_subrelations.tar.gz') }
+
+        it 'successfully imports the group' do
+          expect(subject).to be_truthy
+        end
+
+        it 'logs the import success' do
+          allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
+
+          expect(import_logger).to receive(:info).with(
+            group_id:   group.id,
+            group_name: group.name,
+            message:    'Group Import/Export: Import succeeded'
+          )
+
+          subject
+        end
       end
     end
   end
diff --git a/spec/services/groups/update_service_spec.rb b/spec/services/groups/update_service_spec.rb
index 1aa7e06182b..b17d78505d1 100644
--- a/spec/services/groups/update_service_spec.rb
+++ b/spec/services/groups/update_service_spec.rb
@@ -148,6 +148,26 @@ describe Groups::UpdateService do
     end
   end
 
+  context 'updating default_branch_protection' do
+    let(:service) do
+      described_class.new(internal_group, user, default_branch_protection: Gitlab::Access::PROTECTION_NONE)
+    end
+
+    context 'for users who have the ability to update default_branch_protection' do
+      it 'updates the attribute' do
+        internal_group.add_owner(user)
+
+        expect { service.execute }.to change { internal_group.default_branch_protection }.to(Gitlab::Access::PROTECTION_NONE)
+      end
+    end
+
+    context 'for users who do not have the ability to update default_branch_protection' do
+      it 'does not update the attribute' do
+        expect { service.execute }.not_to change { internal_group.default_branch_protection }
+      end
+    end
+  end
+
   context 'rename group' do
     let!(:service) { described_class.new(internal_group, user, path: SecureRandom.hex) }