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

57 files changed, 1180 insertions, 464 deletions

diff --git a/spec/graphql/features/authorization_spec.rb b/spec/graphql/features/authorization_spec.rb
index 6e5a8b9f4be..e40c44925e2 100644
--- a/spec/graphql/features/authorization_spec.rb
+++ b/spec/graphql/features/authorization_spec.rb
@@ -257,6 +257,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do
         type.field :id, GraphQL::ID_TYPE, null: false
       end
     end
+
     let(:project_type) do |type|
       type_factory do |type|
         type.graphql_name 'FakeProjectType'
@@ -264,11 +265,13 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do
                    resolve: -> (_, _, _) { Issue.where(project: [visible_project, other_project]).order(id: :asc) }
       end
     end
+
     let(:query_type) do
       query_factory do |query|
         query.field :test_project, project_type, null: false, resolve: -> (_, _, _) { visible_project }
       end
     end
+
     let(:query_string) do
       <<~QRY
         { testProject { testIssues(first: 3) { edges { node { id } } } } }
diff --git a/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb b/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb
new file mode 100644
index 00000000000..71c43ed826c
--- /dev/null
+++ b/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Mutations::Boards::Issues::IssueMoveList do
+  let_it_be(:group) { create(:group, :public) }
+  let_it_be(:project) { create(:project, group: group) }
+  let_it_be(:board) { create(:board, group: group) }
+  let_it_be(:user)  { create(:user) }
+  let_it_be(:guest) { create(:user) }
+  let_it_be(:development) { create(:label, project: project, name: 'Development') }
+  let_it_be(:testing) { create(:label, project: project, name: 'Testing') }
+  let_it_be(:list1)   { create(:list, board: board, label: development, position: 0) }
+  let_it_be(:list2)   { create(:list, board: board, label: testing, position: 1) }
+  let_it_be(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
+  let_it_be(:existing_issue1) { create(:labeled_issue, project: project, labels: [testing], relative_position: 10) }
+  let_it_be(:existing_issue2) { create(:labeled_issue, project: project, labels: [testing], relative_position: 50) }
+
+  let(:current_user) { user }
+  let(:mutation) { described_class.new(object: nil, context: { current_user: current_user }, field: nil) }
+  let(:params) { { board: board, project_path: project.full_path, iid: issue1.iid } }
+  let(:move_params) do
+    {
+      from_list_id: list1.id,
+      to_list_id: list2.id,
+      move_before_id: existing_issue2.id,
+      move_after_id: existing_issue1.id
+    }
+  end
+
+  before_all do
+    group.add_maintainer(user)
+    group.add_guest(guest)
+  end
+
+  subject do
+    mutation.resolve(params.merge(move_params))
+  end
+
+  describe '#ready?' do
+    it 'raises an error if required arguments are missing' do
+      expect { mutation.ready?(params) }
+        .to raise_error(Gitlab::Graphql::Errors::ArgumentError, "At least one of the arguments " \
+        "fromListId, toListId, afterId or beforeId is required")
+    end
+
+    it 'raises an error if only one of fromListId and toListId is present' do
+      expect { mutation.ready?(params.merge(from_list_id: list1.id)) }
+        .to raise_error(Gitlab::Graphql::Errors::ArgumentError,
+          'Both fromListId and toListId must be present'
+        )
+    end
+  end
+
+  describe '#resolve' do
+    context 'when user have access to resources' do
+      it 'moves and repositions issue' do
+        subject
+
+        expect(issue1.reload.labels).to eq([testing])
+        expect(issue1.relative_position).to be < existing_issue2.relative_position
+        expect(issue1.relative_position).to be > existing_issue1.relative_position
+      end
+    end
+
+    context 'when user have no access to resources' do
+      shared_examples 'raises a resource not available error' do
+        it { expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) }
+      end
+
+      context 'when user cannot update issue' do
+        let(:current_user) { guest }
+
+        it_behaves_like 'raises a resource not available error'
+      end
+
+      context 'when user cannot access board' do
+        let(:board) { create(:board, group: create(:group, :private)) }
+
+        it_behaves_like 'raises a resource not available error'
+      end
+
+      context 'when passing board_id as nil' do
+        let(:board) { nil }
+
+        it_behaves_like 'raises a resource not available error'
+      end
+    end
+  end
+end
diff --git a/spec/graphql/mutations/boards/lists/create_spec.rb b/spec/graphql/mutations/boards/lists/create_spec.rb
new file mode 100644
index 00000000000..1a881ac81e8
--- /dev/null
+++ b/spec/graphql/mutations/boards/lists/create_spec.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Mutations::Boards::Lists::Create do
+  include GraphqlHelpers
+
+  let_it_be(:group) { create(:group, :private) }
+  let_it_be(:board) { create(:board, group: group) }
+  let_it_be(:user)  { create(:user) }
+  let_it_be(:guest) { create(:user) }
+
+  let(:current_user) { user }
+  let(:mutation) { described_class.new(object: nil, context: { current_user: current_user }, field: nil) }
+  let(:list_create_params) { {} }
+
+  before_all do
+    group.add_reporter(user)
+    group.add_guest(guest)
+  end
+
+  subject { mutation.resolve(board_id: board.to_global_id.to_s, **list_create_params) }
+
+  describe '#ready?' do
+    it 'raises an error if required arguments are missing' do
+      expect { mutation.ready?({ board_id: 'some id' }) }
+        .to raise_error(Gitlab::Graphql::Errors::ArgumentError,
+                        'one and only one of backlog or labelId is required')
+    end
+
+    it 'raises an error if too many required arguments are specified' do
+      expect { mutation.ready?({ board_id: 'some id', backlog: true, label_id: 'some label' }) }
+        .to raise_error(Gitlab::Graphql::Errors::ArgumentError,
+                        'one and only one of backlog or labelId is required')
+    end
+  end
+
+  describe '#resolve' do
+    context 'with proper permissions' do
+      describe 'backlog list' do
+        let(:list_create_params) { { backlog: true } }
+
+        it 'creates one and only one backlog' do
+          expect { subject }.to change { board.lists.backlog.count }.from(0).to(1)
+          expect(board.lists.backlog.first.list_type).to eq 'backlog'
+
+          backlog_id = board.lists.backlog.first.id
+
+          expect { subject }.not_to change { board.lists.backlog.count }
+          expect(board.lists.backlog.last.id).to eq backlog_id
+        end
+      end
+
+      describe 'label list' do
+        let_it_be(:dev_label) do
+          create(:group_label, title: 'Development', color: '#FFAABB', group: group)
+        end
+
+        let(:list_create_params) { { label_id: dev_label.to_global_id.to_s } }
+
+        it 'creates a new issue board list for labels' do
+          expect { subject }.to change { board.lists.count }.from(1).to(2)
+
+          new_list = subject[:list]
+
+          expect(new_list.title).to eq dev_label.title
+          expect(new_list.position).to eq 0
+        end
+      end
+    end
+
+    context 'without proper permissions' do
+      let(:current_user) { guest }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+      end
+    end
+  end
+end
diff --git a/spec/graphql/mutations/boards/lists/update_spec.rb b/spec/graphql/mutations/boards/lists/update_spec.rb
new file mode 100644
index 00000000000..d5d8a2af6bf
--- /dev/null
+++ b/spec/graphql/mutations/boards/lists/update_spec.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Mutations::Boards::Lists::Update do
+  let_it_be(:group)    { create(:group, :private) }
+  let_it_be(:board)    { create(:board, group: group) }
+  let_it_be(:reporter) { create(:user) }
+  let_it_be(:guest)    { create(:user) }
+  let_it_be(:list)     { create(:list, board: board, position: 0) }
+  let_it_be(:list2)    { create(:list, board: board) }
+  let(:mutation) { described_class.new(object: nil, context: { current_user: current_user }, field: nil) }
+  let(:list_update_params) { { position: 1, collapsed: true } }
+
+  before_all do
+    group.add_reporter(reporter)
+    group.add_guest(guest)
+    list.update_preferences_for(reporter, collapsed: false)
+  end
+
+  subject { mutation.resolve(list: list, **list_update_params) }
+
+  describe '#resolve' do
+    context 'with permission to admin board lists' do
+      let(:current_user) { reporter }
+
+      it 'updates the list position and collapsed state as expected' do
+        subject
+
+        reloaded_list = list.reload
+        expect(reloaded_list.position).to eq(1)
+        expect(reloaded_list.collapsed?(current_user)).to eq(true)
+      end
+    end
+
+    context 'with permission to read board lists' do
+      let(:current_user) { guest }
+
+      it 'updates the list collapsed state but not the list position' do
+        subject
+
+        reloaded_list = list.reload
+        expect(reloaded_list.position).to eq(0)
+        expect(reloaded_list.collapsed?(current_user)).to eq(true)
+      end
+    end
+
+    context 'without permission to read board lists' do
+      let(:current_user) { create(:user) }
+
+      it 'raises Resource Not Found error' do
+        expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+      end
+    end
+  end
+end
diff --git a/spec/graphql/mutations/commits/create_spec.rb b/spec/graphql/mutations/commits/create_spec.rb
index bb0b8c577b0..fb1baafe7bd 100644
--- a/spec/graphql/mutations/commits/create_spec.rb
+++ b/spec/graphql/mutations/commits/create_spec.rb
@@ -147,7 +147,7 @@ RSpec.describe Mutations::Commits::Create do
 
         it 'returns errors' do
           expect(mutated_commit).to be_nil
-          expect(subject[:errors]).to eq(['3:UserCommitFiles: empty CommitMessage'])
+          expect(subject[:errors].to_s).to match(/3:UserCommitFiles: empty CommitMessage/)
         end
       end
 
