Merge branch '341422-gitlab-migration-add-gitlab-version-check-for-project-migration' into 'master'

Resolve "GitLab Migration - Add GitLab version check for Project Migration"

See merge request gitlab-org/gitlab!71423

app/controllers/import/bulk_imports_controller.rb

@@ -22,13 +22,16 @@ class Import::BulkImportsController < ApplicationController
   def status
     respond_to do |format|
       format.json do
-        data = importable_data
+        data = ::BulkImports::GetImportableDataService.new(params, query_params, credentials).execute
 
         pagination_headers.each do |header|
-          response.set_header(header, data.headers[header])
+          response.set_header(header, data[:response].headers[header])
         end
 
-        render json: { importable_data: serialized_data(data.parsed_response) }
+        json_response = { importable_data: serialized_data(data[:response].parsed_response) }
+        json_response[:version_validation] = data[:version_validation]
+
+        render json: json_response
       end
       format.html do
         @source_url = session[url_key]
@@ -66,10 +69,6 @@ class Import::BulkImportsController < ApplicationController
     @serializer ||= BaseSerializer.new(current_user: current_user)
   end
 
-  def importable_data
-    client.get('groups', query_params)
-  end
-
   # Default query string params used to fetch groups from GitLab source instance
   #
   # top_level_only: fetch only top level groups (subgroups are fetched during import itself)
@@ -85,15 +84,6 @@ class Import::BulkImportsController < ApplicationController
     query_params
   end
 
-  def client
-    @client ||= BulkImports::Clients::HTTP.new(
-      url: session[url_key],
-      token: session[access_token_key],
-      per_page: params[:per_page],
-      page: params[:page]
-    )
-  end
-
   def configure_params
     params.permit(access_token_key, url_key)
   end

app/models/bulk_import.rb

@@ -4,7 +4,8 @@
 # projects to a GitLab instance. It associates the import with the responsible
 # user.
 class BulkImport < ApplicationRecord
-  MINIMUM_GITLAB_MAJOR_VERSION = 14
+  MIN_MAJOR_VERSION = 14
+  MIN_MINOR_VERSION_FOR_PROJECT = 4
 
   belongs_to :user, optional: false
 
@@ -34,6 +35,14 @@ class BulkImport < ApplicationRecord
     end
   end
 
+  def source_version_info
+    Gitlab::VersionInfo.parse(source_version)
+  end
+
+  def self.min_gl_version_for_project_migration
+    Gitlab::VersionInfo.new(MIN_MAJOR_VERSION, MIN_MINOR_VERSION_FOR_PROJECT)
+  end
+
   def self.all_human_statuses
     state_machine.states.map(&:human_name)
   end

app/models/bulk_imports/entity.rb

@@ -83,9 +83,9 @@ class BulkImports::Entity < ApplicationRecord
   def pipelines
     @pipelines ||= case source_type
                    when 'group_entity'
-                     BulkImports::Groups::Stage.pipelines
+                     BulkImports::Groups::Stage.new(bulk_import).pipelines
                    when 'project_entity'
-                     BulkImports::Projects::Stage.pipelines
+                     BulkImports::Projects::Stage.new(bulk_import).pipelines
                    end
   end
 

app/services/bulk_imports/create_service.rb

@@ -52,7 +52,11 @@ module BulkImports
 
     def create_bulk_import
       BulkImport.transaction do
-        bulk_import = BulkImport.create!(user: current_user, source_type: 'gitlab')
+        bulk_import = BulkImport.create!(
+          user: current_user,
+          source_type: 'gitlab',
+          source_version: client.instance_version
+        )
         bulk_import.create_configuration!(credentials.slice(:url, :access_token))
 
         params.each do |entity|
@@ -68,5 +72,12 @@ module BulkImports
         bulk_import
       end
     end
+
+    def client
+      @client ||= BulkImports::Clients::HTTP.new(
+        url: @credentials[:url],
+        token: @credentials[:access_token]
+      )
+    end
   end
 end

app/services/bulk_imports/get_importable_data_service.rb