diff --git a/spec/graphql/mutations/design_management/move_spec.rb b/spec/graphql/mutations/design_management/move_spec.rb
new file mode 100644
index 00000000000..7519347d07c
--- /dev/null
+++ b/spec/graphql/mutations/design_management/move_spec.rb
@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Mutations::DesignManagement::Move do
+  include DesignManagementTestHelpers
+
+  let_it_be(:issue) { create(:issue) }
+  let_it_be(:designs) { create_list(:design, 3, issue: issue) }
+  let_it_be(:developer) { create(:user, developer_projects: [issue.project]) }
+
+  let(:user) { developer }
+
+  let(:mutation) { described_class.new(object: nil, context: { current_user: user }, field: nil) }
+
+  let(:current_design) { designs.first }
+  let(:previous_design) { designs.second }
+  let(:next_design) { designs.third }
+
+  before do
+    enable_design_management
+  end
+
+  describe "#resolve" do
+    subject(:resolve) do
+      args = {
+        current_design: current_design.to_global_id,
+        previous_design: previous_design&.to_global_id,
+        next_design: next_design&.to_global_id
+      }.compact
+
+      mutation.resolve(args)
+    end
+
+    shared_examples "resource not available" do
+      it "raises an error" do
+        expect { resolve }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+      end
+    end
+
+    context 'when the feature is not available' do
+      before do
+        enable_design_management(false)
+      end
+
+      it_behaves_like 'resource not available'
+    end
+
+    %i[current_design previous_design next_design].each do |binding|
+      context "When #{binding} cannot be found" do
+        let(binding) { build_stubbed(:design) }
+
+        it_behaves_like 'resource not available'
+      end
+    end
+
+    context 'the service runs' do
+      before do
+        expect_next_instance_of(::DesignManagement::MoveDesignsService) do |service|
+          expect(service).to receive(:execute).and_return(service_result)
+        end
+      end
+
+      context 'raising an error' do
+        let(:service_result) { ServiceResponse.error(message: 'bang!') }
+
+        it 'reports the service-level error' do
+          expect(resolve).to include(errors: ['bang!'], design_collection: eq(issue.design_collection))
+        end
+      end
+
+      context 'successfully' do
+        let(:service_result) { ServiceResponse.success }
+
+        it 'reports the service-level error' do
+          expect(resolve).to include(errors: be_empty, design_collection: eq(issue.design_collection))
+        end
+      end
+    end
+  end
+end
diff --git a/spec/graphql/mutations/issues/set_assignees_spec.rb b/spec/graphql/mutations/issues/set_assignees_spec.rb
new file mode 100644
index 00000000000..77ba511b715
--- /dev/null
+++ b/spec/graphql/mutations/issues/set_assignees_spec.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Mutations::Issues::SetAssignees do
+  it_behaves_like 'an assignable resource' do
+    let_it_be(:resource, reload: true) { create(:issue) }
+  end
+end
diff --git a/spec/graphql/mutations/issues/set_subscription_spec.rb b/spec/graphql/mutations/issues/set_subscription_spec.rb
new file mode 100644
index 00000000000..9e05a136c0b
--- /dev/null
+++ b/spec/graphql/mutations/issues/set_subscription_spec.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Mutations::Issues::SetSubscription do
+  it_behaves_like 'a subscribeable graphql resource' do
+    let_it_be(:resource) { create(:issue) }
+    let(:permission_name) { :update_issue }
+  end
+end
diff --git a/spec/graphql/mutations/issues/update_spec.rb b/spec/graphql/mutations/issues/update_spec.rb
index 9a847476e2e..15c15afd9b7 100644
--- a/spec/graphql/mutations/issues/update_spec.rb
+++ b/spec/graphql/mutations/issues/update_spec.rb
@@ -3,16 +3,23 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::Issues::Update do
-  let(:issue) { create(:issue) }
-  let(:user) { create(:user) }
+  let_it_be(:project) { create(:project) }
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project_label) { create(:label, project: project) }
+  let_it_be(:issue) { create(:issue, project: project, labels: [project_label]) }
+  let_it_be(:milestone) { create(:milestone, project: project) }
+
   let(:expected_attributes) do
     {
       title: 'new title',
       description: 'new description',
       confidential: true,
-      due_date: Date.tomorrow
+      due_date: Date.tomorrow,
+      discussion_locked: true,
+      milestone_id: milestone.id
     }
   end
+
   let(:mutation) { described_class.new(object: nil, context: { current_user: user }, field: nil) }
   let(:mutated_issue) { subject[:issue] }
 
@@ -21,20 +28,22 @@ RSpec.describe Mutations::Issues::Update do
   describe '#resolve' do
     let(:mutation_params) do
       {
-        project_path: issue.project.full_path,
+        project_path: project.full_path,
         iid: issue.iid
       }.merge(expected_attributes)
     end
 
     subject { mutation.resolve(mutation_params) }
 
-    it 'raises an error if the resource is not accessible to the user' do
-      expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+    context 'when the user cannot access the issue' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+      end
     end
 
     context 'when the user can update the issue' do
       before do
-        issue.project.add_developer(user)
+        project.add_developer(user)
       end
 
       it 'updates issue with correct values' do
@@ -50,6 +59,62 @@ RSpec.describe Mutations::Issues::Update do
           expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
         end
       end
+
+      context 'when setting milestone to nil' do
+        let(:expected_attributes) { { milestone_id: nil } }
+
+        it 'changes the milestone corrrectly' do
+          issue.update_column(:milestone_id, milestone.id)
+
+          expect { subject }.to change { issue.reload.milestone }.from(milestone).to(nil)
+        end
+      end
+
+      context 'when changing labels' do
+        let_it_be(:label_1) { create(:label, project: project) }
+        let_it_be(:label_2) { create(:label, project: project) }
+        let_it_be(:external_label) { create(:label, project: create(:project)) }
+
+        it 'adds and removes labels correctly' do
+          mutation_params[:add_label_ids] = [label_1.id, label_2.id]
+          mutation_params[:remove_label_ids] = [project_label.id]
+
+          subject
+
+          expect(issue.reload.labels).to match_array([label_1, label_2])
+        end
+
+        it 'does not add label if label id is nil' do
+          mutation_params[:add_label_ids] = [nil, label_2.id]
+
+          subject
+
+          expect(issue.reload.labels).to match_array([project_label, label_2])
+        end
+
+        it 'does not add label if label is not found' do
+          mutation_params[:add_label_ids] = [external_label.id, label_2.id]
+
+          subject
+
+          expect(issue.reload.labels).to match_array([project_label, label_2])
+        end
+
+        it 'does not modify labels if label is already present' do
+          mutation_params[:add_label_ids] = [project_label.id]
+
+          expect(issue.reload.labels).to match_array([project_label])
+        end
+
+        it 'does not modify labels if label is addded and removed in the same request' do
+          mutation_params[:add_label_ids] = [label_1.id, label_2.id]
+          mutation_params[:remove_label_ids] = [label_1.id]
+
+          subject
+
+          expect(issue.reload.labels).to match_array([project_label, label_2])
+        end
+      end
     end
   end
 end
diff --git a/spec/graphql/mutations/merge_requests/create_spec.rb b/spec/graphql/mutations/merge_requests/create_spec.rb
index ae31790f1f9..ba0ac3cbe66 100644
--- a/spec/graphql/mutations/merge_requests/create_spec.rb
+++ b/spec/graphql/mutations/merge_requests/create_spec.rb
@@ -22,7 +22,8 @@ RSpec.describe Mutations::MergeRequests::Create do
         title: title,
         source_branch: source_branch,
         target_branch: target_branch,
-        description: description
+        description: description,
+        labels: labels
       )
     end
 
@@ -30,6 +31,7 @@ RSpec.describe Mutations::MergeRequests::Create do
     let(:source_branch) { 'feature' }
     let(:target_branch) { 'master' }
     let(:description) { nil }
+    let(:labels) { nil }
 
     let(:mutated_merge_request) { subject[:merge_request] }
 
@@ -70,6 +72,15 @@ RSpec.describe Mutations::MergeRequests::Create do
         end
       end
 
+      context 'when optional labels field is set' do
+        let(:labels) { %w[label-1 label-2] }
+
+        it 'returns a new merge request with labels' do
+          expect(mutated_merge_request.labels.map(&:title)).to eq(labels)
+          expect(subject[:errors]).to be_empty
+        end
+      end
+
       context 'when service cannot create a merge request' do
         let(:title) { nil }
 
diff --git a/spec/graphql/mutations/merge_requests/set_assignees_spec.rb b/spec/graphql/mutations/merge_requests/set_assignees_spec.rb
index 0e7abb849c4..4ac40fc09c6 100644
--- a/spec/graphql/mutations/merge_requests/set_assignees_spec.rb
+++ b/spec/graphql/mutations/merge_requests/set_assignees_spec.rb
@@ -3,106 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::MergeRequests::SetAssignees do
-  let(:merge_request) { create(:merge_request) }
-  let(:user) { create(:user) }
-
-  subject(:mutation) { described_class.new(object: nil, context: { current_user: user }, field: nil) }
-
-  describe '#resolve' do
-    let(:assignee) { create(:user) }
-    let(:assignee2) { create(:user) }
-    let(:assignee_usernames) { [assignee.username] }
-    let(:mutated_merge_request) { subject[:merge_request] }
-
-    subject { mutation.resolve(project_path: merge_request.project.full_path, iid: merge_request.iid, assignee_usernames: assignee_usernames) }
-
-    before do
-      merge_request.project.add_developer(assignee)
-      merge_request.project.add_developer(assignee2)
-    end
-
-    it 'raises an error if the resource is not accessible to the user' do
-      expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
-    end
-
-    context 'when the user can update the merge request' do
-      before do
-        merge_request.project.add_developer(user)
-      end
-
-      it 'replaces the assignee' do
-        merge_request.assignees = [assignee2]
-        merge_request.save!
-
-        expect(mutated_merge_request).to eq(merge_request)
-        expect(mutated_merge_request.assignees).to contain_exactly(assignee)
-        expect(subject[:errors]).to be_empty
-      end
-
-      it 'returns errors merge request could not be updated' do
-        # Make the merge request invalid
-        merge_request.allow_broken = true
-        merge_request.update!(source_project: nil)
-
-        expect(subject[:errors]).not_to be_empty
-      end
-
-      context 'when passing an empty assignee list' do
-        let(:assignee_usernames) { [] }
-
-        before do
-          merge_request.assignees = [assignee]
-          merge_request.save!
-        end
-
-        it 'removes all assignees' do
-          expect(mutated_merge_request).to eq(merge_request)
-          expect(mutated_merge_request.assignees).to eq([])
-          expect(subject[:errors]).to be_empty
-        end
-      end
-
-      context 'when passing "append" as true' do
-        subject { mutation.resolve(project_path: merge_request.project.full_path, iid: merge_request.iid, assignee_usernames: assignee_usernames, operation_mode: Types::MutationOperationModeEnum.enum[:append]) }
-
-        before do
-          merge_request.assignees = [assignee2]
-          merge_request.save!
-
-          # In CE, APPEND is a NOOP as you can't have multiple assignees
-          # We test multiple assignment in EE specs
-          stub_licensed_features(multiple_merge_request_assignees: false)
-        end
-
-        it 'is a NO-OP in FOSS' do
-          expect(mutated_merge_request).to eq(merge_request)
-          expect(mutated_merge_request.assignees).to contain_exactly(assignee2)
-          expect(subject[:errors]).to be_empty
-        end
-      end
-
-      context 'when passing "remove" as true' do
-        before do
-          merge_request.assignees = [assignee]
-          merge_request.save!
-        end
-
-        it 'removes named assignee' do
-          mutated_merge_request = mutation.resolve(project_path: merge_request.project.full_path, iid: merge_request.iid, assignee_usernames: assignee_usernames, operation_mode: Types::MutationOperationModeEnum.enum[:remove])[:merge_request]
-
-          expect(mutated_merge_request).to eq(merge_request)
-          expect(mutated_merge_request.assignees).to eq([])
-          expect(subject[:errors]).to be_empty
-        end
-
-        it 'does not remove unnamed assignee' do
-          mutated_merge_request = mutation.resolve(project_path: merge_request.project.full_path, iid: merge_request.iid, assignee_usernames: [assignee2.username], operation_mode: Types::MutationOperationModeEnum.enum[:remove])[:merge_request]
-
-          expect(mutated_merge_request).to eq(merge_request)
-          expect(mutated_merge_request.assignees).to contain_exactly(assignee)
-          expect(subject[:errors]).to be_empty
-        end
-      end
-    end
+  it_behaves_like 'an assignable resource' do
+    let_it_be(:resource, reload: true) { create(:merge_request) }
   end
 end
diff --git a/spec/graphql/mutations/merge_requests/set_subscription_spec.rb b/spec/graphql/mutations/merge_requests/set_subscription_spec.rb
index 20cfed9dd3d..600053637c9 100644
--- a/spec/graphql/mutations/merge_requests/set_subscription_spec.rb
+++ b/spec/graphql/mutations/merge_requests/set_subscription_spec.rb
@@ -3,44 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::MergeRequests::SetSubscription do
-  let(:merge_request) { create(:merge_request) }
-  let(:project) { merge_request.project }
-  let(:user) { create(:user) }
-
-  subject(:mutation) { described_class.new(object: nil, context: { current_user: user }, field: nil) }
-
-  specify { expect(described_class).to require_graphql_authorizations(:update_merge_request) }
-
-  describe '#resolve' do
-    let(:subscribe) { true }
-    let(:mutated_merge_request) { subject[:merge_request] }
-
-    subject { mutation.resolve(project_path: merge_request.project.full_path, iid: merge_request.iid, subscribed_state: subscribe) }
-
-    it 'raises an error if the resource is not accessible to the user' do
-      expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
-    end
-
-    context 'when the user can update the merge request' do
-      before do
-        merge_request.project.add_developer(user)
-      end
-
-      it 'returns the merge request as discussion locked' do
-        expect(mutated_merge_request).to eq(merge_request)
-        expect(mutated_merge_request.subscribed?(user, project)).to eq(true)
-        expect(subject[:errors]).to be_empty
-      end
-
-      context 'when passing subscribe as false' do
-        let(:subscribe) { false }
-
-        it 'unsubscribes from the discussion' do
-          merge_request.subscribe(user, project)
-
-          expect(mutated_merge_request.subscribed?(user, project)).to eq(false)
-        end
-      end
-    end
+  it_behaves_like 'a subscribeable graphql resource' do
+    let_it_be(:resource) { create(:merge_request) }
+    let(:permission_name) { :update_merge_request }
   end
 end
diff --git a/spec/graphql/resolvers/alert_management/alert_resolver_spec.rb b/spec/graphql/resolvers/alert_management/alert_resolver_spec.rb
index 0c1ba5aab2c..42830f0024d 100644
--- a/spec/graphql/resolvers/alert_management/alert_resolver_spec.rb
+++ b/spec/graphql/resolvers/alert_management/alert_resolver_spec.rb
@@ -7,8 +7,8 @@ RSpec.describe Resolvers::AlertManagement::AlertResolver do
 
   let_it_be(:current_user) { create(:user) }
   let_it_be(:project) { create(:project) }
-  let_it_be(:alert_1) { create(:alert_management_alert, :resolved, project: project, ended_at: 1.year.ago, events: 2, severity: :high) }
-  let_it_be(:alert_2) { create(:alert_management_alert, :ignored, project: project, events: 1, severity: :critical) }
+  let_it_be(:resolved_alert) { create(:alert_management_alert, :resolved, project: project, ended_at: 1.year.ago, events: 2, severity: :high) }
+  let_it_be(:ignored_alert) { create(:alert_management_alert, :ignored, project: project, events: 1, severity: :critical) }
   let_it_be(:alert_other_proj) { create(:alert_management_alert) }
 
   let(:args) { {} }
@@ -24,18 +24,18 @@ RSpec.describe Resolvers::AlertManagement::AlertResolver do
       project.add_developer(current_user)
     end
 
-    it { is_expected.to contain_exactly(alert_1, alert_2) }
+    it { is_expected.to contain_exactly(resolved_alert, ignored_alert) }
 
     context 'finding by iid' do
-      let(:args) { { iid: alert_1.iid } }
+      let(:args) { { iid: resolved_alert.iid } }
 
-      it { is_expected.to contain_exactly(alert_1) }
+      it { is_expected.to contain_exactly(resolved_alert) }
     end
 
     context 'finding by status' do
       let(:args) { { status: [Types::AlertManagement::StatusEnum.values['IGNORED'].value] } }
 
-      it { is_expected.to contain_exactly(alert_2) }
+      it { is_expected.to contain_exactly(ignored_alert) }
     end
 
     describe 'sorting' do
@@ -45,11 +45,11 @@ RSpec.describe Resolvers::AlertManagement::AlertResolver do
         let_it_be(:alert_count_3) { create(:alert_management_alert, project: project, events: 3) }
 
         it 'sorts alerts ascending' do
-          expect(resolve_alerts(sort: :event_count_asc)).to eq [alert_2, alert_1, alert_count_3, alert_count_6]
+          expect(resolve_alerts(sort: :event_count_asc)).to eq [ignored_alert, resolved_alert, alert_count_3, alert_count_6]
         end
 
         it 'sorts alerts descending' do
-          expect(resolve_alerts(sort: :event_count_desc)).to eq [alert_count_6, alert_count_3, alert_1, alert_2]
+          expect(resolve_alerts(sort: :event_count_desc)).to eq [alert_count_6, alert_count_3, resolved_alert, ignored_alert]
         end
       end
     end
diff --git a/spec/graphql/resolvers/board_list_issues_resolver_spec.rb b/spec/graphql/resolvers/board_list_issues_resolver_spec.rb
new file mode 100644
index 00000000000..e23a37b3d69
--- /dev/null
+++ b/spec/graphql/resolvers/board_list_issues_resolver_spec.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Resolvers::BoardListIssuesResolver do
+  include GraphqlHelpers
+
+  let_it_be(:user)          { create(:user) }
+  let_it_be(:unauth_user)   { create(:user) }
+  let_it_be(:user_project)  { create(:project, creator_id: user.id, namespace: user.namespace ) }
+  let_it_be(:group)         { create(:group, :private) }
+
+  shared_examples_for 'group and project board list issues resolver' do
+    let!(:board) { create(:board, resource_parent: board_parent) }
+
+    before do
+      board_parent.add_developer(user)
+    end
+
+    # auth is handled by the parent object
+    context 'when authorized' do
+      let!(:list) { create(:list, board: board, label: label) }
+
+      it 'returns the issues in the correct order' do
+        issue1 = create(:issue, project: project, labels: [label], relative_position: 10)
+        issue2 = create(:issue, project: project, labels: [label], relative_position: 12)
+        issue3 = create(:issue, project: project, labels: [label], relative_position: 10)
+
+        # by relative_position and then ID
+        issues = resolve_board_list_issues.items
+
+        expect(issues.map(&:id)).to eq [issue3.id, issue1.id, issue2.id]
+      end
+    end
+  end
+
+  describe '#resolve' do
+    context 'when project boards' do
+      let(:board_parent) { user_project }
+      let!(:label) { create(:label, project: project, name: 'project label') }
+      let(:project) { user_project }
+
+      it_behaves_like 'group and project board list issues resolver'
+    end
+
+    context 'when group boards' do
+      let(:board_parent) { group }
+      let!(:label) { create(:group_label, group: group, name: 'group label') }
+      let!(:project) { create(:project, :private, group: group) }
+
+      it_behaves_like 'group and project board list issues resolver'
+    end
+  end
+
+  def resolve_board_list_issues(args: {}, current_user: user)
+    resolve(described_class, obj: list, args: args, ctx: { current_user: current_user })
+  end
+end
diff --git a/spec/graphql/resolvers/board_lists_resolver_spec.rb b/spec/graphql/resolvers/board_lists_resolver_spec.rb
index f662e9a0f62..fb6a5ccb781 100644
--- a/spec/graphql/resolvers/board_lists_resolver_spec.rb
+++ b/spec/graphql/resolvers/board_lists_resolver_spec.rb
@@ -57,6 +57,30 @@ RSpec.describe Resolvers::BoardListsResolver do
           expect(lists.count).to eq 3
         end
       end
+
+      context 'when querying for a single list' do
+        it 'returns specified list' do
+          list = resolve_board_lists(args: { id: global_id_of(label_list) }).items
+
+          expect(list).to eq [label_list]
+        end
+
+        it 'returns empty result if list is not found' do
+          external_group = create(:group, :private)
+          external_board = create(:board, resource_parent: external_group )
+          external_label = create(:group_label, group: group)
+          external_list = create(:list, board: external_board, label: external_label)
+
+          list = resolve_board_lists(args: { id: global_id_of(external_list) }).items
+
+          expect(list).to eq List.none
+        end
+
+        it 'raises an argument error if list ID is not valid' do
+          expect { resolve_board_lists(args: { id: 'test' }).items }
+            .to raise_error(Gitlab::Graphql::Errors::ArgumentError)
+        end
+      end
     end
   end
 