+# frozen_string_literal: true
+
+module BulkImports
+  class GetImportableDataService
+    def initialize(params, query_params, credentials)
+      @params = params
+      @query_params = query_params
+      @credentials = credentials
+    end
+
+    def execute
+      {
+        version_validation: version_validation,
+        response: importables
+      }
+    end
+
+    private
+
+    def importables
+      client.get('groups', @query_params)
+    end
+
+    def version_validation
+      {
+        features: {
+          project_migration: {
+            available: client.compatible_for_project_migration?,
+            min_version: BulkImport.min_gl_version_for_project_migration.to_s
+          },
+          source_instance_version: client.instance_version.to_s
+        }
+      }
+    end
+
+    def client
+      @client ||= BulkImports::Clients::HTTP.new(
+        url: @credentials[:url],
+        token: @credentials[:access_token],
+        per_page: @params[:per_page],
+        page: @params[:page]
+      )
+    end
+  end
+end

db/migrate/20211001001222_add_source_version_to_bulk_imports.rb

+# frozen_string_literal: true
+
+class AddSourceVersionToBulkImports < Gitlab::Database::Migration[1.0]
+  def change
+    add_column :bulk_imports, :source_version, :text # rubocop:disable Migration/AddLimitToTextColumns
+  end
+end

db/migrate/20211012091822_add_text_limit_to_bulk_imports_source_version.rb

+# frozen_string_literal: true
+
+class AddTextLimitToBulkImportsSourceVersion < Gitlab::Database::Migration[1.0]
+  disable_ddl_transaction!
+
+  def up
+    add_text_limit :bulk_imports, :source_version, 63
+  end
+
+  def down
+    remove_text_limit :bulk_imports, :source_version
+  end
+end

db/schema_migrations/20211001001222

+23be5444bb11f731e98edc9b6aad814d02fd0f3f6be9abdea9060898cc2b95f1
\ No newline at end of file

db/schema_migrations/20211012091822

+3482e5c12f1603cb67d24aee14f003345ef2a5c350c7dccafdea6554db04c4cc
\ No newline at end of file

db/structure.sql

@@ -11216,7 +11216,9 @@ CREATE TABLE bulk_imports (
     source_type smallint NOT NULL,
     status smallint NOT NULL,
     created_at timestamp with time zone NOT NULL,
-    updated_at timestamp with time zone NOT NULL
+    updated_at timestamp with time zone NOT NULL,
+    source_version text,
+    CONSTRAINT check_ea4e58775a CHECK ((char_length(source_version) <= 63))
 );
 
 CREATE SEQUENCE bulk_imports_id_seq

ee/spec/lib/ee/bulk_imports/groups/stage_spec.rb

@@ -20,6 +20,12 @@ RSpec.describe BulkImports::Groups::Stage do
     ]
   end
 
+  subject do
+    bulk_import = build(:bulk_import)
+
+    described_class.new(bulk_import)
+  end
+
   describe '#each' do
     it 'iterates over all pipelines with the stage number' do
       expect(subject.pipelines).to match_array(pipelines)

lib/bulk_imports/clients/graphql.rb

@@ -57,7 +57,7 @@ module BulkImports
         response = client.execute('{ metadata { version } }')
         version = Gitlab::VersionInfo.parse(response.data.metadata.version)
 
-        if version.major < BulkImport::MINIMUM_GITLAB_MAJOR_VERSION
+        if version.major < BulkImport::MIN_MAJOR_VERSION
           raise ::BulkImports::Error.unsupported_gitlab_version
         else
           @compatible_instance_version = true

lib/bulk_imports/clients/http.rb

@@ -3,6 +3,8 @@
 module BulkImports
   module Clients
     class HTTP
+      include Gitlab::Utils::StrongMemoize
+
       API_VERSION = 'v4'
       DEFAULT_PAGE = 1
       DEFAULT_PER_PAGE = 30
@@ -52,24 +54,32 @@ module BulkImports
         Gitlab::Utils.append_path(api_url, resource)
       end
 
-      def validate_instance_version!
-        return if @compatible_instance_version
+      def instance_version
+        strong_memoize(:instance_version) do
+          response = with_error_handling do
+            Gitlab::HTTP.get(resource_url(:version), default_options)
+          end
 