diff --git a/spec/graphql/resolvers/ci_configuration/sast_resolver_spec.rb b/spec/graphql/resolvers/ci_configuration/sast_resolver_spec.rb
deleted file mode 100644
index de69ad5d450..00000000000
--- a/spec/graphql/resolvers/ci_configuration/sast_resolver_spec.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Resolvers::CiConfiguration::SastResolver do
-  include GraphqlHelpers
-
-  let_it_be(:user) { create(:user) }
-  let_it_be(:project) { create(:project) }
-
-  describe '#resolve' do
-    subject(:sast_config) { resolve(described_class, ctx: { current_user: user }, obj: project) }
-
-    it 'returns global variable informations related to SAST' do
-      expect(sast_config['global'].first['field']).to eql("SECURE_ANALYZERS_PREFIX")
-      expect(sast_config['global'].first['label']).to eql("Image prefix")
-      expect(sast_config['global'].first['type']).to eql("string")
-
-      expect(sast_config['pipeline'].first['field']).to eql("stage")
-      expect(sast_config['pipeline'].first['label']).to eql("Stage")
-      expect(sast_config['pipeline'].first['type']).to eql("dropdown")
-
-      expect(sast_config['analyzers'].first['name']).to eql("brakeman")
-      expect(sast_config['analyzers'].first['label']).to eql("Brakeman")
-      expect(sast_config['analyzers'].first['enabled']).to be true
-    end
-  end
-end
diff --git a/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb b/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb
index 20a0cb842a4..a408981c08e 100644
--- a/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb
+++ b/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb
@@ -18,6 +18,7 @@ RSpec.describe Resolvers::CommitPipelinesResolver do
       status: 'success'
     )
   end
+
   let!(:pipeline2) do
     create(
       :ci_pipeline,
@@ -27,6 +28,7 @@ RSpec.describe Resolvers::CommitPipelinesResolver do
       status: 'failed'
     )
   end
+
   let!(:pipeline3) do
     create(
       :ci_pipeline,
diff --git a/spec/graphql/resolvers/group_issues_resolver_spec.rb b/spec/graphql/resolvers/group_issues_resolver_spec.rb
new file mode 100644
index 00000000000..463cdca699b
--- /dev/null
+++ b/spec/graphql/resolvers/group_issues_resolver_spec.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Resolvers::GroupIssuesResolver do
+  include GraphqlHelpers
+
+  let_it_be(:current_user) { create(:user) }
+
+  let_it_be(:group)         { create(:group) }
+  let_it_be(:project)       { create(:project, group: group) }
+  let_it_be(:other_project) { create(:project, group: group) }
+  let_it_be(:subgroup)      { create(:group, parent: group) }
+  let_it_be(:subproject)    { create(:project, group: subgroup) }
+
+  let_it_be(:issue1)    { create(:incident, project: project, state: :opened, created_at: 3.hours.ago, updated_at: 3.hours.ago) }
+  let_it_be(:issue2)    { create(:issue, project: project, state: :closed, title: 'foo', created_at: 1.hour.ago, updated_at: 1.hour.ago, closed_at: 1.hour.ago) }
+  let_it_be(:issue3)    { create(:issue, project: other_project, state: :closed, title: 'foo', created_at: 1.hour.ago, updated_at: 1.hour.ago, closed_at: 1.hour.ago) }
+  let_it_be(:issue4)    { create(:issue) }
+
+  let_it_be(:subissue1) { create(:issue, project: subproject) }
+  let_it_be(:subissue2) { create(:issue, project: subproject) }
+  let_it_be(:subissue3) { create(:issue, project: subproject) }
+
+  before_all do
+    group.add_developer(current_user)
+    subgroup.add_developer(current_user)
+  end
+
+  describe '#resolve' do
+    it 'finds all group issues' do
+      result = resolve(described_class, obj: group, ctx: { current_user: current_user })
+
+      expect(result).to contain_exactly(issue1, issue2, issue3)
+    end
+
+    it 'finds all group and subgroup issues' do
+      result = resolve(described_class, obj: group, args: { include_subgroups: true }, ctx: { current_user: current_user })
+
+      expect(result).to contain_exactly(issue1, issue2, issue3, subissue1, subissue2, subissue3)
+    end
+  end
+end
diff --git a/spec/graphql/resolvers/group_milestones_resolver_spec.rb b/spec/graphql/resolvers/group_milestones_resolver_spec.rb
new file mode 100644
index 00000000000..05d0ec38192
--- /dev/null
+++ b/spec/graphql/resolvers/group_milestones_resolver_spec.rb
@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Resolvers::GroupMilestonesResolver do
+  include GraphqlHelpers
+
+  describe '#resolve' do
+    let_it_be(:current_user) { create(:user) }
+
+    def resolve_group_milestones(args = {}, context = { current_user: current_user })
+      resolve(described_class, obj: group, args: args, ctx: context)
+    end
+
+    let_it_be(:now) { Time.now }
+    let_it_be(:group) { create(:group, :private) }
+
+    before_all do
+      group.add_developer(current_user)
+    end
+
+    it 'calls MilestonesFinder#execute' do
+      expect_next_instance_of(MilestonesFinder) do |finder|
+        expect(finder).to receive(:execute)
+      end
+
+      resolve_group_milestones
+    end
+
+    context 'without parameters' do
+      it 'calls MilestonesFinder to retrieve all milestones' do
+        expect(MilestonesFinder).to receive(:new)
+          .with(ids: nil, group_ids: group.id, state: 'all', start_date: nil, end_date: nil)
+          .and_call_original
+
+        resolve_group_milestones
+      end
+    end
+
+    context 'with parameters' do
+      it 'calls MilestonesFinder with correct parameters' do
+        start_date = now
+        end_date = start_date + 1.hour
+
+        expect(MilestonesFinder).to receive(:new)
+          .with(ids: nil, group_ids: group.id, state: 'closed', start_date: start_date, end_date: end_date)
+          .and_call_original
+
+        resolve_group_milestones(start_date: start_date, end_date: end_date, state: 'closed')
+      end
+    end
+
+    context 'by ids' do
+      it 'calls MilestonesFinder with correct parameters' do
+        milestone = create(:milestone, group: group)
+
+        expect(MilestonesFinder).to receive(:new)
+          .with(ids: [milestone.id.to_s], group_ids: group.id, state: 'all', start_date: nil, end_date: nil)
+          .and_call_original
+
+        resolve_group_milestones(ids: [milestone.to_global_id])
+      end
+    end
+
+    context 'by timeframe' do
+      context 'when start_date and end_date are present' do
+        context 'when start date is after end_date' do
+          it 'raises error' do
+            expect do
+              resolve_group_milestones(start_date: now, end_date: now - 2.days)
+            end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, "startDate is after endDate")
+          end
+        end
+      end
+
+      context 'when only start_date is present' do
+        it 'raises error' do
+          expect do
+            resolve_group_milestones(start_date: now)
+          end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, /Both startDate and endDate/)
+        end
+      end
+
+      context 'when only end_date is present' do
+        it 'raises error' do
+          expect do
+            resolve_group_milestones(end_date: now)
+          end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, /Both startDate and endDate/)
+        end
+      end
+    end
+
+    context 'when user cannot read milestones' do
+      it 'raises error' do
+        unauthorized_user = create(:user)
+
+        expect do
+          resolve_group_milestones({}, { current_user: unauthorized_user })
+        end.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+      end
+    end
+
+    context 'when including descendant milestones in a public group' do
+      let_it_be(:group) { create(:group, :public) }
+      let(:args) { { include_descendants: true } }
+
+      it 'finds milestones only in accessible projects and groups' do
+        accessible_group = create(:group, :private, parent: group)
+        accessible_project = create(:project, group: accessible_group)
+        accessible_group.add_developer(current_user)
+        inaccessible_group = create(:group, :private, parent: group)
+        inaccessible_project = create(:project, :private, group: group)
+        milestone1 = create(:milestone, group: group)
+        milestone2 = create(:milestone, group: accessible_group)
+        milestone3 = create(:milestone, project: accessible_project)
+        create(:milestone, group: inaccessible_group)
+        create(:milestone, project: inaccessible_project)
+
+        expect(resolve_group_milestones(args)).to match_array([milestone1, milestone2, milestone3])
+      end
+    end
+  end
+end
diff --git a/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb b/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb
new file mode 100644
index 00000000000..d2412db35c6
--- /dev/null
+++ b/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb
@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Resolvers::IssueStatusCountsResolver do
+  include GraphqlHelpers
+
+  describe '#resolve' do
+    let_it_be(:current_user) { create(:user) }
+    let_it_be(:project) { create(:project) }
+    let_it_be(:issue)    { create(:issue, project: project, state: :opened, created_at: 3.hours.ago, updated_at: 3.hours.ago) }
+    let_it_be(:incident) { create(:incident, project: project, state: :closed, created_at: 1.hour.ago, updated_at: 1.hour.ago, closed_at: 1.hour.ago) }
+
+    let(:args) { {} }
+
+    before do
+      project.add_developer(current_user)
+    end
+
+    subject { resolve_issue_status_counts(args) }
+
+    it { is_expected.to be_a(Gitlab::IssuablesCountForState) }
+    specify { expect(subject.project).to eq(project) }
+
+    it 'returns expected results' do
+      result = resolve_issue_status_counts
+
+      expect(result.all).to eq 2
+      expect(result.opened).to eq 1
+      expect(result.closed).to eq 1
+    end
+
+    it 'filters by search', :aggregate_failures do
+      result = resolve_issue_status_counts(search: issue.title)
+
+      expect(result.all).to eq 1
+      expect(result.opened).to eq 1
+      expect(result.closed).to eq 0
+    end
+
+    it 'filters by issue type', :aggregate_failures do
+      result = resolve_issue_status_counts(issue_types: ['incident'])
+
+      expect(result.all).to eq 1
+      expect(result.opened).to eq 0
+      expect(result.closed).to eq 1
+    end
+
+    # The state param is ignored in IssuableFinder#count_by_state
+    it 'ignores state filter', :aggregate_failures do
+      result = resolve_issue_status_counts(state: 'closed')
+
+      expect(result.all).to eq 2
+      expect(result.opened).to eq 1
+      expect(result.closed).to eq 1
+    end
+
+    private
+
+    def resolve_issue_status_counts(args = {}, context = { current_user: current_user })
+      resolve(described_class, obj: project, args: args, ctx: context)
+    end
+  end
+end
diff --git a/spec/graphql/resolvers/issues_resolver_spec.rb b/spec/graphql/resolvers/issues_resolver_spec.rb
index eb17e94a450..db5d009f0e7 100644
--- a/spec/graphql/resolvers/issues_resolver_spec.rb
+++ b/spec/graphql/resolvers/issues_resolver_spec.rb
@@ -13,7 +13,7 @@ RSpec.describe Resolvers::IssuesResolver do
 
   let_it_be(:milestone) { create(:milestone, project: project) }
   let_it_be(:assignee)  { create(:user) }
-  let_it_be(:issue1)    { create(:issue, project: project, state: :opened, created_at: 3.hours.ago, updated_at: 3.hours.ago, milestone: milestone) }
+  let_it_be(:issue1)    { create(:incident, project: project, state: :opened, created_at: 3.hours.ago, updated_at: 3.hours.ago, milestone: milestone) }
   let_it_be(:issue2)    { create(:issue, project: project, state: :closed, title: 'foo', created_at: 1.hour.ago, updated_at: 1.hour.ago, closed_at: 1.hour.ago, assignees: [assignee]) }
   let_it_be(:issue3)    { create(:issue, project: other_project, state: :closed, title: 'foo', created_at: 1.hour.ago, updated_at: 1.hour.ago, closed_at: 1.hour.ago, assignees: [assignee]) }
   let_it_be(:issue4)    { create(:issue) }
@@ -95,6 +95,20 @@ RSpec.describe Resolvers::IssuesResolver do
         end
       end
 
+      describe 'filters by issue_type' do
+        it 'filters by a single type' do
+          expect(resolve_issues(issue_types: ['incident'])).to contain_exactly(issue1)
+        end
+
+        it 'filters by more than one type' do
+          expect(resolve_issues(issue_types: %w(incident issue))).to contain_exactly(issue1, issue2)
+        end
+
+        it 'ignores the filter if none given' do
+          expect(resolve_issues(issue_types: [])).to contain_exactly(issue1, issue2)
+        end
+      end
+
       context 'when searching issues' do
         it 'returns correct issues' do
           expect(resolve_issues(search: 'foo')).to contain_exactly(issue2)
diff --git a/spec/graphql/resolvers/merge_requests_resolver_spec.rb b/spec/graphql/resolvers/merge_requests_resolver_spec.rb
index 0a8fd82613a..e939edae779 100644
--- a/spec/graphql/resolvers/merge_requests_resolver_spec.rb
+++ b/spec/graphql/resolvers/merge_requests_resolver_spec.rb
@@ -161,6 +161,24 @@ RSpec.describe Resolvers::MergeRequestsResolver do
       end
     end
 
+    context 'by merged_after and merged_before' do
+      before do
+        merge_request_1.metrics.update!(merged_at: 10.days.ago)
+      end
+
+      it 'returns merge requests merged between the given period' do
+        result = resolve_mr(project, merged_after: 20.days.ago, merged_before: 5.days.ago)
+
+        expect(result).to eq([merge_request_1])
+      end
+
+      it 'does not return anything' do
+        result = resolve_mr(project, merged_after: 2.days.ago)
+
+        expect(result).to be_empty
+      end
+    end
+
     describe 'combinations' do
       it 'requires all filters' do
         create(:merge_request, :closed, source_project: project, target_project: project, source_branch: merge_request_4.source_branch)
diff --git a/spec/graphql/resolvers/milestone_resolver_spec.rb b/spec/graphql/resolvers/milestone_resolver_spec.rb
deleted file mode 100644
index 36dd5ef03e2..00000000000
--- a/spec/graphql/resolvers/milestone_resolver_spec.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Resolvers::MilestoneResolver do
-  include GraphqlHelpers
-
-  describe '#resolve' do
-    let_it_be(:current_user) { create(:user) }
-
-    def resolve_group_milestones(args = {}, context = { current_user: current_user })
-      resolve(described_class, obj: group, args: args, ctx: context)
-    end
-
-    context 'for group milestones' do
-      let_it_be(:now) { Time.now }
-      let_it_be(:group) { create(:group, :private) }
-
-      before do
-        group.add_developer(current_user)
-      end
-
-      it 'calls MilestonesFinder#execute' do
-        expect_next_instance_of(MilestonesFinder) do |finder|
-          expect(finder).to receive(:execute)
-        end
-
-        resolve_group_milestones
-      end
-
-      context 'without parameters' do
-        it 'calls MilestonesFinder to retrieve all milestones' do
-          expect(MilestonesFinder).to receive(:new)
-            .with(group_ids: group.id, state: 'all', start_date: nil, end_date: nil)
-            .and_call_original
-
-          resolve_group_milestones
-        end
-      end
-
-      context 'with parameters' do
-        it 'calls MilestonesFinder with correct parameters' do
-          start_date = now
-          end_date = start_date + 1.hour
-
-          expect(MilestonesFinder).to receive(:new)
-            .with(group_ids: group.id, state: 'closed', start_date: start_date, end_date: end_date)
-            .and_call_original
-
-          resolve_group_milestones(start_date: start_date, end_date: end_date, state: 'closed')
-        end
-      end
-
-      context 'by timeframe' do
-        context 'when start_date and end_date are present' do
-          context 'when start date is after end_date' do
-            it 'raises error' do
-              expect do
-                resolve_group_milestones(start_date: now, end_date: now - 2.days)
-              end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, "startDate is after endDate")
-            end
-          end
-        end
-
-        context 'when only start_date is present' do
-          it 'raises error' do
-            expect do
-              resolve_group_milestones(start_date: now)
-            end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, /Both startDate and endDate/)
-          end
-        end
-
-        context 'when only end_date is present' do
-          it 'raises error' do
-            expect do
-              resolve_group_milestones(end_date: now)
-            end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, /Both startDate and endDate/)
-          end
-        end
-      end
-
-      context 'when user cannot read milestones' do
-        it 'raises error' do
-          unauthorized_user = create(:user)
-
-          expect do
-            resolve_group_milestones({}, { current_user: unauthorized_user })
-          end.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
-        end
-      end
-    end
-
-    context 'when including descendant milestones in a public group' do
-      let_it_be(:group) { create(:group, :public) }
-      let(:args) { { include_descendants: true } }
-
-      it 'finds milestones only in accessible projects and groups' do
-        accessible_group = create(:group, :private, parent: group)
-        accessible_project = create(:project, group: accessible_group)
-        accessible_group.add_developer(current_user)
-        inaccessible_group = create(:group, :private, parent: group)
-        inaccessible_project = create(:project, :private, group: group)
-        milestone1 = create(:milestone, group: group)
-        milestone2 = create(:milestone, group: accessible_group)
-        milestone3 = create(:milestone, project: accessible_project)
-        create(:milestone, group: inaccessible_group)
-        create(:milestone, project: inaccessible_project)
-
-        expect(resolve_group_milestones(args)).to match_array([milestone1, milestone2, milestone3])
-      end
-    end
-  end
-end
diff --git a/spec/graphql/resolvers/project_milestones_resolver_spec.rb b/spec/graphql/resolvers/project_milestones_resolver_spec.rb
new file mode 100644
index 00000000000..e0b250cfe7c
--- /dev/null
+++ b/spec/graphql/resolvers/project_milestones_resolver_spec.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Resolvers::ProjectMilestonesResolver do
+  include GraphqlHelpers
+
+  describe '#resolve' do
+    let_it_be(:project) { create(:project, :private) }
+    let_it_be(:current_user) { create(:user) }
+
+    before_all do
+      project.add_developer(current_user)
+    end
+
+    def resolve_project_milestones(args = {}, context = { current_user: current_user })
+      resolve(described_class, obj: project, args: args, ctx: context)
+    end
+
+    it 'calls MilestonesFinder to retrieve all milestones' do
+      expect(MilestonesFinder).to receive(:new)
+        .with(ids: nil, project_ids: project.id, state: 'all', start_date: nil, end_date: nil)
+        .and_call_original
+
+      resolve_project_milestones
+    end
+
+    context 'when including ancestor milestones' do
+      let(:parent_group) { create(:group) }
+      let(:group) { create(:group, parent: parent_group) }
+      let(:project) { create(:project, group: group) }
+
+      before do
+        project.add_developer(current_user)
+      end
+
+      it 'calls MilestonesFinder with correct parameters' do
+        expect(MilestonesFinder).to receive(:new)
+          .with(ids: nil, project_ids: project.id, group_ids: contain_exactly(group, parent_group), state: 'all', start_date: nil, end_date: nil)
+          .and_call_original
+
+        resolve_project_milestones(include_ancestors: true)
+      end
+    end
+
+    context 'by ids' do
+      it 'calls MilestonesFinder with correct parameters' do
+        milestone = create(:milestone, project: project)
+
+        expect(MilestonesFinder).to receive(:new)
+          .with(ids: [milestone.id.to_s], project_ids: project.id, state: 'all', start_date: nil, end_date: nil)
+          .and_call_original
+
+        resolve_project_milestones(ids: [milestone.to_global_id])
+      end
+    end
+
+    context 'by state' do
+      it 'calls MilestonesFinder with correct parameters' do
+        expect(MilestonesFinder).to receive(:new)
+          .with(ids: nil, project_ids: project.id, state: 'closed', start_date: nil, end_date: nil)
+          .and_call_original
+
+        resolve_project_milestones(state: 'closed')
+      end
+    end
+
+    context 'by timeframe' do
+      context 'when start_date and end_date are present' do
+        it 'calls MilestonesFinder with correct parameters' do
+          start_date = Time.now
+          end_date = Time.now + 5.days
+
+          expect(MilestonesFinder).to receive(:new)
+            .with(ids: nil, project_ids: project.id, state: 'all', start_date: start_date, end_date: end_date)
+            .and_call_original
+
+          resolve_project_milestones(start_date: start_date, end_date: end_date)
+        end
+
+        context 'when start date is after end_date' do
+          it 'raises error' do
+            expect do
+              resolve_project_milestones(start_date: Time.now, end_date: Time.now - 2.days)
+            end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, "startDate is after endDate")
+          end
+        end
+      end
+
+      context 'when only start_date is present' do
+        it 'raises error' do
+          expect do
+            resolve_project_milestones(start_date: Time.now)
+          end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, /Both startDate and endDate/)
+        end
+      end
+
+      context 'when only end_date is present' do
+        it 'raises error' do
+          expect do
+            resolve_project_milestones(end_date: Time.now)
+          end.to raise_error(Gitlab::Graphql::Errors::ArgumentError, /Both startDate and endDate/)
+        end
+      end
+    end
+
+    context 'when user cannot read milestones' do
+      it 'raises error' do
+        unauthorized_user = create(:user)
+
+        expect do
+          resolve_project_milestones({}, { current_user: unauthorized_user })
+        end.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable)
+      end
+    end
+  end
+end
diff --git a/spec/graphql/resolvers/project_pipeline_resolver_spec.rb b/spec/graphql/resolvers/project_pipeline_resolver_spec.rb
index a659b3bdb6e..fada2f9193c 100644
--- a/spec/graphql/resolvers/project_pipeline_resolver_spec.rb
+++ b/spec/graphql/resolvers/project_pipeline_resolver_spec.rb
@@ -33,4 +33,21 @@ RSpec.describe Resolvers::ProjectPipelineResolver do
   it 'errors when no iid is passed' do
     expect { resolve_pipeline(project, {}) }.to raise_error(ArgumentError)
   end