-        response = with_error_handling do
-          Gitlab::HTTP.get(resource_url(:version), default_options)
+          Gitlab::VersionInfo.parse(response.parsed_response['version'])
         end
+      end
+
+      def compatible_for_project_migration?
+        instance_version >= BulkImport.min_gl_version_for_project_migration
+      end
 
-        version = Gitlab::VersionInfo.parse(response.parsed_response['version'])
+      private
+
+      def validate_instance_version!
+        return if @compatible_instance_version
 
-        if version.major < BulkImport::MINIMUM_GITLAB_MAJOR_VERSION
+        if instance_version.major < BulkImport::MIN_MAJOR_VERSION
           raise ::BulkImports::Error.unsupported_gitlab_version
         else
           @compatible_instance_version = true
         end
       end
 
-      private
-
       # rubocop:disable GitlabSecurity/PublicSend
       def request(method, resource, options = {}, &block)
         validate_instance_version!

lib/bulk_imports/error.rb

@@ -3,7 +3,7 @@
 module BulkImports
   class Error < StandardError
     def self.unsupported_gitlab_version
-      self.new("Unsupported GitLab Version. Minimum Supported Gitlab Version #{BulkImport::MINIMUM_GITLAB_MAJOR_VERSION}.")
+      self.new("Unsupported GitLab Version. Minimum Supported Gitlab Version #{BulkImport::MIN_MAJOR_VERSION}.")
     end
   end
 end

lib/bulk_imports/groups/stage.rb

@@ -47,7 +47,7 @@ module BulkImports
       end
 
       def project_entities_pipeline