+
+  context 'when the pipeline is not a ci_config_source' do
+    let(:pipeline) do
+      config_source_value = Ci::PipelineEnums.non_ci_config_source_values.first
+      config_source = Ci::PipelineEnums.config_sources.key(config_source_value)
+
+      create(:ci_pipeline, config_source: config_source, project: project)
+    end
+
+    it 'resolves pipeline for the passed iid' do
+      result = batch_sync do
+        resolve_pipeline(project, { iid: pipeline.iid.to_s })
+      end
+
+      expect(result).to eq(pipeline)
+    end
+  end
 end
diff --git a/spec/graphql/resolvers/projects/jira_projects_resolver_spec.rb b/spec/graphql/resolvers/projects/jira_projects_resolver_spec.rb
index 4038bcb3e5d..840aea8b8c4 100644
--- a/spec/graphql/resolvers/projects/jira_projects_resolver_spec.rb
+++ b/spec/graphql/resolvers/projects/jira_projects_resolver_spec.rb
@@ -17,7 +17,7 @@ RSpec.describe Resolvers::Projects::JiraProjectsResolver do
       end
     end
 
-    context 'when project has no jira service' do
+    context 'when project has no Jira service' do
       let_it_be(:jira_service) { nil }
 
       context 'when user is a maintainer' do
@@ -29,7 +29,7 @@ RSpec.describe Resolvers::Projects::JiraProjectsResolver do
       end
     end
 
-    context 'when project has jira service' do
+    context 'when project has Jira service' do
       let(:jira_service) { create(:jira_service, project: project) }
 
       context 'when user is a developer' do
@@ -46,10 +46,11 @@ RSpec.describe Resolvers::Projects::JiraProjectsResolver do
         end
 
         context 'when Jira connection is valid' do
-          include_context 'jira projects request context'
+          include_context 'Jira projects request context'
 
-          it 'returns jira projects' do
-            jira_projects = resolve_jira_projects
+          it 'returns Jira projects', :aggregate_failures do
+            resolver = resolve_jira_projects
+            jira_projects = resolver.items
             project_keys = jira_projects.map(&:key)
             project_names = jira_projects.map(&:name)
             project_ids = jira_projects.map(&:id)
@@ -58,6 +59,23 @@ RSpec.describe Resolvers::Projects::JiraProjectsResolver do
             expect(project_keys).to eq(%w(EX ABC))
             expect(project_names).to eq(%w(Example Alphabetical))
             expect(project_ids).to eq(%w(10000 10001))
+            expect(resolver.max_page_size).to eq(2)
+          end
+
+          context 'when filtering projects by name' do
+            it 'returns Jira projects', :aggregate_failures do
+              resolver = resolve_jira_projects({ name: 'ABC' })
+              jira_projects = resolver.items
+              project_keys = jira_projects.map(&:key)
+              project_names = jira_projects.map(&:name)
+              project_ids = jira_projects.map(&:id)
+
+              expect(jira_projects.size).to eq 1
+              expect(project_keys).to eq(%w(ABC))
+              expect(project_names).to eq(%w(Alphabetical))
+              expect(project_ids).to eq(%w(10001))
+              expect(resolver.max_page_size).to eq(1)
+            end
           end
         end
 
diff --git a/spec/graphql/resolvers/todo_resolver_spec.rb b/spec/graphql/resolvers/todo_resolver_spec.rb
index 0775cb8dae7..83e3140b676 100644
--- a/spec/graphql/resolvers/todo_resolver_spec.rb
+++ b/spec/graphql/resolvers/todo_resolver_spec.rb
@@ -99,7 +99,7 @@ RSpec.describe Resolvers::TodoResolver do
       end
     end
 
-    context 'when no user is provided' do
+    context 'when no target is provided' do
       it 'returns no todos' do
         todos = resolve(described_class, obj: nil, args: {}, ctx: { current_user: current_user })
 
@@ -107,7 +107,7 @@ RSpec.describe Resolvers::TodoResolver do
       end
     end
 
-    context 'when provided user is not current user' do
+    context 'when target user is not the current user' do
       it 'returns no todos' do
         other_user = create(:user)
 
@@ -116,6 +116,16 @@ RSpec.describe Resolvers::TodoResolver do
         expect(todos).to be_empty
       end
     end
+
+    context 'when request is for a todo target' do
+      it 'returns only the todos for the target' do
+        target = issue_todo_pending.target
+
+        todos = resolve(described_class, obj: target, args: {}, ctx: { current_user: current_user })
+
+        expect(todos).to contain_exactly(issue_todo_pending)
+      end
+    end
   end
 
   def resolve_todos(args = {}, context = { current_user: current_user })
diff --git a/spec/graphql/types/alert_management/alert_type_spec.rb b/spec/graphql/types/alert_management/alert_type_spec.rb
index 45ac673986d..e14c189d4b6 100644
--- a/spec/graphql/types/alert_management/alert_type_spec.rb
+++ b/spec/graphql/types/alert_management/alert_type_spec.rb
@@ -28,6 +28,10 @@ RSpec.describe GitlabSchema.types['AlertManagementAlert'] do
       notes
       discussions
       metrics_dashboard_url
+      runbook
+      todos
+      details_url
+      prometheus_alert
     ]
 
     expect(described_class).to have_graphql_fields(*expected_fields)
diff --git a/spec/graphql/types/board_list_type_spec.rb b/spec/graphql/types/board_list_type_spec.rb
index 046d1e92bfa..7976936fc1f 100644
--- a/spec/graphql/types/board_list_type_spec.rb
+++ b/spec/graphql/types/board_list_type_spec.rb
@@ -6,7 +6,7 @@ RSpec.describe GitlabSchema.types['BoardList'] do
   specify { expect(described_class.graphql_name).to eq('BoardList') }
 
   it 'has specific fields' do
-    expected_fields = %w[id list_type position label]
+    expected_fields = %w[id list_type position label issues_count issues]
 
     expect(described_class).to include_graphql_fields(*expected_fields)
   end
diff --git a/spec/graphql/types/ci/group_type_spec.rb b/spec/graphql/types/ci/group_type_spec.rb
new file mode 100644
index 00000000000..8d547b19af3
--- /dev/null
+++ b/spec/graphql/types/ci/group_type_spec.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Types::Ci::GroupType do
+  specify { expect(described_class.graphql_name).to eq('CiGroup') }
+
+  it 'exposes the expected fields' do
+    expected_fields = %i[
+      name
+      size
+      jobs
+    ]
+
+    expect(described_class).to have_graphql_fields(*expected_fields)
+  end
+end
diff --git a/spec/graphql/types/ci/job_type_spec.rb b/spec/graphql/types/ci/job_type_spec.rb
new file mode 100644
index 00000000000..faf3a95cf25
--- /dev/null
+++ b/spec/graphql/types/ci/job_type_spec.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Types::Ci::JobType do
+  specify { expect(described_class.graphql_name).to eq('CiJob') }
+
+  it 'exposes the expected fields' do
+    expected_fields = %i[
+      name
+      needs
+    ]
+
+    expect(described_class).to have_graphql_fields(*expected_fields)
+  end
+end
diff --git a/spec/graphql/types/ci/stage_type_spec.rb b/spec/graphql/types/ci/stage_type_spec.rb
new file mode 100644
index 00000000000..0c352ed27aa
--- /dev/null
+++ b/spec/graphql/types/ci/stage_type_spec.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Types::Ci::StageType do
+  specify { expect(described_class.graphql_name).to eq('CiStage') }
+
+  it 'exposes the expected fields' do
+    expected_fields = %i[
+      name
+      groups
+    ]
+
+    expect(described_class).to have_graphql_fields(*expected_fields)
+  end
+end
diff --git a/spec/graphql/types/ci_configuration/sast/analyzers_entity_type_spec.rb b/spec/graphql/types/ci_configuration/sast/analyzers_entity_type_spec.rb
deleted file mode 100644
index 34a22feeaf5..00000000000
--- a/spec/graphql/types/ci_configuration/sast/analyzers_entity_type_spec.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GitlabSchema.types['SastCiConfigurationAnalyzersEntity'] do
-  let(:fields) { %i[name label enabled description] }
-
-  it { expect(described_class.graphql_name).to eq('SastCiConfigurationAnalyzersEntity') }
-
-  it { expect(described_class).to have_graphql_fields(fields) }
-end
diff --git a/spec/graphql/types/ci_configuration/sast/entity_type_spec.rb b/spec/graphql/types/ci_configuration/sast/entity_type_spec.rb
deleted file mode 100644
index 7c6ad013d4a..00000000000
--- a/spec/graphql/types/ci_configuration/sast/entity_type_spec.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GitlabSchema.types['SastCiConfigurationEntity'] do
-  let(:fields) { %i[field label description type options default_value value] }
-
-  it { expect(described_class.graphql_name).to eq('SastCiConfigurationEntity') }
-
-  it { expect(described_class).to have_graphql_fields(fields) }
-end
diff --git a/spec/graphql/types/ci_configuration/sast/options_entity_spec.rb b/spec/graphql/types/ci_configuration/sast/options_entity_spec.rb
deleted file mode 100644
index c60c8b9c84a..00000000000
--- a/spec/graphql/types/ci_configuration/sast/options_entity_spec.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GitlabSchema.types['SastCiConfigurationOptionsEntity'] do
-  let(:fields) { %i[label value] }
-
-  it { expect(described_class.graphql_name).to eq('SastCiConfigurationOptionsEntity') }
-
-  it { expect(described_class).to have_graphql_fields(fields) }
-end
diff --git a/spec/graphql/types/ci_configuration/sast/type_spec.rb b/spec/graphql/types/ci_configuration/sast/type_spec.rb
deleted file mode 100644
index e7a8cd436e4..00000000000
--- a/spec/graphql/types/ci_configuration/sast/type_spec.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GitlabSchema.types['SastCiConfiguration'] do
-  let(:fields) { %i[global pipeline analyzers] }
-
-  it { expect(described_class.graphql_name).to eq('SastCiConfiguration') }
-
-  it { expect(described_class).to have_graphql_fields(fields) }
-end
diff --git a/spec/graphql/types/commit_type_spec.rb b/spec/graphql/types/commit_type_spec.rb
index 75984786972..d222287270d 100644
--- a/spec/graphql/types/commit_type_spec.rb
+++ b/spec/graphql/types/commit_type_spec.rb
@@ -9,8 +9,8 @@ RSpec.describe GitlabSchema.types['Commit'] do
 
   it 'contains attributes related to commit' do
     expect(described_class).to have_graphql_fields(
-      :id, :sha, :title, :description, :message, :title_html, :authored_date,
-      :author_name, :author_gravatar, :author, :web_url, :latest_pipeline,
+      :id, :sha, :title, :description, :description_html, :message, :title_html, :authored_date,
+      :author_name, :author_gravatar, :author, :web_url, :web_path, :latest_pipeline,
       :pipelines, :signature_html
     )
   end
diff --git a/spec/graphql/types/issue_connection_type_spec.rb b/spec/graphql/types/countable_connection_type_spec.rb
index af34611ecfe..af34611ecfe 100644
--- a/spec/graphql/types/issue_connection_type_spec.rb
+++ b/spec/graphql/types/countable_connection_type_spec.rb
diff --git a/spec/graphql/types/design_management/design_at_version_type_spec.rb b/spec/graphql/types/design_management/design_at_version_type_spec.rb
index 5a6292c924a..4d61ecf62cc 100644
--- a/spec/graphql/types/design_management/design_at_version_type_spec.rb
+++ b/spec/graphql/types/design_management/design_at_version_type_spec.rb
@@ -10,6 +10,7 @@ RSpec.describe GitlabSchema.types['DesignAtVersion'] do
       version = design.versions.first
       GitlabSchema.id_from_object(create(:design_at_version, design: design, version: version))
     end
+
     let_it_be(:object_id_b) { GitlabSchema.id_from_object(create(:design_at_version)) }
     let(:object_type) { ::Types::DesignManagement::DesignAtVersionType }
   end
diff --git a/spec/graphql/types/environment_type_spec.rb b/spec/graphql/types/environment_type_spec.rb
index f7522cb3e2c..abeeeba543f 100644
--- a/spec/graphql/types/environment_type_spec.rb
+++ b/spec/graphql/types/environment_type_spec.rb
@@ -7,11 +7,76 @@ RSpec.describe GitlabSchema.types['Environment'] do
 
   it 'has the expected fields' do
     expected_fields = %w[
-      name id state metrics_dashboard
+      name id state metrics_dashboard latest_opened_most_severe_alert
     ]
 
     expect(described_class).to have_graphql_fields(*expected_fields)
   end
 
   specify { expect(described_class).to require_graphql_authorizations(:read_environment) }
+
+  context 'when there is an environment' do
+    let_it_be(:project) { create(:project) }
+    let_it_be(:environment) { create(:environment, project: project) }
+    let_it_be(:user) { create(:user) }
+
+    subject { GitlabSchema.execute(query, context: { current_user: user }).as_json }
+
+    let(:query) do
+      %(
+        query {
+          project(fullPath: "#{project.full_path}") {
+            environment(name: "#{environment.name}") {
+              name
+              state
+            }
+          }
+        }
+      )
+    end
+
+    before do
+      project.add_developer(user)
+    end
+
+    it 'returns an environment' do
+      expect(subject['data']['project']['environment']['name']).to eq(environment.name)
+    end
+
+    context 'when query alert data for the environment' do
+      let_it_be(:query) do
+        %(
+          query {
+            project(fullPath: "#{project.full_path}") {
+              environment(name: "#{environment.name}") {
+                name
+                state
+                latestOpenedMostSevereAlert {
+                  severity
+                  title
+                  detailsUrl
+                  prometheusAlert {
+                    humanizedText
+                  }
+                }
+              }
+            }
+          }
+        )
+      end
+
+      it 'does not return alert information' do
+        expect(subject['data']['project']['environment']['latestOpenedMostSevereAlert']).to be_nil
+      end
+
+      context 'when alert is raised on the environment' do
+        let!(:prometheus_alert) { create(:prometheus_alert, project: project, environment: environment) }
+        let!(:alert) { create(:alert_management_alert, :triggered, :prometheus, project: project, environment: environment, prometheus_alert: prometheus_alert) }
+
+        it 'returns alert information' do
+          expect(subject['data']['project']['environment']['latestOpenedMostSevereAlert']['severity']).to eq(alert.severity.upcase)
+        end
+      end
+    end
+  end
 end
diff --git a/spec/graphql/types/group_type_spec.rb b/spec/graphql/types/group_type_spec.rb
index fb79e9bb85b..0b87805c2ef 100644
--- a/spec/graphql/types/group_type_spec.rb
+++ b/spec/graphql/types/group_type_spec.rb
@@ -16,7 +16,7 @@ RSpec.describe GitlabSchema.types['Group'] do
       web_url avatar_url share_with_group_lock project_creation_level
       subgroup_creation_level require_two_factor_authentication
       two_factor_grace_period auto_devops_enabled emails_disabled
-      mentions_disabled parent boards
+      mentions_disabled parent boards milestones
     ]
 
     expect(described_class).to include_graphql_fields(*expected_fields)