-        if ::Feature.enabled?(:bulk_import_projects, default_enabled: :yaml)
+        if project_pipeline_available? && ::Feature.enabled?(:bulk_import_projects, default_enabled: :yaml)
           {
             project_entities: {
               pipeline: BulkImports::Groups::Pipelines::ProjectEntitiesPipeline,
@@ -58,6 +58,10 @@ module BulkImports
           {}
         end
       end
+
+      def project_pipeline_available?
+        @bulk_import.source_version_info >= BulkImport.min_gl_version_for_project_migration
+      end
     end
   end
 end

lib/bulk_imports/stage.rb

@@ -2,8 +2,10 @@
 
 module BulkImports
   class Stage
-    def self.pipelines
-      new.pipelines
+    def initialize(bulk_import)
+      raise(ArgumentError, 'Expected an argument of type ::BulkImport') unless bulk_import.is_a?(::BulkImport)
+
+      @bulk_import = bulk_import
     end
 
     def pipelines

spec/controllers/import/bulk_imports_controller_spec.rb

@@ -51,62 +51,87 @@ RSpec.describe Import::BulkImportsController do
       end
 
       describe 'GET status' do
+        def get_status(params_override = {})
+          params = { page: 1, per_page: 20, filter: '' }.merge(params_override)
+
+          get :status,
+              params: params,
+              format: :json,
+              session: {
+                bulk_import_gitlab_url: 'https://gitlab.example.com',
+                bulk_import_gitlab_access_token: 'demo-pat'
+              }
+        end
+
+        include_context 'bulk imports requests context', 'https://gitlab.example.com'
+
         let(:client) { BulkImports::Clients::HTTP.new(url: 'http://gitlab.example', token: 'token') }
+        let(:version) { "#{BulkImport::MIN_MAJOR_VERSION}.#{BulkImport::MIN_MINOR_VERSION_FOR_PROJECT}.0" }
+        let(:version_response) { double(code: 200, success?: true, parsed_response: { 'version' => version }) }
 
         describe 'serialized group data' do
-          let(:client_response) do
+          let(:expected_response) do
             double(
               parsed_response: [
-                { 'id' => 1, 'full_name' => 'group1', 'full_path' => 'full/path/group1', 'web_url' => 'http://demo.host/full/path/group1' },
-                { 'id' => 2, 'full_name' => 'group2', 'full_path' => 'full/path/group2', 'web_url' => 'http://demo.host/full/path/group1' }
+                {
+                  "full_name" => "Stub",
+                  "full_path" => "stub-group",
+                  "id" => 2595438,
+                  "web_url" => "https://gitlab.com/groups/auto-breakfast"
+                }
               ],
               headers: {
                 'x-next-page' => '2',
                 'x-page' => '1',
                 'x-per-page' => '20',
-                'x-total' => '37',
+                'x-total' => '42',
                 'x-total-pages' => '2'
               }
             )
           end
 
-          let(:client_params) do
-            {
-              top_level_only: true,
-              min_access_level: Gitlab::Access::OWNER
-            }
-          end
-
-          before do
-            allow(controller).to receive(:client).and_return(client)
-            allow(client).to receive(:get).with('groups', client_params).and_return(client_response)
-          end
-
           it 'returns serialized group data' do
-            get :status, format: :json
+            get_status
+
+            version_validation = {
+              "features" => {
+                "project_migration" => {
+                  "available" => true,
+                  "min_version" => BulkImport.min_gl_version_for_project_migration.to_s
+                },
+                "source_instance_version" => version
+              }
+            }
 
-            expect(json_response).to eq({ importable_data: client_response.parsed_response }.as_json)
+            expect(json_response).to include("importable_data" => expected_response.parsed_response, "version_validation" => hash_including(version_validation))
           end
 
           it 'forwards pagination headers' do
-            get :status, format: :json
-
-            expect(response.headers['x-per-page']).to eq client_response.headers['x-per-page']
-            expect(response.headers['x-page']).to eq client_response.headers['x-page']
-            expect(response.headers['x-next-page']).to eq client_response.headers['x-next-page']
-            expect(response.headers['x-prev-page']).to eq client_response.headers['x-prev-page']
-            expect(response.headers['x-total']).to eq client_response.headers['x-total']
-            expect(response.headers['x-total-pages']).to eq client_response.headers['x-total-pages']
+            get_status
+
+            expect(response.headers['x-per-page']).to eq expected_response.headers['x-per-page']
+            expect(response.headers['x-page']).to eq expected_response.headers['x-page']
+            expect(response.headers['x-next-page']).to eq expected_response.headers['x-next-page']
+            expect(response.headers['x-prev-page']).to eq expected_response.headers['x-prev-page']
+            expect(response.headers['x-total']).to eq expected_response.headers['x-total']
+            expect(response.headers['x-total-pages']).to eq expected_response.headers['x-total-pages']
           end
 
           context 'when filtering' do
-            it 'returns filtered result' do
-              filter = 'test'
-              search_params = client_params.merge(search: filter)
+            let_it_be(:filter) { 'test' }
 
-              expect(client).to receive(:get).with('groups', search_params).and_return(client_response)
+            let(:client_params) do
+              {
+                top_level_only: true,
+                min_access_level: Gitlab::Access::OWNER,
+                search: filter
+              }
+            end
+
+            it 'returns filtered result' do
+              get_status(filter: filter)
 
-              get :status, format: :json, params: { filter: filter }
+              expect(json_response['importable_data'].first['full_name']).to eq('Test')
             end
           end
         end
@@ -148,18 +173,19 @@ RSpec.describe Import::BulkImportsController do
 
         context 'when connection error occurs' do
           before do
-            allow(controller).to receive(:client).and_return(client)
-            allow(client).to receive(:get).and_raise(BulkImports::Error)
+            allow_next_instance_of(BulkImports::Clients::HTTP) do |instance|
+              allow(instance).to receive(:get).and_raise(BulkImports::Error)
+            end
           end
 
           it 'returns 422' do
-            get :status, format: :json
+            get_status
 
             expect(response).to have_gitlab_http_status(:unprocessable_entity)
           end
 
           it 'clears session' do
-            get :status, format: :json
+            get_status
 
             expect(session[:gitlab_url]).to be_nil
             expect(session[:gitlab_access_token]).to be_nil

spec/factories/bulk_import.rb

@@ -4,6 +4,7 @@ FactoryBot.define do
   factory :bulk_import, class: 'BulkImport' do
     user
     source_type { :gitlab }
+    source_version { BulkImport.min_gl_version_for_project_migration.to_s }
 
     trait :created do
       status { 0 }

spec/features/groups/import_export/connect_instance_spec.rb

@@ -19,34 +19,12 @@ RSpec.describe 'Import/Export - Connect to another instance', :js do
   end
 
   context 'when the user provides valid credentials' do
+    source_url = 'https://gitlab.com'
+
+    include_context 'bulk imports requests context', source_url
+
     it 'successfully connects to remote instance' do
-      source_url = 'https://gitlab.com'
       pat = 'demo-pat'
-      stub_path = 'stub-group'
-      total = 37
-
-      stub_request(:get, "%{url}/api/v4/groups?page=1&per_page=20&top_level_only=true&min_access_level=50&search=" % { url: source_url }).to_return(
-        body: [{
-          id: 2595438,
-          web_url: 'https://gitlab.com/groups/auto-breakfast',
-          name: 'Stub',
-          path: stub_path,
-          full_name: 'Stub',
-          full_path: stub_path
-        }].to_json,
-        headers: {
-          'Content-Type' => 'application/json',
-          'X-Next-Page' => 2,
-          'X-Page' => 1,
-          'X-Per-Page' => 20,
-          'X-Total' => total,
-          'X-Total-Pages' => 2
-        }
-      )
-
-      allow_next_instance_of(BulkImports::Clients::HTTP) do |client|
-        allow(client).to receive(:validate_instance_version!).and_return(true)
-      end
 
       expect(page).to have_content 'Import groups from another instance of GitLab'
       expect(page).to have_content 'Not all related objects are migrated'
@@ -56,8 +34,8 @@ RSpec.describe 'Import/Export - Connect to another instance', :js do
 
       click_on 'Connect instance'
 
-      expect(page).to have_content 'Showing 1-1 of %{total} groups from %{url}' % { url: source_url, total: total }
-      expect(page).to have_content stub_path
+      expect(page).to have_content 'Showing 1-1 of 42 groups from %{url}' % { url: source_url }
+      expect(page).to have_content 'stub-group'
 
       visit '/'
 

spec/lib/bulk_imports/clients/graphql_spec.rb

@@ -34,7 +34,7 @@ RSpec.describe BulkImports::Clients::Graphql do
       let(:version) { '13.0.0' }
 
       it 'raises an error' do
-        expect { subject.execute('test') }.to raise_error(::BulkImports::Error, "Unsupported GitLab Version. Minimum Supported Gitlab Version #{BulkImport::MINIMUM_GITLAB_MAJOR_VERSION}.")
+        expect { subject.execute('test') }.to raise_error(::BulkImports::Error, "Unsupported GitLab Version. Minimum Supported Gitlab Version #{BulkImport::MIN_MAJOR_VERSION}.")
       end
     end
   end

spec/lib/bulk_imports/clients/http_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe BulkImports::Clients::HTTP do
   let(:url) { 'http://gitlab.example' }
   let(:token) { 'token' }
   let(:resource) { 'resource' }
-  let(:version) { "#{BulkImport::MINIMUM_GITLAB_MAJOR_VERSION}.0.0" }
+  let(:version) { "#{BulkImport::MIN_MAJOR_VERSION}.0.0" }
   let(:response_double) { double(code: 200, success?: true, parsed_response: {}) }
   let(:version_response) { double(code: 200, success?: true, parsed_response: { 'version' => version }) }
 
@@ -176,6 +176,28 @@ RSpec.describe BulkImports::Clients::HTTP do
     end
   end
 
+  describe '#instance_version' do
+    it 'returns version as an instance of Gitlab::VersionInfo' do
+      expect(subject.instance_version).to eq(Gitlab::VersionInfo.parse(version))
+    end
+  end
+
+  describe '#compatible_for_project_migration?' do
+    context 'when instance version is lower the the expected minimum' do
+      it 'returns false' do
+        expect(subject.compatible_for_project_migration?).to be false
+      end
+    end
+
+    context 'when instance version is at least the expected minimum' do
+      let(:version) { "14.4.4" }
+
+      it 'returns true' do
+        expect(subject.compatible_for_project_migration?).to be true
+      end
+    end
+  end
+
   context 'when source instance is incompatible' do
     let(:version) { '13.0.0' }
 
@@ -183,7 +205,7 @@ RSpec.describe BulkImports::Clients::HTTP do
       expect { subject.get(resource) }
         .to raise_error(
           ::BulkImports::Error,
-          "Unsupported GitLab Version. Minimum Supported Gitlab Version #{BulkImport::MINIMUM_GITLAB_MAJOR_VERSION}."
+          "Unsupported GitLab Version. Minimum Supported Gitlab Version #{BulkImport::MIN_MAJOR_VERSION}."
         )
     end
   end

spec/lib/bulk_imports/groups/stage_spec.rb

@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe BulkImports::Groups::Stage do
+  let(:bulk_import) { build(:bulk_import) }
+
   let(:pipelines) do
     [
       [0, BulkImports::Groups::Pipelines::GroupPipeline],
@@ -16,23 +18,27 @@ RSpec.describe BulkImports::Groups::Stage do
     ]
   end
 
+  it 'raises error when initialized without a BulkImport' do
+    expect { described_class.new({}) }.to raise_error(ArgumentError, 'Expected an argument of type ::BulkImport')
+  end
+
   describe '.pipelines' do
     it 'list all the pipelines with their stage number, ordered by stage' do
-      expect(described_class.pipelines & pipelines).to eq(pipelines)
-      expect(described_class.pipelines.last.last).to eq(BulkImports::Common::Pipelines::EntityFinisher)
+      expect(described_class.new(bulk_import).pipelines & pipelines).to eq(pipelines)
+      expect(described_class.new(bulk_import).pipelines.last.last).to eq(BulkImports::Common::Pipelines::EntityFinisher)
     end
 
     it 'includes project entities pipeline' do
       stub_feature_flags(bulk_import_projects: true)
 
-      expect(described_class.pipelines).to include([1, BulkImports::Groups::Pipelines::ProjectEntitiesPipeline])
+      expect(described_class.new(bulk_import).pipelines).to include([1, BulkImports::Groups::Pipelines::ProjectEntitiesPipeline])
     end
 
     context 'when bulk_import_projects feature flag is disabled' do
       it 'does not include project entities pipeline' do
         stub_feature_flags(bulk_import_projects: false)
 
-        expect(described_class.pipelines.flatten).not_to include(BulkImports::Groups::Pipelines::ProjectEntitiesPipeline)
+        expect(described_class.new(bulk_import).pipelines.flatten).not_to include(BulkImports::Groups::Pipelines::ProjectEntitiesPipeline)
       end
     end
   end

spec/lib/bulk_imports/projects/stage_spec.rb

@@ -13,9 +13,15 @@ RSpec.describe BulkImports::Projects::Stage do
     ]
   end
 
-  describe '.pipelines' do
+  subject do
+    bulk_import = build(:bulk_import)
+
+    described_class.new(bulk_import)
+  end
+
+  describe '#pipelines' do
     it 'list all the pipelines with their stage number, ordered by stage' do
-      expect(described_class.pipelines).to eq(pipelines)
+      expect(subject.pipelines).to eq(pipelines)
     end
   end
 end

spec/models/bulk_import_spec.rb

@@ -21,4 +21,18 @@ RSpec.describe BulkImport, type: :model do
       expect(described_class.all_human_statuses).to contain_exactly('created', 'started', 'finished', 'failed')
     end
   end
+
+  describe '.min_gl_version_for_project' do
+    it { expect(described_class.min_gl_version_for_project_migration).to be_a(Gitlab::VersionInfo) }
+    it { expect(described_class.min_gl_version_for_project_migration.to_s).to eq('14.4.0') }
+  end
+
+  describe '#source_version_info' do
+    it 'returns source_version as Gitlab::VersionInfo' do
+      bulk_import = build(:bulk_import, source_version: '9.13.2')
+
+      expect(bulk_import.source_version_info).to be_a(Gitlab::VersionInfo)
+      expect(bulk_import.source_version_info.to_s).to eq(bulk_import.source_version)
+    end
+  end
 end

spec/models/bulk_imports/entity_spec.rb

@@ -179,7 +179,7 @@ RSpec.describe BulkImports::Entity, type: :model do
         entity = create(:bulk_import_entity, :group_entity)
         entity.create_pipeline_trackers!
 
-        expect(entity.trackers.count).to eq(BulkImports::Groups::Stage.pipelines.count)
+        expect(entity.trackers.count).to eq(BulkImports::Groups::Stage.new(entity.bulk_import).pipelines.count)
         expect(entity.trackers.map(&:pipeline_name)).to include(BulkImports::Groups::Pipelines::GroupPipeline.to_s)
       end
     end
@@ -189,7 +189,7 @@ RSpec.describe BulkImports::Entity, type: :model do
         entity = create(:bulk_import_entity, :project_entity)
         entity.create_pipeline_trackers!
 
-        expect(entity.trackers.count).to eq(BulkImports::Projects::Stage.pipelines.count)
+        expect(entity.trackers.count).to eq(BulkImports::Projects::Stage.new(entity.bulk_import).pipelines.count)
         expect(entity.trackers.map(&:pipeline_name)).to include(BulkImports::Projects::Pipelines::ProjectPipeline.to_s)
       end
     end

spec/models/bulk_imports/tracker_spec.rb

@@ -66,7 +66,8 @@ RSpec.describe BulkImports::Tracker, type: :model do
 
   describe '#pipeline_class' do
     it 'returns the pipeline class' do
-      pipeline_class = BulkImports::Groups::Stage.pipelines.first[1]
+      bulk_import = create(:bulk_import)
+      pipeline_class = BulkImports::Groups::Stage.new(bulk_import).pipelines.first[1]
       tracker = create(:bulk_import_tracker, pipeline_name: pipeline_class)
 
       expect(tracker.pipeline_class).to eq(pipeline_class)

spec/requests/api/bulk_imports_spec.rb

@@ -21,6 +21,15 @@ RSpec.describe API::BulkImports do
   end
 
   describe 'POST /bulk_imports' do
+    before do
+      allow_next_instance_of(BulkImports::Clients::HTTP) do |instance|
+        allow(instance)
+          .to receive(:instance_version)
+          .and_return(
+            Gitlab::VersionInfo.new(::BulkImport::MIN_MAJOR_VERSION, ::BulkImport::MIN_MINOR_VERSION_FOR_PROJECT))
+      end
+    end
+
     it 'starts a new migration' do
       post api('/bulk_imports', user), params: {
         configuration: {

spec/services/bulk_imports/create_service_spec.rb

@@ -31,8 +31,25 @@ RSpec.describe BulkImports::CreateService do
   subject { described_class.new(user, params, credentials) }
 
   describe '#execute' do
+    let_it_be(:source_version) do
+      Gitlab::VersionInfo.new(::BulkImport::MIN_MAJOR_VERSION,
+                              ::BulkImport::MIN_MINOR_VERSION_FOR_PROJECT)
+    end
+
+    before do
+      allow_next_instance_of(BulkImports::Clients::HTTP) do |instance|
+        allow(instance).to receive(:instance_version).and_return(source_version)
+      end
+    end
+
     it 'creates bulk import' do
       expect { subject.execute }.to change { BulkImport.count }.by(1)
+
+      last_bulk_import = BulkImport.last
+
+      expect(last_bulk_import.user).to eq(user)
+      expect(last_bulk_import.source_version).to eq(source_version.to_s)
+      expect(last_bulk_import.user).to eq(user)
     end
 
     it 'creates bulk import entities' do

spec/services/bulk_imports/get_importable_data_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BulkImports::GetImportableDataService do
+  describe '#execute' do
+    include_context 'bulk imports requests context', 'https://gitlab.example.com'
+
+    let_it_be(:params) { { per_page: 20, page: 1 } }
+    let_it_be(:query_params) { { top_level_only: true, min_access_level: 50, search: '' } }
+    let_it_be(:credentials) { { url: 'https://gitlab.example.com', access_token: 'demo-pat' } }
+    let_it_be(:expected_version_validation) do
+      {
+        features: {
+          project_migration: {
+            available: true,
+            min_version: BulkImport.min_gl_version_for_project_migration.to_s
+          },
+          'source_instance_version': BulkImport.min_gl_version_for_project_migration.to_s
+        }
+      }
+    end
+
+    let_it_be(:expected_parsed_response) do
+      [
+        {
+          'id' => 2595438,
+          'web_url' => 'https://gitlab.com/groups/auto-breakfast',
+          'name' => 'Stub',
+          'path' => 'stub-group',
+          'full_name' => 'Stub',
+          'full_path' => 'stub-group'
+        }
+      ]
+    end
+
+    subject do
+      described_class.new(params, query_params, credentials).execute
+    end
+
+    it 'returns version_validation and a response' do
+      expect(subject[:version_validation]).to eq(expected_version_validation)
+      expect(subject[:response].parsed_response).to eq(expected_parsed_response)
+    end
+  end
+end

spec/support/shared_contexts/bulk_imports_requests_shared_context.rb

+# frozen_string_literal: true
+
+RSpec.shared_context 'bulk imports requests context' do |url|
+  let(:page_response_headers) do
+    {
+      'Content-Type' => 'application/json',
+      'X-Next-Page' => 2,
+      'X-Page' => 1,
+      'X-Per-Page' => 20,
+      'X-Total' => 42,
+      'X-Total-Pages' => 2
+    }
+  end
+
+  let(:request_headers) { { 'Authorization' => 'Bearer demo-pat', 'Content-Type' => 'application/json' } }
+
+  before do
+    stub_request(:get, "#{url}/api/v4/version")
+      .with(headers: request_headers)
+      .to_return(
+        status: 200,
+        body: { version: ::BulkImport.min_gl_version_for_project_migration.to_s }.to_json,
+        headers: { 'Content-Type' => 'application/json' })
+
+    stub_request(:get, "https://gitlab.example.com/api/v4/groups?min_access_level=50&page=1&per_page=20&search=test&top_level_only=true")
+      .with(headers: request_headers)
+      .to_return(status: 200,
+        body: [{
+          id: 2595440,
+          web_url: 'https://gitlab.com/groups/test',
+          name: 'Test',
+          path: 'stub-test-group',
+          full_name: 'Test',
+          full_path: 'stub-test-group'
+        }].to_json,
+        headers: page_response_headers
+                )
+
+    stub_request(:get, "%{url}/api/v4/groups?page=1&per_page=20&top_level_only=true&min_access_level=50&search=" % { url: url })
+      .to_return(
+        body: [{
+          id: 2595438,
+          web_url: 'https://gitlab.com/groups/auto-breakfast',
+          name: 'Stub',
+          path: 'stub-group',
+          full_name: 'Stub',
+          full_path: 'stub-group'
+        }].to_json,
+        headers: page_response_headers
+      )
+  end
+end

spec/workers/bulk_import_worker_spec.rb

@@ -84,7 +84,7 @@ RSpec.describe BulkImportWorker do
 
         expect { subject.perform(bulk_import.id) }
           .to change(BulkImports::Tracker, :count)
-          .by(BulkImports::Groups::Stage.pipelines.size * 2)
+          .by(BulkImports::Groups::Stage.new(bulk_import).pipelines.size * 2)
 
         expect(entity_1.trackers).not_to be_empty
         expect(entity_2.trackers).not_to be_empty

spec/workers/bulk_imports/pipeline_worker_spec.rb

@@ -22,9 +22,10 @@ RSpec.describe BulkImports::PipelineWorker do
   before do
     stub_const('FakePipeline', pipeline_class)
 
-    allow(BulkImports::Groups::Stage)
-      .to receive(:pipelines)
-      .and_return([[0, pipeline_class]])
+    allow_next_instance_of(BulkImports::Groups::Stage) do |instance|
+      allow(instance).to receive(:pipelines)
+        .and_return([[0, pipeline_class]])
+    end
   end
 
   shared_examples 'successfully runs the pipeline' do
@@ -206,9 +207,10 @@ RSpec.describe BulkImports::PipelineWorker do
     before do
       stub_const('NdjsonPipeline', ndjson_pipeline)
 
-      allow(BulkImports::Groups::Stage)
-        .to receive(:pipelines)
-        .and_return([[0, ndjson_pipeline]])
+      allow_next_instance_of(BulkImports::Groups::Stage) do |instance|
+        allow(instance).to receive(:pipelines)
+                             .and_return([[0, ndjson_pipeline]])
+      end
     end
 
     it 'runs the pipeline successfully' do