diff --git a/spec/graphql/types/issue_status_count_type_spec.rb b/spec/graphql/types/issue_status_count_type_spec.rb
new file mode 100644
index 00000000000..4e273d6415a
--- /dev/null
+++ b/spec/graphql/types/issue_status_count_type_spec.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe GitlabSchema.types['IssueStatusCountsType'] do
+  specify { expect(described_class.graphql_name).to eq('IssueStatusCountsType') }
+
+  it 'exposes the expected fields' do
+    expected_fields = %i[
+      all
+      opened
+      closed
+    ]
+
+    expect(described_class).to have_graphql_fields(*expected_fields)
+  end
+end
diff --git a/spec/graphql/types/issue_type_enum_spec.rb b/spec/graphql/types/issue_type_enum_spec.rb
new file mode 100644
index 00000000000..7ae5eb76f28
--- /dev/null
+++ b/spec/graphql/types/issue_type_enum_spec.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Types::IssueTypeEnum do
+  specify { expect(described_class.graphql_name).to eq('IssueType') }
+
+  it 'exposes all the existing issue type values' do
+    expect(described_class.values.keys).to include(
+      *%w[ISSUE INCIDENT]
+    )
+  end
+end
diff --git a/spec/graphql/types/issue_type_spec.rb b/spec/graphql/types/issue_type_spec.rb
index 4a86b07ab1c..24353f8fe3a 100644
--- a/spec/graphql/types/issue_type_spec.rb
+++ b/spec/graphql/types/issue_type_spec.rb
@@ -132,14 +132,14 @@ RSpec.describe GitlabSchema.types['Issue'] do
     let(:query) do
       %(
         query {
-          project(fullPath:"#{project.full_path}"){
-            issue(iid:"#{issue.iid}"){
+          project(fullPath: "#{project.full_path}") {
+            issue(iid: "#{issue.iid}") {
               descriptionHtml
-              notes{
-                edges{
-                  node{
+              notes {
+                edges {
+                  node {
                     bodyHtml
-                    author{
+                    author {
                       username
                     }
                     body
diff --git a/spec/graphql/types/merge_request_type_spec.rb b/spec/graphql/types/merge_request_type_spec.rb
index b3dccde8ce3..b11951190e0 100644
--- a/spec/graphql/types/merge_request_type_spec.rb
+++ b/spec/graphql/types/merge_request_type_spec.rb
@@ -24,9 +24,11 @@ RSpec.describe GitlabSchema.types['MergeRequest'] do
       source_branch_exists target_branch_exists
       upvotes downvotes head_pipeline pipelines task_completion_status
       milestone assignees participants subscribed labels discussion_locked time_estimate
-      total_time_spent reference author merged_at
+      total_time_spent reference author merged_at commit_count
     ]
 
+    expected_fields << 'approved_by' if Gitlab.ee?
+
     expect(described_class).to have_graphql_fields(*expected_fields)
   end
 end
diff --git a/spec/graphql/types/project_type_spec.rb b/spec/graphql/types/project_type_spec.rb
index ea88ed6a3f5..8a5d0cdf12d 100644
--- a/spec/graphql/types/project_type_spec.rb
+++ b/spec/graphql/types/project_type_spec.rb
@@ -22,11 +22,12 @@ RSpec.describe GitlabSchema.types['Project'] do
       only_allow_merge_if_pipeline_succeeds request_access_enabled
       only_allow_merge_if_all_discussions_are_resolved printing_merge_request_link_enabled
       namespace group statistics repository merge_requests merge_request issues
-      issue pipelines removeSourceBranchAfterMerge sentryDetailedError snippets
+      issue milestones pipelines removeSourceBranchAfterMerge sentryDetailedError snippets
       grafanaIntegration autocloseReferencedIssues suggestion_commit_message environments
-      boards jira_import_status jira_imports services releases release
+      environment boards jira_import_status jira_imports services releases release
       alert_management_alerts alert_management_alert alert_management_alert_status_counts
-      container_expiration_policy sast_ci_configuration service_desk_enabled service_desk_address
+      container_expiration_policy service_desk_enabled service_desk_address
+      issue_status_counts
     ]
 
     expect(described_class).to include_graphql_fields(*expected_fields)
@@ -69,7 +70,9 @@ RSpec.describe GitlabSchema.types['Project'] do
                                             :before,
                                             :after,
                                             :first,
-                                            :last
+                                            :last,
+                                            :merged_after,
+                                            :merged_before
                                            )
     end
   end
@@ -95,6 +98,13 @@ RSpec.describe GitlabSchema.types['Project'] do
     it { is_expected.to have_graphql_resolver(Resolvers::EnvironmentsResolver) }
   end
 
+  describe 'environment field' do
+    subject { described_class.fields['environment'] }
+
+    it { is_expected.to have_graphql_type(Types::EnvironmentType) }
+    it { is_expected.to have_graphql_resolver(Resolvers::EnvironmentsResolver.single) }
+  end
+
   describe 'members field' do
     subject { described_class.fields['projectMembers'] }
 
@@ -140,93 +150,5 @@ RSpec.describe GitlabSchema.types['Project'] do
     it { is_expected.to have_graphql_type(Types::ContainerExpirationPolicyType) }
   end
 
-  describe 'sast_ci_configuration' do
-    let_it_be(:project) { create(:project) }
-    let_it_be(:user) { create(:user) }
-    let_it_be(:query) do
-      %(
-        query {
-            project(fullPath: "#{project.full_path}") {
-                sastCiConfiguration {
-                  global {
-                    nodes {
-                      type
-                      options {
-                        nodes {
-                          label
-                          value
-                        }
-                      }
-                      field
-                      label
-                      defaultValue
-                      value
-                    }
-                  }
-                  pipeline {
-                    nodes {
-                      type
-                      options {
-                        nodes {
-                          label
-                          value
-                        }
-                      }
-                      field
-                      label
-                      defaultValue
-                      value
-                    }
-                  }
-                  analyzers {
-                    nodes {
-                      name
-                      label
-                      enabled
-                    }
-                  }
-                }
-              }
-        }
-      )
-    end
-
-    subject { GitlabSchema.execute(query, context: { current_user: user }).as_json }
-
-    before do
-      project.add_developer(user)
-    end
-
-    it "returns the project's sast configuration for global variables" do
-      query_result = subject.dig('data', 'project', 'sastCiConfiguration', 'global', 'nodes')
-      first_config = query_result.first
-      fourth_config = query_result[3]
-      expect(first_config['type']).to eq('string')
-      expect(first_config['field']).to eq('SECURE_ANALYZERS_PREFIX')
-      expect(first_config['label']).to eq('Image prefix')
-      expect(first_config['defaultValue']).to eq('registry.gitlab.com/gitlab-org/security-products/analyzers')
-      expect(first_config['value']).to eq('')
-      expect(first_config['options']).to be_nil
-      expect(fourth_config['options']['nodes']).to match([{ "value" => "true", "label" => "true (disables SAST)" },
-                                                          { "value" => "false", "label" => "false (enables SAST)" }])
-    end
-
-    it "returns the project's sast configuration for pipeline variables" do
-      configuration = subject.dig('data', 'project', 'sastCiConfiguration', 'pipeline', 'nodes').first
-      expect(configuration['type']).to eq('dropdown')
-      expect(configuration['field']).to eq('stage')
-      expect(configuration['label']).to eq('Stage')
-      expect(configuration['defaultValue']).to eq('test')
-      expect(configuration['value']).to eq('')
-    end
-
-    it "returns the project's sast configuration for analyzer variables" do
-      configuration = subject.dig('data', 'project', 'sastCiConfiguration', 'analyzers', 'nodes').first
-      expect(configuration['name']).to eq('brakeman')
-      expect(configuration['label']).to eq('Brakeman')
-      expect(configuration['enabled']).to eq(true)
-    end
-  end
-
   it_behaves_like 'a GraphQL type with labels'
 end
diff --git a/spec/graphql/types/prometheus_alert_type_spec.rb b/spec/graphql/types/prometheus_alert_type_spec.rb
new file mode 100644
index 00000000000..716537ea716
--- /dev/null
+++ b/spec/graphql/types/prometheus_alert_type_spec.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe GitlabSchema.types['PrometheusAlert'] do
+  specify { expect(described_class.graphql_name).to eq('PrometheusAlert') }
+
+  it 'has the expected fields' do
+    expected_fields = %w[
+      id humanized_text
+    ]
+
+    expect(described_class).to have_graphql_fields(*expected_fields)
+  end
+
+  specify { expect(described_class).to require_graphql_authorizations(:read_prometheus_alerts) }
+end
diff --git a/spec/graphql/types/query_type_spec.rb b/spec/graphql/types/query_type_spec.rb
index 081f99a8307..ab13162b406 100644
--- a/spec/graphql/types/query_type_spec.rb
+++ b/spec/graphql/types/query_type_spec.rb
@@ -17,6 +17,7 @@ RSpec.describe GitlabSchema.types['Query'] do
       current_user
       snippets
       design_management
+      milestone
       user
       users
     ]
diff --git a/spec/graphql/types/snippet_type_spec.rb b/spec/graphql/types/snippet_type_spec.rb
index 0341ca2c733..86af69f1294 100644
--- a/spec/graphql/types/snippet_type_spec.rb
+++ b/spec/graphql/types/snippet_type_spec.rb
@@ -33,6 +33,7 @@ RSpec.describe GitlabSchema.types['Snippet'] do
         }
       )
     end
+
     let(:response) { subject.dig('data', 'snippets', 'nodes')[0] }
 
     subject { GitlabSchema.execute(query, context: { current_user: current_user }).as_json }
@@ -97,6 +98,7 @@ RSpec.describe GitlabSchema.types['Snippet'] do
         }
       )
     end
+
     let(:response) { subject.dig('data', 'snippets', 'nodes')[0] }
 
     subject { GitlabSchema.execute(query, context: { current_user: user }).as_json }
diff --git a/spec/graphql/types/snippets/file_input_action_enum_spec.rb b/spec/graphql/types/snippets/blob_action_enum_spec.rb
index ff9b706240b..9c641bd5446 100644
--- a/spec/graphql/types/snippets/file_input_action_enum_spec.rb
+++ b/spec/graphql/types/snippets/blob_action_enum_spec.rb
@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-RSpec.describe Types::Snippets::FileInputActionEnum do
-  specify { expect(described_class.graphql_name).to eq('SnippetFileInputActionEnum') }
+RSpec.describe Types::Snippets::BlobActionEnum do
+  specify { expect(described_class.graphql_name).to eq('SnippetBlobActionEnum') }
 
   it 'exposes all file input action types' do
     expect(described_class.values.keys).to eq(%w[create update delete move])
diff --git a/spec/graphql/types/snippets/file_input_type_spec.rb b/spec/graphql/types/snippets/blob_action_input_type_spec.rb
index c7d4909b542..5d6bd81fb77 100644
--- a/spec/graphql/types/snippets/file_input_type_spec.rb
+++ b/spec/graphql/types/snippets/blob_action_input_type_spec.rb
@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 
-RSpec.describe Types::Snippets::FileInputType do
-  specify { expect(described_class.graphql_name).to eq('SnippetFileInputType') }
+RSpec.describe Types::Snippets::BlobActionInputType do
+  specify { expect(described_class.graphql_name).to eq('SnippetBlobActionInputType') }
 
   it 'has the correct arguments' do
     expect(described_class.arguments.keys).to match_array(%w[filePath action previousPath content])
   end
 
-  it 'sets the type of action argument to FileInputActionEnum' do
-    expect(described_class.arguments['action'].type.of_type).to eq(Types::Snippets::FileInputActionEnum)
+  it 'sets the type of action argument to BlobActionEnum' do
+    expect(described_class.arguments['action'].type.of_type).to eq(Types::Snippets::BlobActionEnum)
   end
 end
diff --git a/spec/graphql/types/snippets/blob_viewer_type_spec.rb b/spec/graphql/types/snippets/blob_viewer_type_spec.rb
index 8210eb9a95c..295df992c67 100644
--- a/spec/graphql/types/snippets/blob_viewer_type_spec.rb
+++ b/spec/graphql/types/snippets/blob_viewer_type_spec.rb
@@ -44,7 +44,7 @@ RSpec.describe GitlabSchema.types['SnippetBlobViewer'] do
       let(:query) do
         %(
           query {
-            snippets(ids:"#{snippet.to_global_id}"){
+            snippets(ids: "#{snippet.to_global_id}") {
               edges {
                 node {
                   blob {
@@ -70,7 +70,7 @@ RSpec.describe GitlabSchema.types['SnippetBlobViewer'] do
       let(:query) do
         %(
           query {
-            snippets(ids:"#{snippet.to_global_id}"){
+            snippets(ids: "#{snippet.to_global_id}") {
               edges {
                 node {
                   blob {
diff --git a/spec/graphql/types/time_type_spec.rb b/spec/graphql/types/time_type_spec.rb
index 68d346766c2..3b0d257e1d7 100644
--- a/spec/graphql/types/time_type_spec.rb
+++ b/spec/graphql/types/time_type_spec.rb
@@ -15,4 +15,14 @@ RSpec.describe GitlabSchema.types['Time'] do
   it 'coerces an ISO-time into Time object' do
     expect(described_class.coerce_isolated_input(iso)).to eq(time)
   end
+
+  it 'rejects invalid input' do
+    expect { described_class.coerce_isolated_input('not valid') }
+      .to raise_error(GraphQL::CoercionError)
+  end
+
+  it 'rejects nil' do
+    expect { described_class.coerce_isolated_input(nil) }
+      .to raise_error(GraphQL::CoercionError)
+  end
 end
diff --git a/spec/graphql/types/tree/blob_type_spec.rb b/spec/graphql/types/tree/blob_type_spec.rb
index 73d61d4860c..2b08b528e38 100644
--- a/spec/graphql/types/tree/blob_type_spec.rb
+++ b/spec/graphql/types/tree/blob_type_spec.rb
@@ -5,5 +5,5 @@ require 'spec_helper'
 RSpec.describe Types::Tree::BlobType do
   specify { expect(described_class.graphql_name).to eq('Blob') }
 
-  specify { expect(described_class).to have_graphql_fields(:id, :sha, :name, :type, :path, :flat_path, :web_url, :lfs_oid, :mode) }
+  specify { expect(described_class).to have_graphql_fields(:id, :sha, :name, :type, :path, :flat_path, :web_url, :web_path, :lfs_oid, :mode) }
 end
diff --git a/spec/graphql/types/tree/tree_entry_type_spec.rb b/spec/graphql/types/tree/tree_entry_type_spec.rb
index 0e5caf66854..82e05b299fc 100644
--- a/spec/graphql/types/tree/tree_entry_type_spec.rb
+++ b/spec/graphql/types/tree/tree_entry_type_spec.rb
@@ -5,5 +5,5 @@ require 'spec_helper'
 RSpec.describe Types::Tree::TreeEntryType do
   specify { expect(described_class.graphql_name).to eq('TreeEntry') }
 
-  specify { expect(described_class).to have_graphql_fields(:id, :sha, :name, :type, :path, :flat_path, :web_url) }
+  specify { expect(described_class).to have_graphql_fields(:id, :sha, :name, :type, :path, :flat_path, :web_url, :web_path) }
 end
diff --git a/spec/graphql/types/user_status_type_spec.rb b/spec/graphql/types/user_status_type_spec.rb
new file mode 100644
index 00000000000..c4421a9cc10
--- /dev/null
+++ b/spec/graphql/types/user_status_type_spec.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Types::UserStatusType do
+  specify { expect(described_class.graphql_name).to eq('UserStatus') }
+
+  it 'exposes the expected fields' do
+    expected_fields = %i[
+      emoji
+      message
+      message_html
+    ]
+
+    expect(described_class).to have_graphql_fields(*expected_fields)
+  end
+end
diff --git a/spec/graphql/types/user_type_spec.rb b/spec/graphql/types/user_type_spec.rb
index 6cc3f7bcaa1..7710b8efefe 100644
--- a/spec/graphql/types/user_type_spec.rb
+++ b/spec/graphql/types/user_type_spec.rb
@@ -14,10 +14,13 @@ RSpec.describe GitlabSchema.types['User'] do
       snippets
       name
       username
+      email
       avatarUrl
       webUrl
+      webPath
       todos
       state
+      status
       authoredMergeRequests
       assignedMergeRequests
       groupMemberships