diff options
Diffstat (limited to 'spec/graphql')
75 files changed, 1279 insertions, 296 deletions
diff --git a/spec/graphql/features/authorization_spec.rb b/spec/graphql/features/authorization_spec.rb index e40c44925e2..ec67ed16fe9 100644 --- a/spec/graphql/features/authorization_spec.rb +++ b/spec/graphql/features/authorization_spec.rb @@ -55,7 +55,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do describe 'with a single permission' do let(:query_type) do query_factory do |query| - query.field :item, type, null: true, resolve: ->(obj, args, ctx) { test_object }, authorize: permission_single + query.field :item, type, null: true, resolver: simple_resolver(test_object), authorize: permission_single end end @@ -66,7 +66,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do let(:query_type) do permissions = permission_collection query_factory do |qt| - qt.field :item, type, null: true, resolve: ->(obj, args, ctx) { test_object } do + qt.field :item, type, null: true, resolver: simple_resolver(test_object) do authorize permissions end end @@ -79,7 +79,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do describe 'Field authorizations when field is a built in type' do let(:query_type) do query_factory do |query| - query.field :item, type, null: true, resolve: ->(obj, args, ctx) { test_object } + query.field :item, type, null: true, resolver: simple_resolver(test_object) end end @@ -132,7 +132,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do describe 'Type authorizations' do let(:query_type) do query_factory do |query| - query.field :item, type, null: true, resolve: ->(obj, args, ctx) { test_object } + query.field :item, type, null: true, resolver: simple_resolver(test_object) end end @@ -169,7 +169,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do let(:query_type) do query_factory do |query| - query.field :item, type, null: true, resolve: ->(obj, args, ctx) { test_object }, authorize: permission_2 + query.field :item, type, null: true, resolver: simple_resolver(test_object), authorize: permission_2 end end @@ -188,7 +188,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do let(:query_type) do query_factory do |query| - query.field :item, type.connection_type, null: true, resolve: ->(obj, args, ctx) { [test_object, second_test_object] } + query.field :item, type.connection_type, null: true, resolver: simple_resolver([test_object, second_test_object]) end end @@ -208,9 +208,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do describe 'limiting connections with multiple objects' do let(:query_type) do query_factory do |query| - query.field :item, type.connection_type, null: true, resolve: ->(obj, args, ctx) do - [test_object, second_test_object] - end + query.field :item, type.connection_type, null: true, resolver: simple_resolver([test_object, second_test_object]) end end @@ -234,7 +232,7 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do let(:query_type) do query_factory do |query| - query.field :item, [type], null: true, resolve: ->(obj, args, ctx) { [test_object] } + query.field :item, [type], null: true, resolver: simple_resolver([test_object]) end end @@ -262,13 +260,13 @@ RSpec.describe 'Gitlab::Graphql::Authorization' do type_factory do |type| type.graphql_name 'FakeProjectType' type.field :test_issues, issue_type.connection_type, null: false, - resolve: -> (_, _, _) { Issue.where(project: [visible_project, other_project]).order(id: :asc) } + resolver: simple_resolver(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 } + query.field :test_project, project_type, null: false, resolver: simple_resolver(visible_project) end end diff --git a/spec/graphql/features/feature_flag_spec.rb b/spec/graphql/features/feature_flag_spec.rb index 9ebc6e595a6..77810f78257 100644 --- a/spec/graphql/features/feature_flag_spec.rb +++ b/spec/graphql/features/feature_flag_spec.rb @@ -23,7 +23,7 @@ RSpec.describe 'Graphql Field feature flags' do let(:query_type) do query_factory do |query| - query.field :item, type, null: true, feature_flag: feature_flag, resolve: ->(obj, args, ctx) { test_object } + query.field :item, type, null: true, feature_flag: feature_flag, resolver: simple_resolver(test_object) end end diff --git a/spec/graphql/mutations/alert_management/create_alert_issue_spec.rb b/spec/graphql/mutations/alert_management/create_alert_issue_spec.rb index e6a7434d579..47ee338ad34 100644 --- a/spec/graphql/mutations/alert_management/create_alert_issue_spec.rb +++ b/spec/graphql/mutations/alert_management/create_alert_issue_spec.rb @@ -28,6 +28,7 @@ RSpec.describe Mutations::AlertManagement::CreateAlertIssue do end it_behaves_like 'an incident management tracked event', :incident_management_incident_created + it_behaves_like 'an incident management tracked event', :incident_management_alert_create_incident end context 'when CreateAlertIssue responds with an error' do diff --git a/spec/graphql/mutations/alert_management/http_integration/destroy_spec.rb b/spec/graphql/mutations/alert_management/http_integration/destroy_spec.rb index f74f9186743..acd7070d0d3 100644 --- a/spec/graphql/mutations/alert_management/http_integration/destroy_spec.rb +++ b/spec/graphql/mutations/alert_management/http_integration/destroy_spec.rb @@ -11,7 +11,7 @@ RSpec.describe Mutations::AlertManagement::HttpIntegration::Destroy do specify { expect(described_class).to require_graphql_authorizations(:admin_operations) } describe '#resolve' do - subject(:resolve) { mutation_for(project, current_user).resolve(args) } + subject(:resolve) { mutation_for(project, current_user).resolve(**args) } context 'user has access to project' do before do diff --git a/spec/graphql/mutations/alert_management/http_integration/reset_token_spec.rb b/spec/graphql/mutations/alert_management/http_integration/reset_token_spec.rb index d3ffb2abb47..96974c2aa6f 100644 --- a/spec/graphql/mutations/alert_management/http_integration/reset_token_spec.rb +++ b/spec/graphql/mutations/alert_management/http_integration/reset_token_spec.rb @@ -11,7 +11,7 @@ RSpec.describe Mutations::AlertManagement::HttpIntegration::ResetToken do specify { expect(described_class).to require_graphql_authorizations(:admin_operations) } describe '#resolve' do - subject(:resolve) { mutation_for(project, current_user).resolve(args) } + subject(:resolve) { mutation_for(project, current_user).resolve(**args) } context 'user has sufficient access to project' do before do diff --git a/spec/graphql/mutations/alert_management/prometheus_integration/reset_token_spec.rb b/spec/graphql/mutations/alert_management/prometheus_integration/reset_token_spec.rb index 45d92695e06..ddf23909035 100644 --- a/spec/graphql/mutations/alert_management/prometheus_integration/reset_token_spec.rb +++ b/spec/graphql/mutations/alert_management/prometheus_integration/reset_token_spec.rb @@ -11,7 +11,7 @@ RSpec.describe Mutations::AlertManagement::PrometheusIntegration::ResetToken do specify { expect(described_class).to require_graphql_authorizations(:admin_project) } describe '#resolve' do - subject(:resolve) { mutation_for(project, current_user).resolve(args) } + subject(:resolve) { mutation_for(project, current_user).resolve(**args) } context 'user has sufficient access to project' do before do diff --git a/spec/graphql/mutations/alert_management/update_alert_status_spec.rb b/spec/graphql/mutations/alert_management/update_alert_status_spec.rb index 08761ce64c2..8465393f299 100644 --- a/spec/graphql/mutations/alert_management/update_alert_status_spec.rb +++ b/spec/graphql/mutations/alert_management/update_alert_status_spec.rb @@ -12,7 +12,7 @@ RSpec.describe Mutations::AlertManagement::UpdateAlertStatus do specify { expect(described_class).to require_graphql_authorizations(:update_alert_management_alert) } describe '#resolve' do - subject(:resolve) { mutation_for(project, current_user).resolve(args) } + subject(:resolve) { mutation_for(project, current_user).resolve(**args) } context 'user has access to project' do before do diff --git a/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb b/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb index 71c43ed826c..24104a20465 100644 --- a/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb +++ b/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb @@ -34,18 +34,18 @@ RSpec.describe Mutations::Boards::Issues::IssueMoveList do end subject do - mutation.resolve(params.merge(move_params)) + mutation.resolve(**params.merge(move_params)) end describe '#ready?' do it 'raises an error if required arguments are missing' do - expect { mutation.ready?(params) } + 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)) } + expect { mutation.ready?(**params.merge(from_list_id: list1.id)) } .to raise_error(Gitlab::Graphql::Errors::ArgumentError, 'Both fromListId and toListId must be present' ) @@ -73,18 +73,6 @@ RSpec.describe Mutations::Boards::Issues::IssueMoveList do 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 index b1fe9911c7b..894dd1f34b4 100644 --- a/spec/graphql/mutations/boards/lists/create_spec.rb +++ b/spec/graphql/mutations/boards/lists/create_spec.rb @@ -23,12 +23,12 @@ RSpec.describe Mutations::Boards::Lists::Create do describe '#ready?' do it 'raises an error if required arguments are missing' do - expect { mutation.ready?({ board_id: 'some id' }) } + expect { mutation.ready?(board_id: 'some id') } .to raise_error(Gitlab::Graphql::Errors::ArgumentError, /one and only one of/) 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' }) } + 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/) end end @@ -68,9 +68,8 @@ RSpec.describe Mutations::Boards::Lists::Create do context 'when label not found' do let(:list_create_params) { { label_id: "gid://gitlab/Label/#{non_existing_record_id}" } } - it 'raises an error' do - expect { subject } - .to raise_error(Gitlab::Graphql::Errors::ArgumentError, 'Label not found!') + it 'returns an error' do + expect(subject[:errors]).to include 'Label not found' end end end diff --git a/spec/graphql/mutations/concerns/mutations/finds_by_gid_spec.rb b/spec/graphql/mutations/concerns/mutations/finds_by_gid_spec.rb new file mode 100644 index 00000000000..37e0fd611e4 --- /dev/null +++ b/spec/graphql/mutations/concerns/mutations/finds_by_gid_spec.rb @@ -0,0 +1,26 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::FindsByGid do + include GraphqlHelpers + + let(:mutation_class) do + Class.new(Mutations::BaseMutation) do + authorize :read_user + + include Mutations::FindsByGid + end + end + + let(:query) { double('Query', schema: GitlabSchema) } + let(:context) { GraphQL::Query::Context.new(query: query, object: nil, values: { current_user: user }) } + let(:user) { create(:user) } + let(:gid) { user.to_global_id } + + subject(:mutation) { mutation_class.new(object: nil, context: context, field: nil) } + + it 'calls GitlabSchema.find_by_gid to find objects during authorized_find!' do + expect(mutation.authorized_find!(id: gid)).to eq(user) + end +end diff --git a/spec/graphql/mutations/container_expiration_policies/update_spec.rb b/spec/graphql/mutations/container_expiration_policies/update_spec.rb index 9c6016e0af4..e22fb951172 100644 --- a/spec/graphql/mutations/container_expiration_policies/update_spec.rb +++ b/spec/graphql/mutations/container_expiration_policies/update_spec.rb @@ -14,7 +14,7 @@ RSpec.describe Mutations::ContainerExpirationPolicies::Update do specify { expect(described_class).to require_graphql_authorizations(:destroy_container_image) } describe '#resolve' do - subject { described_class.new(object: project, context: { current_user: user }, field: nil).resolve(params) } + subject { described_class.new(object: project, context: { current_user: user }, field: nil).resolve(**params) } RSpec.shared_examples 'returning a success' do it 'returns the container expiration policy with no errors' do diff --git a/spec/graphql/mutations/container_repositories/destroy_tags_spec.rb b/spec/graphql/mutations/container_repositories/destroy_tags_spec.rb new file mode 100644 index 00000000000..f22d9ffe753 --- /dev/null +++ b/spec/graphql/mutations/container_repositories/destroy_tags_spec.rb @@ -0,0 +1,92 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::ContainerRepositories::DestroyTags do + include_context 'container repository delete tags service shared context' + using RSpec::Parameterized::TableSyntax + + let(:id) { repository.to_global_id.to_s } + + specify { expect(described_class).to require_graphql_authorizations(:destroy_container_image) } + + describe '#resolve' do + let(:tags) { %w[A C D E] } + + subject do + described_class.new(object: nil, context: { current_user: user }, field: nil) + .resolve(id: id, tag_names: tags) + end + + shared_examples 'destroying container repository tags' do + before do + stub_delete_reference_requests(tags) + expect_delete_tag_by_names(tags) + allow_next_instance_of(ContainerRegistry::Client) do |client| + allow(client).to receive(:supports_tag_delete?).and_return(true) + end + end + + it 'destroys the container repository tags' do + expect(Projects::ContainerRepository::DeleteTagsService) + .to receive(:new).and_call_original + + expect(subject).to eq(errors: [], deleted_tag_names: tags) + end + + it 'creates a package event' do + expect(::Packages::CreateEventService) + .to receive(:new).with(nil, user, event_name: :delete_tag_bulk, scope: :tag).and_call_original + expect { subject }.to change { ::Packages::Event.count }.by(1) + end + end + + shared_examples 'denying access to container respository' do + it 'raises an error' do + expect(::Projects::ContainerRepository::DeleteTagsService).not_to receive(:new) + + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + + context 'with valid id' do + where(:user_role, :shared_examples_name) do + :maintainer | 'destroying container repository tags' + :developer | 'destroying container repository tags' + :reporter | 'denying access to container respository' + :guest | 'denying access to container respository' + :anonymous | 'denying access to container respository' + end + + with_them do + before do + project.send("add_#{user_role}", user) unless user_role == :anonymous + end + + it_behaves_like params[:shared_examples_name] + end + end + + context 'with invalid id' do + let(:id) { 'gid://gitlab/ContainerRepository/5555' } + + it_behaves_like 'denying access to container respository' + end + + context 'with service error' do + before do + project.add_maintainer(user) + allow_next_instance_of(Projects::ContainerRepository::DeleteTagsService) do |service| + allow(service).to receive(:execute).and_return(message: 'could not delete tags', status: :error) + end + end + + it { is_expected.to eq(errors: ['could not delete tags'], deleted_tag_names: []) } + + it 'does not create a package event' do + expect(::Packages::CreateEventService).not_to receive(:new) + expect { subject }.not_to change { ::Packages::Event.count } + end + end + end +end diff --git a/spec/graphql/mutations/discussions/toggle_resolve_spec.rb b/spec/graphql/mutations/discussions/toggle_resolve_spec.rb index 2e5d41a8f1e..162b1249ab5 100644 --- a/spec/graphql/mutations/discussions/toggle_resolve_spec.rb +++ b/spec/graphql/mutations/discussions/toggle_resolve_spec.rb @@ -11,7 +11,7 @@ RSpec.describe Mutations::Discussions::ToggleResolve do describe '#resolve' do subject do - mutation.resolve({ id: id_arg, resolve: resolve_arg }) + mutation.resolve(id: id_arg, resolve: resolve_arg) end let(:id_arg) { discussion.to_global_id.to_s } diff --git a/spec/graphql/mutations/environments/canary_ingress/update_spec.rb b/spec/graphql/mutations/environments/canary_ingress/update_spec.rb new file mode 100644 index 00000000000..c022828cf09 --- /dev/null +++ b/spec/graphql/mutations/environments/canary_ingress/update_spec.rb @@ -0,0 +1,66 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Environments::CanaryIngress::Update do + let_it_be(:project) { create(:project) } + let_it_be(:environment) { create(:environment, project: project) } + let_it_be(:maintainer) { create(:user) } + let_it_be(:reporter) { create(:user) } + let(:user) { maintainer } + + subject(:mutation) { described_class.new(object: nil, context: { current_user: user }, field: nil) } + + before_all do + project.add_maintainer(maintainer) + project.add_reporter(reporter) + end + + describe '#resolve' do + subject { mutation.resolve(id: environment_id, weight: weight) } + + let(:environment_id) { environment.to_global_id.to_s } + let(:weight) { 50 } + let(:update_service) { double('update_service') } + + before do + allow(Environments::CanaryIngress::UpdateService).to receive(:new) { update_service } + end + + context 'when service execution succeeded' do + before do + allow(update_service).to receive(:execute_async) { { status: :success } } + end + + it 'returns no errors' do + expect(subject[:errors]).to be_empty + end + end + + context 'when service encounters a problem' do + before do + allow(update_service).to receive(:execute_async) { { status: :error, message: 'something went wrong' } } + end + + it 'returns an error' do + expect(subject[:errors]).to eq(['something went wrong']) + end + end + + context 'when environment is not found' do + let(:environment_id) { non_existing_record_id.to_s } + + it 'raises an error' do + expect { subject }.to raise_error(GraphQL::CoercionError) + end + end + + context 'when user is reporter who does not have permission to access the environment' do + let(:user) { reporter } + + it 'raises an error' do + expect { subject }.to raise_error("The resource that you are attempting to access does not exist or you don't have permission to perform this action") + end + end + end +end diff --git a/spec/graphql/mutations/issues/create_spec.rb b/spec/graphql/mutations/issues/create_spec.rb index 57658f6b358..422ad40a9cb 100644 --- a/spec/graphql/mutations/issues/create_spec.rb +++ b/spec/graphql/mutations/issues/create_spec.rb @@ -51,7 +51,7 @@ RSpec.describe Mutations::Issues::Create do project.add_guest(assignee2) end - subject { mutation.resolve(mutation_params) } + subject { mutation.resolve(**mutation_params) } context 'when the user does not have permission to create an issue' do it 'raises an error' do @@ -117,7 +117,7 @@ RSpec.describe Mutations::Issues::Create do end it 'raises exception when mutually exclusive params are given' do - expect { mutation.ready?(mutation_params) } + expect { mutation.ready?(**mutation_params) } .to raise_error(Gitlab::Graphql::Errors::ArgumentError, /one and only one of/) end end @@ -128,7 +128,7 @@ RSpec.describe Mutations::Issues::Create do end it 'raises exception when mutually exclusive params are given' do - expect { mutation.ready?(mutation_params) } + expect { mutation.ready?(**mutation_params) } .to raise_error(Gitlab::Graphql::Errors::ArgumentError, /to resolve a discussion please also provide `merge_request_to_resolve_discussions_of` parameter/) end end @@ -139,7 +139,7 @@ RSpec.describe Mutations::Issues::Create do end it 'raises exception when mutually exclusive params are given' do - expect { mutation.ready?(mutation_params) }.not_to raise_error + expect { mutation.ready?(**mutation_params) }.not_to raise_error end end end diff --git a/spec/graphql/mutations/issues/update_spec.rb b/spec/graphql/mutations/issues/update_spec.rb index ce1eb874bcf..f10e257e153 100644 --- a/spec/graphql/mutations/issues/update_spec.rb +++ b/spec/graphql/mutations/issues/update_spec.rb @@ -33,7 +33,7 @@ RSpec.describe Mutations::Issues::Update do }.merge(expected_attributes) end - subject { mutation.resolve(mutation_params) } + subject { mutation.resolve(**mutation_params) } it_behaves_like 'permission level for issue mutation is correctly verified' diff --git a/spec/graphql/mutations/labels/create_spec.rb b/spec/graphql/mutations/labels/create_spec.rb index 8b284816d63..b2dd94f31bb 100644 --- a/spec/graphql/mutations/labels/create_spec.rb +++ b/spec/graphql/mutations/labels/create_spec.rb @@ -58,7 +58,7 @@ RSpec.describe Mutations::Labels::Create do end describe '#ready?' do - subject { mutation.ready?(attributes.merge(extra_params)) } + subject { mutation.ready?(**attributes.merge(extra_params)) } context 'when passing both project_path and group_path' do let(:extra_params) { { project_path: 'foo', group_path: 'bar' } } diff --git a/spec/graphql/mutations/notes/reposition_image_diff_note_spec.rb b/spec/graphql/mutations/notes/reposition_image_diff_note_spec.rb index 8c22e1a1cb6..d88b196cbff 100644 --- a/spec/graphql/mutations/notes/reposition_image_diff_note_spec.rb +++ b/spec/graphql/mutations/notes/reposition_image_diff_note_spec.rb @@ -7,7 +7,7 @@ RSpec.describe Mutations::Notes::RepositionImageDiffNote do describe '#resolve' do subject do - mutation.resolve({ note: note, position: new_position }) + mutation.resolve(note: note, position: new_position) end let_it_be(:noteable) { create(:merge_request) } diff --git a/spec/graphql/mutations/releases/delete_spec.rb b/spec/graphql/mutations/releases/delete_spec.rb new file mode 100644 index 00000000000..bedb72b002c --- /dev/null +++ b/spec/graphql/mutations/releases/delete_spec.rb @@ -0,0 +1,92 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Releases::Delete do + let_it_be(:project) { create(:project, :public, :repository) } + let_it_be(:non_project_member) { create(:user) } + let_it_be(:developer) { create(:user) } + let_it_be(:maintainer) { create(:user) } + let_it_be(:tag) { 'v1.1.0'} + let_it_be(:release) { create(:release, project: project, tag: tag) } + + let(:mutation) { described_class.new(object: nil, context: { current_user: current_user }, field: nil) } + + let(:mutation_arguments) do + { + project_path: project.full_path, + tag: tag + } + end + + before do + project.add_developer(developer) + project.add_maintainer(maintainer) + end + + shared_examples 'unauthorized or not found error' do + it 'raises a Gitlab::Graphql::Errors::ResourceNotAvailable error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable, "The resource that you are attempting to access does not exist or you don't have permission to perform this action") + end + end + + describe '#resolve' do + subject(:resolve) do + mutation.resolve(**mutation_arguments) + end + + context 'when the current user has access to create releases' do + let(:current_user) { maintainer } + + it 'deletes the release' do + expect { subject }.to change { Release.count }.by(-1) + end + + it 'returns the deleted release' do + expect(subject[:release].tag).to eq(tag) + end + + it 'does not remove the Git tag associated with the deleted release' do + expect { subject }.not_to change { Project.find_by_id(project.id).repository.tag_count } + end + + it 'returns no errors' do + expect(subject[:errors]).to eq([]) + end + + context 'validation' do + context 'when the release does not exist' do + let(:mutation_arguments) { super().merge(tag: 'not-a-real-release') } + + it 'returns the release as nil' do + expect(subject[:release]).to be_nil + end + + it 'returns an errors-at-data message' do + expect(subject[:errors]).to eq(['Release does not exist']) + end + end + + context 'when the project does not exist' do + let(:mutation_arguments) { super().merge(project_path: 'not/a/real/path') } + + it_behaves_like 'unauthorized or not found error' + end + end + end + + context "when the current user doesn't have access to update releases" do + context 'when the user is a developer' do + let(:current_user) { developer } + + it_behaves_like 'unauthorized or not found error' + end + + context 'when the user is a non-project member' do + let(:current_user) { non_project_member } + + it_behaves_like 'unauthorized or not found error' + end + end + end +end diff --git a/spec/graphql/mutations/releases/update_spec.rb b/spec/graphql/mutations/releases/update_spec.rb new file mode 100644 index 00000000000..0406e9c96f3 --- /dev/null +++ b/spec/graphql/mutations/releases/update_spec.rb @@ -0,0 +1,232 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Releases::Update do + let_it_be(:project) { create(:project, :public, :repository) } + let_it_be(:milestone_12_3) { create(:milestone, project: project, title: '12.3') } + let_it_be(:milestone_12_4) { create(:milestone, project: project, title: '12.4') } + let_it_be(:reporter) { create(:user) } + let_it_be(:developer) { create(:user) } + + let_it_be(:tag) { 'v1.1.0'} + let_it_be(:name) { 'Version 1.0'} + let_it_be(:description) { 'The first release :rocket:' } + let_it_be(:released_at) { Time.parse('2018-12-10').utc } + let_it_be(:created_at) { Time.parse('2018-11-05').utc } + let_it_be(:milestones) { [milestone_12_3.title, milestone_12_4.title] } + + let_it_be(:release) do + create(:release, project: project, tag: tag, name: name, + description: description, released_at: released_at, + created_at: created_at, milestones: [milestone_12_3, milestone_12_4]) + end + + let(:mutation) { described_class.new(object: nil, context: { current_user: current_user }, field: nil) } + + let(:mutation_arguments) do + { + project_path: project.full_path, + tag: tag + } + end + + around do |example| + freeze_time { example.run } + end + + before do + project.add_reporter(reporter) + project.add_developer(developer) + end + + shared_examples 'no changes to the release except for the' do |except_for| + it 'does not change other release properties' do + expect(updated_release.project).to eq(project) + expect(updated_release.tag).to eq(tag) + + expect(updated_release.name).to eq(name) unless except_for == :name + expect(updated_release.description).to eq(description) unless except_for == :description + expect(updated_release.released_at).to eq(released_at) unless except_for == :released_at + + # Right now the milestones are returned in a non-deterministic order. + # Because of this, we need to allow for milestones to be returned in any order. + # Once https://gitlab.com/gitlab-org/gitlab/-/issues/259012 has been + # fixed, this can be updated to expect a specific order. + expect(updated_release.milestones).to match_array([milestone_12_3, milestone_12_4]) unless except_for == :milestones + end + end + + shared_examples 'validation error with message' do |message| + it 'returns the updated release as nil' do + expect(updated_release).to be_nil + end + + it 'returns a validation error' do + expect(subject[:errors]).to eq([message]) + end + end + + describe '#ready?' do + let(:current_user) { developer } + + subject(:ready) do + mutation.ready?(**mutation_arguments) + end + + context 'when released_at is included as an argument but is passed nil' do + let(:mutation_arguments) { super().merge(released_at: nil) } + + it 'raises a validation error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ArgumentError, 'if the releasedAt argument is provided, it cannot be null') + end + end + + context 'when milestones is included as an argument but is passed nil' do + let(:mutation_arguments) { super().merge(milestones: nil) } + + it 'raises a validation error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ArgumentError, 'if the milestones argument is provided, it cannot be null') + end + end + end + + describe '#resolve' do + subject(:resolve) do + mutation.resolve(**mutation_arguments) + end + + let(:updated_release) { subject[:release] } + + context 'when the current user has access to create releases' do + let(:current_user) { developer } + + context 'name' do + let(:mutation_arguments) { super().merge(name: updated_name) } + + context 'when a new name is provided' do + let(:updated_name) { 'Updated name' } + + it 'updates the name' do + expect(updated_release.name).to eq(updated_name) + end + + it_behaves_like 'no changes to the release except for the', :name + end + + context 'when nil is provided' do + let(:updated_name) { nil } + + it 'updates the name to be the tag name' do + expect(updated_release.name).to eq(tag) + end + + it_behaves_like 'no changes to the release except for the', :name + end + end + + context 'description' do + let(:mutation_arguments) { super().merge(description: updated_description) } + + context 'when a new description is provided' do + let(:updated_description) { 'Updated description' } + + it 'updates the description' do + expect(updated_release.description).to eq(updated_description) + end + + it_behaves_like 'no changes to the release except for the', :description + end + + context 'when nil is provided' do + let(:updated_description) { nil } + + it 'updates the description to nil' do + expect(updated_release.description).to eq(nil) + end + + it_behaves_like 'no changes to the release except for the', :description + end + end + + context 'released_at' do + let(:mutation_arguments) { super().merge(released_at: updated_released_at) } + + context 'when a new released_at is provided' do + let(:updated_released_at) { Time.parse('2020-12-10').utc } + + it 'updates the released_at' do + expect(updated_release.released_at).to eq(updated_released_at) + end + + it_behaves_like 'no changes to the release except for the', :released_at + end + end + + context 'milestones' do + let(:mutation_arguments) { super().merge(milestones: updated_milestones) } + + context 'when a new set of milestones is provided provided' do + let(:updated_milestones) { [milestone_12_3.title] } + + it 'updates the milestone associations' do + expect(updated_release.milestones).to eq([milestone_12_3]) + end + + it_behaves_like 'no changes to the release except for the', :milestones + end + + context 'when an empty array is provided' do + let(:updated_milestones) { [] } + + it 'removes all milestone associations' do + expect(updated_release.milestones).to eq([]) + end + + it_behaves_like 'no changes to the release except for the', :milestones + end + + context 'when a non-existent milestone title is provided' do + let(:updated_milestones) { ['not real'] } + + it_behaves_like 'validation error with message', 'Milestone(s) not found: not real' + end + + context 'when a milestone title from a different project is provided' do + let(:milestone_in_different_project) { create(:milestone, title: 'milestone in different project') } + let(:updated_milestones) { [milestone_in_different_project.title] } + + it_behaves_like 'validation error with message', 'Milestone(s) not found: milestone in different project' + end + end + + context 'validation' do + context 'when no updated fields are provided' do + it_behaves_like 'validation error with message', 'params is empty' + end + + context 'when the tag does not exist' do + let(:mutation_arguments) { super().merge(tag: 'not-a-real-tag') } + + it_behaves_like 'validation error with message', 'Tag does not exist' + end + + context 'when the project does not exist' do + let(:mutation_arguments) { super().merge(project_path: 'not/a/real/path') } + + it 'raises an error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable, "The resource that you are attempting to access does not exist or you don't have permission to perform this action") + end + end + end + end + + context "when the current user doesn't have access to update releases" do + let(:current_user) { reporter } + + it 'raises an error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable, "The resource that you are attempting to access does not exist or you don't have permission to perform this action") + end + end + 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 42830f0024d..c042f6dac19 100644 --- a/spec/graphql/resolvers/alert_management/alert_resolver_spec.rb +++ b/spec/graphql/resolvers/alert_management/alert_resolver_spec.rb @@ -33,11 +33,21 @@ RSpec.describe Resolvers::AlertManagement::AlertResolver do end context 'finding by status' do - let(:args) { { status: [Types::AlertManagement::StatusEnum.values['IGNORED'].value] } } + let(:args) { { statuses: [Types::AlertManagement::StatusEnum.values['IGNORED'].value] } } it { is_expected.to contain_exactly(ignored_alert) } end + context 'filtering by domain' do + let_it_be(:alert1) { create(:alert_management_alert, project: project, monitoring_tool: 'Cilium', domain: :threat_monitoring) } + let_it_be(:alert2) { create(:alert_management_alert, project: project, monitoring_tool: 'Cilium', domain: :threat_monitoring) } + let_it_be(:alert3) { create(:alert_management_alert, project: project, monitoring_tool: 'generic') } + + let(:args) { { domain: 'operations' } } + + it { is_expected.to contain_exactly(resolved_alert, ignored_alert, alert3) } + end + describe 'sorting' do # Other sorting examples in spec/finders/alert_management/alerts_finder_spec.rb context 'when sorting by events count' do diff --git a/spec/graphql/resolvers/base_resolver_spec.rb b/spec/graphql/resolvers/base_resolver_spec.rb index e5b9fb57e42..8a24b69eb6f 100644 --- a/spec/graphql/resolvers/base_resolver_spec.rb +++ b/spec/graphql/resolvers/base_resolver_spec.rb @@ -273,4 +273,12 @@ RSpec.describe Resolvers::BaseResolver do end end end + + describe '#offset_pagination' do + let(:instance) { resolver_instance(resolver) } + + it 'is sugar for OffsetActiveRecordRelationConnection.new' do + expect(instance.offset_pagination(User.none)).to be_a(::Gitlab::Graphql::Pagination::OffsetActiveRecordRelationConnection) + 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 index 4ccf194522f..e7c56a526f4 100644 --- a/spec/graphql/resolvers/board_list_issues_resolver_spec.rb +++ b/spec/graphql/resolvers/board_list_issues_resolver_spec.rb @@ -29,7 +29,7 @@ RSpec.describe Resolvers::BoardListIssuesResolver do end it 'finds only issues matching filters' do - result = resolve_board_list_issues(args: { filters: { label_name: label.title, not: { label_name: label2.title } } }).items + result = resolve_board_list_issues(args: { filters: { label_name: [label.title], not: { label_name: [label2.title] } } }).items expect(result).to match_array([issue1, issue3]) end diff --git a/spec/graphql/resolvers/board_lists_resolver_spec.rb b/spec/graphql/resolvers/board_lists_resolver_spec.rb index c1d8041a1e0..71ebec4dc7e 100644 --- a/spec/graphql/resolvers/board_lists_resolver_spec.rb +++ b/spec/graphql/resolvers/board_lists_resolver_spec.rb @@ -29,9 +29,7 @@ RSpec.describe Resolvers::BoardListsResolver do context 'with unauthorized user' do it 'raises an error' do - expect do - resolve_board_lists(current_user: unauth_user) - end.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + expect(resolve_board_lists(current_user: unauth_user)).to be_nil end end @@ -101,12 +99,6 @@ RSpec.describe Resolvers::BoardListsResolver do end def resolve_board_lists(args: {}, current_user: user) - context = GraphQL::Query::Context.new( - query: OpenStruct.new(schema: nil), - values: { current_user: current_user }, - object: nil - ) - - resolve(described_class, obj: board, args: args, ctx: context ) + resolve(described_class, obj: board, args: args, ctx: { current_user: current_user }) end end diff --git a/spec/graphql/resolvers/ci/config_resolver_spec.rb b/spec/graphql/resolvers/ci/config_resolver_spec.rb new file mode 100644 index 00000000000..6911acdb4ec --- /dev/null +++ b/spec/graphql/resolvers/ci/config_resolver_spec.rb @@ -0,0 +1,56 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::Ci::ConfigResolver do + include GraphqlHelpers + + describe '#resolve' do + before do + yaml_processor_double = instance_double(::Gitlab::Ci::YamlProcessor) + allow(yaml_processor_double).to receive(:execute).and_return(fake_result) + + allow(::Gitlab::Ci::YamlProcessor).to receive(:new).and_return(yaml_processor_double) + end + + context 'with a valid .gitlab-ci.yml' do + let(:fake_result) do + ::Gitlab::Ci::YamlProcessor::Result.new( + ci_config: ::Gitlab::Ci::Config.new(content), + errors: [], + warnings: [] + ) + end + + let_it_be(:content) do + File.read(Rails.root.join('spec/support/gitlab_stubs/gitlab_ci_includes.yml')) + end + + it 'lints the ci config file' do + response = resolve(described_class, args: { content: content }, ctx: {}) + + expect(response[:status]).to eq(:valid) + expect(response[:errors]).to be_empty + end + end + + context 'with an invalid .gitlab-ci.yml' do + let(:content) { 'invalid' } + + let(:fake_result) do + Gitlab::Ci::YamlProcessor::Result.new( + ci_config: nil, + errors: ['Invalid configuration format'], + warnings: [] + ) + end + + it 'responds with errors about invalid syntax' do + response = resolve(described_class, args: { content: content }, ctx: {}) + + expect(response[:status]).to eq(:invalid) + expect(response[:errors]).to eq(['Invalid configuration format']) + end + end + end +end diff --git a/spec/graphql/resolvers/ci/jobs_resolver_spec.rb b/spec/graphql/resolvers/ci/jobs_resolver_spec.rb index a836c89bd61..46ee74a5f7e 100644 --- a/spec/graphql/resolvers/ci/jobs_resolver_spec.rb +++ b/spec/graphql/resolvers/ci/jobs_resolver_spec.rb @@ -17,10 +17,14 @@ RSpec.describe Resolvers::Ci::JobsResolver do describe '#resolve' do context 'when security_report_types is empty' do it "returns all of the pipeline's jobs" do - jobs = resolve(described_class, obj: pipeline, args: {}, ctx: {}) - - job_names = jobs.map(&:name) - expect(job_names).to contain_exactly('Normal job', 'DAST job', 'SAST job', 'Container scanning job') + jobs = resolve(described_class, obj: pipeline) + + expect(jobs).to contain_exactly( + have_attributes(name: 'Normal job'), + have_attributes(name: 'DAST job'), + have_attributes(name: 'SAST job'), + have_attributes(name: 'Container scanning job') + ) end end @@ -30,10 +34,12 @@ RSpec.describe Resolvers::Ci::JobsResolver do ::Types::Security::ReportTypeEnum.values['SAST'].value, ::Types::Security::ReportTypeEnum.values['DAST'].value ] - jobs = resolve(described_class, obj: pipeline, args: { security_report_types: report_types }, ctx: {}) + jobs = resolve(described_class, obj: pipeline, args: { security_report_types: report_types }) - job_names = jobs.map(&:name) - expect(job_names).to contain_exactly('DAST job', 'SAST job') + expect(jobs).to contain_exactly( + have_attributes(name: 'DAST job'), + have_attributes(name: 'SAST job') + ) end end end diff --git a/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb b/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb index a408981c08e..241a9e58147 100644 --- a/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb +++ b/spec/graphql/resolvers/commit_pipelines_resolver_spec.rb @@ -50,6 +50,6 @@ RSpec.describe Resolvers::CommitPipelinesResolver do it 'resolves pipelines for commit and ref' do pipelines = resolve_pipelines - expect(pipelines).to eq([pipeline2, pipeline]) + expect(pipelines.to_a).to eq([pipeline2, pipeline]) end end diff --git a/spec/graphql/resolvers/concerns/caching_array_resolver_spec.rb b/spec/graphql/resolvers/concerns/caching_array_resolver_spec.rb index b6fe94a2312..5370f7a7433 100644 --- a/spec/graphql/resolvers/concerns/caching_array_resolver_spec.rb +++ b/spec/graphql/resolvers/concerns/caching_array_resolver_spec.rb @@ -4,18 +4,25 @@ require 'spec_helper' RSpec.describe ::CachingArrayResolver do include GraphqlHelpers + include Gitlab::Graphql::Laziness - let_it_be(:non_admins) { create_list(:user, 4, admin: false) } - let(:query_context) { {} } + let_it_be(:admins) { create_list(:user, 4, admin: true) } + let(:query_context) { { current_user: admins.first } } let(:max_page_size) { 10 } let(:field) { double('Field', max_page_size: max_page_size) } - let(:schema) { double('Schema', default_max_page_size: 3) } + let(:schema) do + Class.new(GitlabSchema) do + default_max_page_size 3 + end + end let_it_be(:caching_resolver) do mod = described_class Class.new(::Resolvers::BaseResolver) do include mod + type [::Types::UserType], null: true + argument :is_admin, ::GraphQL::BOOLEAN_TYPE, required: false def query_input(is_admin:) is_admin @@ -44,6 +51,8 @@ RSpec.describe ::CachingArrayResolver do Class.new(::Resolvers::BaseResolver) do include mod + type [::Types::UserType], null: true + argument :username, ::GraphQL::STRING_TYPE, required: false def query_input(username:) username @@ -72,7 +81,7 @@ RSpec.describe ::CachingArrayResolver do expect(User).to receive(:from_union).twice.and_call_original results = users.in_groups_of(2, false).map do |users| - resolve(resolver, args: { username: users.map(&:username) }, field: field, schema: schema) + resolve(resolver, args: { username: users.map(&:username) }, schema: schema) end expect(results.flat_map(&method(:force))).to match_array(users) @@ -80,19 +89,19 @@ RSpec.describe ::CachingArrayResolver do end context 'all queries return results' do - let_it_be(:admins) { create_list(:admin, 3) } + let_it_be(:non_admins) { create_list(:user, 3, admin: false) } it 'batches the queries' do expect do - [resolve_users(true), resolve_users(false)].each(&method(:force)) - end.to issue_same_number_of_queries_as { force(resolve_users(nil)) } + [resolve_users(admin: true), resolve_users(admin: false)].each(&method(:force)) + end.to issue_same_number_of_queries_as { force(resolve_users(admin: nil)) } end it 'finds the correct values' do - found_admins = resolve_users(true) - found_others = resolve_users(false) - admins_again = resolve_users(true) - found_all = resolve_users(nil) + found_admins = resolve_users(admin: true) + found_others = resolve_users(admin: false) + admins_again = resolve_users(admin: true) + found_all = resolve_users(admin: nil) expect(force(found_admins)).to match_array(admins) expect(force(found_others)).to match_array(non_admins) @@ -104,37 +113,37 @@ RSpec.describe ::CachingArrayResolver do it 'does not perform a union of a query with itself' do expect(User).to receive(:where).once.and_call_original - [resolve_users(false), resolve_users(false)].each(&method(:force)) + [resolve_users(admin: false), resolve_users(admin: false)].each(&method(:force)) end context 'one of the queries returns no results' do it 'finds the correct values' do - found_admins = resolve_users(true) - found_others = resolve_users(false) - found_all = resolve_users(nil) + found_admins = resolve_users(admin: true) + found_others = resolve_users(admin: false) + found_all = resolve_users(admin: nil) - expect(force(found_admins)).to be_empty - expect(force(found_others)).to match_array(non_admins) - expect(force(found_all)).to match_array(non_admins) + expect(force(found_admins)).to match_array(admins) + expect(force(found_others)).to be_empty + expect(force(found_all)).to match_array(admins) end end context 'one of the queries has already been cached' do before do - force(resolve_users(nil)) + force(resolve_users(admin: nil)) end it 'avoids further queries' do expect do - repeated_find = resolve_users(nil) + repeated_find = resolve_users(admin: nil) - expect(force(repeated_find)).to match_array(non_admins) + expect(force(repeated_find)).to match_array(admins) end.not_to exceed_query_limit(0) end end context 'the resolver overrides item_found' do - let_it_be(:admins) { create_list(:admin, 2) } + let_it_be(:non_admins) { create_list(:user, 2, admin: false) } let(:query_context) do { found: { true => [], false => [], nil => [] } @@ -150,14 +159,14 @@ RSpec.describe ::CachingArrayResolver do end it 'receives item_found for each key the item mapped to' do - found_admins = resolve_users(true, with_item_found) - found_all = resolve_users(nil, with_item_found) + found_admins = resolve_users(admin: true, resolver: with_item_found) + found_all = resolve_users(admin: nil, resolver: with_item_found) [found_admins, found_all].each(&method(:force)) expect(query_context[:found]).to match({ - false => be_empty, true => match_array(admins), + false => be_empty, nil => match_array(admins + non_admins) }) end @@ -167,11 +176,11 @@ RSpec.describe ::CachingArrayResolver do let(:max_page_size) { 2 } it 'respects the max_page_size, on a per subset basis' do - found_all = resolve_users(nil) - found_others = resolve_users(false) + found_all = resolve_users(admin: nil) + found_admins = resolve_users(admin: true) expect(force(found_all).size).to eq(2) - expect(force(found_others).size).to eq(2) + expect(force(found_admins).size).to eq(2) end end @@ -179,11 +188,11 @@ RSpec.describe ::CachingArrayResolver do let(:max_page_size) { nil } it 'takes the page size from schema.default_max_page_size' do - found_all = resolve_users(nil) - found_others = resolve_users(false) + found_all = resolve_users(admin: nil) + found_admins = resolve_users(admin: true) expect(force(found_all).size).to eq(schema.default_max_page_size) - expect(force(found_others).size).to eq(schema.default_max_page_size) + expect(force(found_admins).size).to eq(schema.default_max_page_size) end end @@ -197,12 +206,10 @@ RSpec.describe ::CachingArrayResolver do end end - def resolve_users(is_admin, resolver = caching_resolver) - args = { is_admin: is_admin } - resolve(resolver, args: args, field: field, ctx: query_context, schema: schema) - end - - def force(lazy) - ::Gitlab::Graphql::Lazy.force(lazy) + def resolve_users(admin:, resolver: caching_resolver) + args = { is_admin: admin } + opts = resolver.field_options + allow(resolver).to receive(:field_options).and_return(opts.merge(max_page_size: max_page_size)) + resolve(resolver, args: args, ctx: query_context, schema: schema, field: field) end end diff --git a/spec/graphql/resolvers/concerns/looks_ahead_spec.rb b/spec/graphql/resolvers/concerns/looks_ahead_spec.rb index ebea9e5522b..27ac1572cab 100644 --- a/spec/graphql/resolvers/concerns/looks_ahead_spec.rb +++ b/spec/graphql/resolvers/concerns/looks_ahead_spec.rb @@ -14,7 +14,7 @@ RSpec.describe LooksAhead do # Simplified schema to test lookahead let_it_be(:schema) do - issues_resolver = Class.new(Resolvers::BaseResolver) do + issues_resolver = Class.new(GraphQL::Schema::Resolver) do include LooksAhead def resolve_with_lookahead(**args) @@ -41,7 +41,6 @@ RSpec.describe LooksAhead do field :issues, issue.connection_type, null: true field :issues_with_lookahead, issue.connection_type, - extras: [:lookahead], resolver: issues_resolver, null: true end diff --git a/spec/graphql/resolvers/design_management/version/design_at_version_resolver_spec.rb b/spec/graphql/resolvers/design_management/version/design_at_version_resolver_spec.rb index 850b9f8cc87..cc7e2f6814a 100644 --- a/spec/graphql/resolvers/design_management/version/design_at_version_resolver_spec.rb +++ b/spec/graphql/resolvers/design_management/version/design_at_version_resolver_spec.rb @@ -15,7 +15,7 @@ RSpec.describe Resolvers::DesignManagement::Version::DesignAtVersionResolver do let(:all_singular_args) do { - design_at_version_id: global_id_of(dav(design)), + id: global_id_of(dav(design)), design_id: global_id_of(design), filename: design.filename } @@ -50,7 +50,7 @@ RSpec.describe Resolvers::DesignManagement::Version::DesignAtVersionResolver do end end - %i[design_at_version_id design_id filename].each do |arg| + %i[id design_id filename].each do |arg| describe "passing #{arg}" do let(:args) { all_singular_args.slice(arg) } @@ -71,7 +71,7 @@ RSpec.describe Resolvers::DesignManagement::Version::DesignAtVersionResolver do describe 'attempting to retrieve an object not visible at this version' do let(:design) { design_d } - %i[design_at_version_id design_id filename].each do |arg| + %i[id design_id filename].each do |arg| describe "passing #{arg}" do let(:args) { all_singular_args.slice(arg) } diff --git a/spec/graphql/resolvers/design_management/version_in_collection_resolver_spec.rb b/spec/graphql/resolvers/design_management/version_in_collection_resolver_spec.rb index 403261fc22a..b0fc78af2af 100644 --- a/spec/graphql/resolvers/design_management/version_in_collection_resolver_spec.rb +++ b/spec/graphql/resolvers/design_management/version_in_collection_resolver_spec.rb @@ -32,7 +32,7 @@ RSpec.describe Resolvers::DesignManagement::VersionInCollectionResolver do end context 'we pass an id' do - let(:params) { { version_id: global_id_of(first_version) } } + let(:params) { { id: global_id_of(first_version) } } it { is_expected.to eq(first_version) } end @@ -44,13 +44,13 @@ RSpec.describe Resolvers::DesignManagement::VersionInCollectionResolver do end context 'we pass an inconsistent mixture of sha and version id' do - let(:params) { { sha: first_version.sha, version_id: global_id_of(create(:design_version)) } } + let(:params) { { sha: first_version.sha, id: global_id_of(create(:design_version)) } } it { is_expected.to be_nil } end context 'we pass the id of something that is not a design_version' do - let(:params) { { version_id: global_id_of(project) } } + let(:params) { { id: global_id_of(project) } } let(:appropriate_error) { ::GraphQL::CoercionError } it 'raises an appropriate error' do diff --git a/spec/graphql/resolvers/design_management/versions_resolver_spec.rb b/spec/graphql/resolvers/design_management/versions_resolver_spec.rb index 5bc1c555e9a..23d4d86c79a 100644 --- a/spec/graphql/resolvers/design_management/versions_resolver_spec.rb +++ b/spec/graphql/resolvers/design_management/versions_resolver_spec.rb @@ -27,7 +27,7 @@ RSpec.describe Resolvers::DesignManagement::VersionsResolver do end shared_examples 'a source of versions' do - subject(:result) { resolve_versions(object) } + subject(:result) { resolve_versions(object)&.to_a } let_it_be(:all_versions) { object.versions.ordered } @@ -39,7 +39,7 @@ RSpec.describe Resolvers::DesignManagement::VersionsResolver do context 'without constraints' do it 'returns the ordered versions' do - expect(result).to eq(all_versions) + expect(result.to_a).to eq(all_versions) end end @@ -51,13 +51,13 @@ RSpec.describe Resolvers::DesignManagement::VersionsResolver do end context 'by earlier_or_equal_to_id' do - let(:params) { { id: global_id_of(first_version) } } + let(:params) { { earlier_or_equal_to_id: global_id_of(first_version) } } it_behaves_like 'a query for all_versions up to the first_version' end context 'by earlier_or_equal_to_sha' do - let(:params) { { sha: first_version.sha } } + let(:params) { { earlier_or_equal_to_sha: first_version.sha } } it_behaves_like 'a query for all_versions up to the first_version' end @@ -68,8 +68,8 @@ RSpec.describe Resolvers::DesignManagement::VersionsResolver do # return successfully let(:params) do { - sha: first_version.sha, - id: global_id_of(first_version) + earlier_or_equal_to_sha: first_version.sha, + earlier_or_equal_to_id: global_id_of(first_version) } end @@ -79,8 +79,8 @@ RSpec.describe Resolvers::DesignManagement::VersionsResolver do context 'and they do not match' do let(:params) do { - sha: first_version.sha, - id: global_id_of(other_version) + earlier_or_equal_to_sha: first_version.sha, + earlier_or_equal_to_id: global_id_of(other_version) } end @@ -111,7 +111,7 @@ RSpec.describe Resolvers::DesignManagement::VersionsResolver do end def resolve_versions(obj, context = { current_user: current_user }) - eager_resolve(resolver, obj: obj, args: params.merge(parent: parent), ctx: context) + eager_resolve(resolver, obj: obj, parent: parent, args: params, ctx: context) end end end diff --git a/spec/graphql/resolvers/error_tracking/sentry_errors_resolver_spec.rb b/spec/graphql/resolvers/error_tracking/sentry_errors_resolver_spec.rb index edca11f40d7..170a602fb0d 100644 --- a/spec/graphql/resolvers/error_tracking/sentry_errors_resolver_spec.rb +++ b/spec/graphql/resolvers/error_tracking/sentry_errors_resolver_spec.rb @@ -88,8 +88,8 @@ RSpec.describe Resolvers::ErrorTracking::SentryErrorsResolver do it 'sets the pagination variables' do result = resolve_errors - expect(result.next_cursor).to eq 'next' - expect(result.previous_cursor).to eq 'prev' + expect(result.end_cursor).to eq 'next' + expect(result.start_cursor).to eq 'prev' end it 'returns an externally paginated array' do diff --git a/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb b/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb index 16eb190efc6..decc3569d6c 100644 --- a/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb +++ b/spec/graphql/resolvers/issue_status_counts_resolver_spec.rb @@ -62,22 +62,13 @@ RSpec.describe Resolvers::IssueStatusCountsResolver do end it 'filters by issue type', :aggregate_failures do - result = resolve_issue_status_counts(issue_types: ['incident']) + result = resolve_issue_status_counts(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 }) diff --git a/spec/graphql/resolvers/issues_resolver_spec.rb b/spec/graphql/resolvers/issues_resolver_spec.rb index 43cbd4d2bdd..f6f746a8572 100644 --- a/spec/graphql/resolvers/issues_resolver_spec.rb +++ b/spec/graphql/resolvers/issues_resolver_spec.rb @@ -5,7 +5,7 @@ require 'spec_helper' RSpec.describe Resolvers::IssuesResolver do include GraphqlHelpers - let(:current_user) { create(:user) } + let_it_be(:current_user) { create(:user) } let_it_be(:group) { create(:group) } let_it_be(:project) { create(:project, group: group) } @@ -25,7 +25,7 @@ RSpec.describe Resolvers::IssuesResolver do end context "with a project" do - before do + before_all do project.add_developer(current_user) create(:label_link, label: label1, target: issue1) create(:label_link, label: label1, target: issue2) @@ -43,11 +43,11 @@ RSpec.describe Resolvers::IssuesResolver do end it 'filters by milestone' do - expect(resolve_issues(milestone_title: milestone.title)).to contain_exactly(issue1) + expect(resolve_issues(milestone_title: [milestone.title])).to contain_exactly(issue1) end it 'filters by assignee_username' do - expect(resolve_issues(assignee_username: assignee.username)).to contain_exactly(issue2) + expect(resolve_issues(assignee_username: [assignee.username])).to contain_exactly(issue2) end it 'filters by two assignees' do @@ -112,15 +112,19 @@ RSpec.describe Resolvers::IssuesResolver do describe 'filters by issue_type' do it 'filters by a single type' do - expect(resolve_issues(issue_types: ['incident'])).to contain_exactly(issue1) + expect(resolve_issues(types: %w[incident])).to contain_exactly(issue1) + end + + it 'filters by a single type, negative assertion' do + expect(resolve_issues(types: %w[issue])).not_to include(issue1) end it 'filters by more than one type' do - expect(resolve_issues(issue_types: %w(incident issue))).to contain_exactly(issue1, issue2) + expect(resolve_issues(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) + expect(resolve_issues(types: [])).to contain_exactly(issue1, issue2) end end @@ -143,44 +147,44 @@ RSpec.describe Resolvers::IssuesResolver do describe 'sorting' do context 'when sorting by created' do it 'sorts issues ascending' do - expect(resolve_issues(sort: 'created_asc')).to eq [issue1, issue2] + expect(resolve_issues(sort: 'created_asc').to_a).to eq [issue1, issue2] end it 'sorts issues descending' do - expect(resolve_issues(sort: 'created_desc')).to eq [issue2, issue1] + expect(resolve_issues(sort: 'created_desc').to_a).to eq [issue2, issue1] end end context 'when sorting by due date' do - let_it_be(:project) { create(:project) } + let_it_be(:project) { create(:project, :public) } let_it_be(:due_issue1) { create(:issue, project: project, due_date: 3.days.from_now) } let_it_be(:due_issue2) { create(:issue, project: project, due_date: nil) } let_it_be(:due_issue3) { create(:issue, project: project, due_date: 2.days.ago) } let_it_be(:due_issue4) { create(:issue, project: project, due_date: nil) } it 'sorts issues ascending' do - expect(resolve_issues(sort: :due_date_asc)).to eq [due_issue3, due_issue1, due_issue4, due_issue2] + expect(resolve_issues(sort: :due_date_asc).to_a).to eq [due_issue3, due_issue1, due_issue4, due_issue2] end it 'sorts issues descending' do - expect(resolve_issues(sort: :due_date_desc)).to eq [due_issue1, due_issue3, due_issue4, due_issue2] + expect(resolve_issues(sort: :due_date_desc).to_a).to eq [due_issue1, due_issue3, due_issue4, due_issue2] end end context 'when sorting by relative position' do - let_it_be(:project) { create(:project) } + let_it_be(:project) { create(:project, :public) } let_it_be(:relative_issue1) { create(:issue, project: project, relative_position: 2000) } let_it_be(:relative_issue2) { create(:issue, project: project, relative_position: nil) } let_it_be(:relative_issue3) { create(:issue, project: project, relative_position: 1000) } let_it_be(:relative_issue4) { create(:issue, project: project, relative_position: nil) } it 'sorts issues ascending' do - expect(resolve_issues(sort: :relative_position_asc)).to eq [relative_issue3, relative_issue1, relative_issue4, relative_issue2] + expect(resolve_issues(sort: :relative_position_asc).to_a).to eq [relative_issue3, relative_issue1, relative_issue4, relative_issue2] end end context 'when sorting by priority' do - let_it_be(:project) { create(:project) } + let_it_be(:project) { create(:project, :public) } let_it_be(:early_milestone) { create(:milestone, project: project, due_date: 10.days.from_now) } let_it_be(:late_milestone) { create(:milestone, project: project, due_date: 30.days.from_now) } let_it_be(:priority_label1) { create(:label, project: project, priority: 1) } @@ -200,7 +204,7 @@ RSpec.describe Resolvers::IssuesResolver do end context 'when sorting by label priority' do - let_it_be(:project) { create(:project) } + let_it_be(:project) { create(:project, :public) } let_it_be(:label1) { create(:label, project: project, priority: 1) } let_it_be(:label2) { create(:label, project: project, priority: 5) } let_it_be(:label3) { create(:label, project: project, priority: 10) } @@ -219,7 +223,7 @@ RSpec.describe Resolvers::IssuesResolver do end context 'when sorting by milestone due date' do - let_it_be(:project) { create(:project) } + let_it_be(:project) { create(:project, :public) } let_it_be(:early_milestone) { create(:milestone, project: project, due_date: 10.days.from_now) } let_it_be(:late_milestone) { create(:milestone, project: project, due_date: 30.days.from_now) } let_it_be(:milestone_issue1) { create(:issue, project: project) } @@ -236,17 +240,17 @@ RSpec.describe Resolvers::IssuesResolver do end context 'when sorting by severity' do - let_it_be(:project) { create(:project) } + let_it_be(:project) { create(:project, :public) } let_it_be(:issue_high_severity) { create_issue_with_severity(project, severity: :high) } let_it_be(:issue_low_severity) { create_issue_with_severity(project, severity: :low) } let_it_be(:issue_no_severity) { create(:incident, project: project) } it 'sorts issues ascending' do - expect(resolve_issues(sort: :severity_asc)).to eq([issue_no_severity, issue_low_severity, issue_high_severity]) + expect(resolve_issues(sort: :severity_asc).to_a).to eq([issue_no_severity, issue_low_severity, issue_high_severity]) end it 'sorts issues descending' do - expect(resolve_issues(sort: :severity_desc)).to eq([issue_high_severity, issue_low_severity, issue_no_severity]) + expect(resolve_issues(sort: :severity_desc).to_a).to eq([issue_high_severity, issue_low_severity, issue_no_severity]) end end end @@ -267,7 +271,9 @@ RSpec.describe Resolvers::IssuesResolver do it 'batches queries that only include IIDs', :request_store do result = batch_sync(max_queries: 2) do - resolve_issues(iid: issue1.iid) + resolve_issues(iids: issue2.iid) + [issue1, issue2] + .map { |issue| resolve_issues(iid: issue.iid.to_s) } + .flat_map(&:to_a) end expect(result).to contain_exactly(issue1, issue2) diff --git a/spec/graphql/resolvers/merge_request_pipelines_resolver_spec.rb b/spec/graphql/resolvers/merge_request_pipelines_resolver_spec.rb index deb5ff584cf..84ef906b72f 100644 --- a/spec/graphql/resolvers/merge_request_pipelines_resolver_spec.rb +++ b/spec/graphql/resolvers/merge_request_pipelines_resolver_spec.rb @@ -24,7 +24,7 @@ RSpec.describe Resolvers::MergeRequestPipelinesResolver do end def resolve_pipelines - resolve(described_class, obj: merge_request, ctx: { current_user: current_user }) + sync(resolve(described_class, obj: merge_request, ctx: { current_user: current_user })) end it 'resolves only MRs for the passed merge request' do diff --git a/spec/graphql/resolvers/merge_requests_resolver_spec.rb b/spec/graphql/resolvers/merge_requests_resolver_spec.rb index 3a3393a185c..63fbd04848d 100644 --- a/spec/graphql/resolvers/merge_requests_resolver_spec.rb +++ b/spec/graphql/resolvers/merge_requests_resolver_spec.rb @@ -75,9 +75,9 @@ RSpec.describe Resolvers::MergeRequestsResolver do it 'can batch-resolve merge requests from different projects' do # 2 queries for project_authorizations, and 2 for merge_requests result = batch_sync(max_queries: queries_per_project * 2) do - resolve_mr(project, iids: iid_1) + - resolve_mr(project, iids: iid_2) + - resolve_mr(other_project, iids: other_iid) + resolve_mr(project, iids: [iid_1]) + + resolve_mr(project, iids: [iid_2]) + + resolve_mr(other_project, iids: [other_iid]) end expect(result).to contain_exactly(merge_request_1, merge_request_2, other_merge_request) @@ -110,7 +110,7 @@ RSpec.describe Resolvers::MergeRequestsResolver do context 'by source branches' do it 'takes one argument' do - result = resolve_mr(project, source_branch: [merge_request_3.source_branch]) + result = resolve_mr(project, source_branches: [merge_request_3.source_branch]) expect(result).to contain_exactly(merge_request_3) end @@ -118,7 +118,7 @@ RSpec.describe Resolvers::MergeRequestsResolver do it 'takes more than one argument' do mrs = [merge_request_3, merge_request_4] branches = mrs.map(&:source_branch) - result = resolve_mr(project, source_branch: branches ) + result = resolve_mr(project, source_branches: branches ) expect(result).to match_array(mrs) end @@ -126,7 +126,7 @@ RSpec.describe Resolvers::MergeRequestsResolver do context 'by target branches' do it 'takes one argument' do - result = resolve_mr(project, target_branch: [merge_request_3.target_branch]) + result = resolve_mr(project, target_branches: [merge_request_3.target_branch]) expect(result).to contain_exactly(merge_request_3) end @@ -134,7 +134,7 @@ RSpec.describe Resolvers::MergeRequestsResolver do it 'takes more than one argument' do mrs = [merge_request_3, merge_request_4] branches = mrs.map(&:target_branch) - result = resolve_mr(project, target_branch: branches ) + result = resolve_mr(project, target_branches: branches ) expect(result.compact).to match_array(mrs) end @@ -153,13 +153,13 @@ RSpec.describe Resolvers::MergeRequestsResolver do let_it_be(:with_label) { create(:labeled_merge_request, :closed, labels: [label], **common_attrs) } it 'takes one argument' do - result = resolve_mr(project, label_name: [label.title]) + result = resolve_mr(project, labels: [label.title]) expect(result).to contain_exactly(merge_request_6, with_label) end it 'takes multiple arguments, with semantics of ALL MUST MATCH' do - result = resolve_mr(project, label_name: merge_request_6.labels.map(&:title)) + result = resolve_mr(project, labels: merge_request_6.labels.map(&:title)) expect(result).to contain_exactly(merge_request_6) end @@ -201,7 +201,7 @@ RSpec.describe Resolvers::MergeRequestsResolver do it 'requires all filters' do create(:merge_request, :closed, source_project: project, target_project: project, source_branch: merge_request_4.source_branch) - result = resolve_mr(project, source_branch: [merge_request_4.source_branch], state: 'locked') + result = resolve_mr(project, source_branches: [merge_request_4.source_branch], state: 'locked') expect(result.compact).to contain_exactly(merge_request_4) end @@ -236,7 +236,7 @@ RSpec.describe Resolvers::MergeRequestsResolver do end def resolve_mr_single(project, iid) - resolve_mr(project, resolver: described_class.single, iids: iid) + resolve_mr(project, resolver: described_class.single, iid: iid.to_s) end def resolve_mr(project, resolver: described_class, user: current_user, **args) diff --git a/spec/graphql/resolvers/project_merge_requests_resolver_spec.rb b/spec/graphql/resolvers/project_merge_requests_resolver_spec.rb index bfb3ce91d58..45777aa96e1 100644 --- a/spec/graphql/resolvers/project_merge_requests_resolver_spec.rb +++ b/spec/graphql/resolvers/project_merge_requests_resolver_spec.rb @@ -8,14 +8,16 @@ RSpec.describe Resolvers::ProjectMergeRequestsResolver do let_it_be(:project) { create(:project, :repository) } let_it_be(:current_user) { create(:user) } let_it_be(:other_user) { create(:user) } + let_it_be(:reviewer) { create(:user) } - let_it_be(:merge_request_with_author_and_assignee) do + let_it_be(:merge_request) do create(:merge_request, :unique_branches, source_project: project, target_project: project, author: other_user, - assignee: other_user) + assignee: other_user, + reviewers: [reviewer]) end before do @@ -26,7 +28,7 @@ RSpec.describe Resolvers::ProjectMergeRequestsResolver do it 'filters merge requests by assignee username' do result = resolve_mr(project, assignee_username: other_user.username) - expect(result).to eq([merge_request_with_author_and_assignee]) + expect(result).to contain_exactly(merge_request) end it 'does not find anything' do @@ -40,7 +42,7 @@ RSpec.describe Resolvers::ProjectMergeRequestsResolver do it 'filters merge requests by author username' do result = resolve_mr(project, author_username: other_user.username) - expect(result).to eq([merge_request_with_author_and_assignee]) + expect(result).to contain_exactly(merge_request) end it 'does not find anything' do @@ -50,7 +52,21 @@ RSpec.describe Resolvers::ProjectMergeRequestsResolver do end end - def resolve_mr(project, args, resolver: described_class, user: current_user) + context 'by reviewer' do + it 'filters merge requests by reviewer username' do + result = resolve_mr(project, reviewer_username: reviewer.username) + + expect(result).to contain_exactly(merge_request) + end + + it 'does not find anything' do + result = resolve_mr(project, reviewer_username: 'unknown-user') + + expect(result).to be_empty + end + end + + def resolve_mr(project, resolver: described_class, user: current_user, **args) resolve(resolver, obj: project, args: args, ctx: { current_user: user }) end end diff --git a/spec/graphql/resolvers/project_pipeline_resolver_spec.rb b/spec/graphql/resolvers/project_pipeline_resolver_spec.rb index 1950c2ca067..b852b349d4f 100644 --- a/spec/graphql/resolvers/project_pipeline_resolver_spec.rb +++ b/spec/graphql/resolvers/project_pipeline_resolver_spec.rb @@ -18,6 +18,10 @@ RSpec.describe Resolvers::ProjectPipelineResolver do resolve(described_class, obj: project, args: args, ctx: { current_user: current_user }) end + before do + project.add_developer(current_user) + end + it 'resolves pipeline for the passed iid' do result = batch_sync do resolve_pipeline(project, { iid: '1234' }) @@ -26,6 +30,21 @@ RSpec.describe Resolvers::ProjectPipelineResolver do expect(result).to eq(pipeline) end + it 'keeps the queries under the threshold' do + create(:ci_pipeline, project: project, iid: '1235') + + control = ActiveRecord::QueryRecorder.new do + batch_sync { resolve_pipeline(project, { iid: '1234' }) } + end + + expect do + batch_sync do + resolve_pipeline(project, { iid: '1234' }) + resolve_pipeline(project, { iid: '1235' }) + end + end.not_to exceed_query_limit(control) + end + it 'does not resolve a pipeline outside the project' do result = batch_sync do resolve_pipeline(other_pipeline.project, { iid: '1234' }) diff --git a/spec/graphql/resolvers/project_pipeline_statistics_resolver_spec.rb b/spec/graphql/resolvers/project_pipeline_statistics_resolver_spec.rb new file mode 100644 index 00000000000..c0367f7d42e --- /dev/null +++ b/spec/graphql/resolvers/project_pipeline_statistics_resolver_spec.rb @@ -0,0 +1,36 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::ProjectPipelineStatisticsResolver do + include GraphqlHelpers + + let_it_be(:project) { create(:project) } + + specify do + expect(described_class).to have_nullable_graphql_type(::Types::Ci::AnalyticsType) + end + + def resolve_statistics(project, args) + resolve(described_class, obj: project, args: args) + end + + describe '#resolve' do + it 'returns the pipelines statistics for a given project' do + result = resolve_statistics(project, {}) + expect(result.keys).to contain_exactly( + :week_pipelines_labels, + :week_pipelines_totals, + :week_pipelines_successful, + :month_pipelines_labels, + :month_pipelines_totals, + :month_pipelines_successful, + :year_pipelines_labels, + :year_pipelines_totals, + :year_pipelines_successful, + :pipeline_times_labels, + :pipeline_times_values + ) + end + end +end diff --git a/spec/graphql/resolvers/projects/jira_imports_resolver_spec.rb b/spec/graphql/resolvers/projects/jira_imports_resolver_spec.rb deleted file mode 100644 index ad59cb6b95e..00000000000 --- a/spec/graphql/resolvers/projects/jira_imports_resolver_spec.rb +++ /dev/null @@ -1,73 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe Resolvers::Projects::JiraImportsResolver do - include GraphqlHelpers - - specify do - expect(described_class).to have_nullable_graphql_type(Types::JiraImportType.connection_type) - end - - describe '#resolve' do - let_it_be(:user) { create(:user) } - let_it_be(:project, reload: true) { create(:project, :public) } - - context 'when project does not have Jira imports' do - let(:current_user) { user } - - context 'when user cannot read Jira imports' do - context 'when anonymous user' do - let(:current_user) { nil } - - it_behaves_like 'no Jira import access' - end - end - - context 'when user can read Jira import data' do - before do - project.add_guest(user) - end - - it_behaves_like 'no Jira import data present' - - it 'does not raise access error' do - expect do - resolve_imports - end.not_to raise_error - end - end - end - - context 'when project has Jira imports' do - let_it_be(:current_user) { user } - let_it_be(:jira_import1) { create(:jira_import_state, :finished, project: project, jira_project_key: 'AA', created_at: 2.days.ago) } - let_it_be(:jira_import2) { create(:jira_import_state, :finished, project: project, jira_project_key: 'BB', created_at: 5.days.ago) } - - context 'when user cannot read Jira imports' do - context 'when anonymous user' do - let(:current_user) { nil } - - it_behaves_like 'no Jira import access' - end - end - - context 'when user can access Jira imports' do - before do - project.add_guest(user) - end - - it 'returns Jira imports sorted ascending by created_at time' do - imports = resolve_imports - - expect(imports.size).to eq 2 - expect(imports.map(&:jira_project_key)).to eq %w(BB AA) - end - end - end - end - - def resolve_imports(args = {}, context = { current_user: current_user }) - resolve(described_class, obj: project, args: args, ctx: context) - end -end diff --git a/spec/graphql/resolvers/projects/snippets_resolver_spec.rb b/spec/graphql/resolvers/projects/snippets_resolver_spec.rb index 6f7feff8fe5..2d8929c0e8f 100644 --- a/spec/graphql/resolvers/projects/snippets_resolver_spec.rb +++ b/spec/graphql/resolvers/projects/snippets_resolver_spec.rb @@ -6,16 +6,18 @@ RSpec.describe Resolvers::Projects::SnippetsResolver do include GraphqlHelpers describe '#resolve' do - let_it_be(:current_user) { create(:user) } + let_it_be(:user) { create(:user) } let_it_be(:other_user) { create(:user) } let_it_be(:project) { create(:project) } - let_it_be(:personal_snippet) { create(:personal_snippet, :private, author: current_user) } - let_it_be(:project_snippet) { create(:project_snippet, :internal, author: current_user, project: project) } + let_it_be(:personal_snippet) { create(:personal_snippet, :private, author: user) } + let_it_be(:project_snippet) { create(:project_snippet, :internal, author: user, project: project) } let_it_be(:other_project_snippet) { create(:project_snippet, :public, author: other_user, project: project) } - before do - project.add_developer(current_user) + let(:current_user) { user } + + before_all do + project.add_developer(user) end it 'calls SnippetsFinder' do @@ -42,20 +44,26 @@ RSpec.describe Resolvers::Projects::SnippetsResolver do end it 'returns the snippets by gid' do - snippets = resolve_snippets(args: { ids: project_snippet.to_global_id }) + snippets = resolve_snippets(args: { ids: [global_id_of(project_snippet)] }) expect(snippets).to contain_exactly(project_snippet) end it 'returns the snippets by array of gid' do args = { - ids: [project_snippet.to_global_id, other_project_snippet.to_global_id] + ids: [global_id_of(project_snippet), global_id_of(other_project_snippet)] } snippets = resolve_snippets(args: args) expect(snippets).to contain_exactly(project_snippet, other_project_snippet) end + + it 'returns an error if the gid is invalid' do + expect do + resolve_snippets(args: { ids: ['foo'] }) + end.to raise_error(GraphQL::CoercionError) + end end context 'when no project is provided' do @@ -65,8 +73,10 @@ RSpec.describe Resolvers::Projects::SnippetsResolver do end context 'when provided user is not current user' do + let(:current_user) { other_user } + it 'returns no snippets' do - expect(resolve_snippets(context: { current_user: other_user }, args: { ids: project_snippet.to_global_id })).to be_empty + expect(resolve_snippets(args: { ids: [global_id_of(project_snippet)] })).to be_empty end end diff --git a/spec/graphql/resolvers/releases_resolver_spec.rb b/spec/graphql/resolvers/releases_resolver_spec.rb index b9b90686aa7..89623be891f 100644 --- a/spec/graphql/resolvers/releases_resolver_spec.rb +++ b/spec/graphql/resolvers/releases_resolver_spec.rb @@ -17,6 +17,7 @@ RSpec.describe Resolvers::ReleasesResolver do let_it_be(:public_user) { create(:user) } let(:args) { { sort: :released_at_desc } } + let(:all_releases) { [release_v1, release_v2, release_v3] } before do project.add_developer(developer) @@ -27,7 +28,7 @@ RSpec.describe Resolvers::ReleasesResolver do let(:current_user) { public_user } it 'returns an empty array' do - expect(resolve_releases).to eq([]) + expect(resolve_releases).to be_empty end end @@ -35,7 +36,7 @@ RSpec.describe Resolvers::ReleasesResolver do let(:current_user) { developer } it 'returns all releases associated to the project' do - expect(resolve_releases).to eq([release_v3, release_v2, release_v1]) + expect(resolve_releases).to match_array(all_releases) end describe 'sorting behavior' do @@ -43,7 +44,9 @@ RSpec.describe Resolvers::ReleasesResolver do let(:args) { { sort: :released_at_desc } } it 'returns the releases ordered by released_at in descending order' do - expect(resolve_releases).to eq([release_v3, release_v2, release_v1]) + expect(resolve_releases.to_a) + .to match_array(all_releases) + .and be_sorted(:released_at, :desc) end end @@ -51,7 +54,9 @@ RSpec.describe Resolvers::ReleasesResolver do let(:args) { { sort: :released_at_asc } } it 'returns the releases ordered by released_at in ascending order' do - expect(resolve_releases).to eq([release_v1, release_v2, release_v3]) + expect(resolve_releases.to_a) + .to match_array(all_releases) + .and be_sorted(:released_at, :asc) end end @@ -59,7 +64,9 @@ RSpec.describe Resolvers::ReleasesResolver do let(:args) { { sort: :created_desc } } it 'returns the releases ordered by created_at in descending order' do - expect(resolve_releases).to eq([release_v1, release_v3, release_v2]) + expect(resolve_releases.to_a) + .to match_array(all_releases) + .and be_sorted(:created_at, :desc) end end @@ -67,7 +74,9 @@ RSpec.describe Resolvers::ReleasesResolver do let(:args) { { sort: :created_asc } } it 'returns the releases ordered by created_at in ascending order' do - expect(resolve_releases).to eq([release_v2, release_v3, release_v1]) + expect(resolve_releases.to_a) + .to match_array(all_releases) + .and be_sorted(:created_at, :asc) end end end diff --git a/spec/graphql/resolvers/snippets/blobs_resolver_spec.rb b/spec/graphql/resolvers/snippets/blobs_resolver_spec.rb index 16e69f662c0..ebe286769cf 100644 --- a/spec/graphql/resolvers/snippets/blobs_resolver_spec.rb +++ b/spec/graphql/resolvers/snippets/blobs_resolver_spec.rb @@ -16,16 +16,18 @@ RSpec.describe Resolvers::Snippets::BlobsResolver do context 'when user is not authorized' do let(:other_user) { create(:user) } - it 'raises an error' do - expect do - resolve_blobs(snippet, user: other_user) - end.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + it 'redacts the field' do + expect(resolve_blobs(snippet, user: other_user)).to be_nil end end context 'when using no filter' do it 'returns all snippet blobs' do - expect(resolve_blobs(snippet).map(&:path)).to contain_exactly(*snippet.list_files) + result = resolve_blobs(snippet, args: {}) + + expect(result).to match_array(snippet.list_files.map do |file| + have_attributes(path: file) + end) end end @@ -34,7 +36,13 @@ RSpec.describe Resolvers::Snippets::BlobsResolver do it 'returns an array of files' do path = 'CHANGELOG' - expect(resolve_blobs(snippet, args: { paths: path }).first.path).to eq(path) + expect(resolve_blobs(snippet, paths: [path])).to contain_exactly(have_attributes(path: path)) + end + end + + context 'the argument does not match anything' do + it 'returns an empty result' do + expect(resolve_blobs(snippet, paths: ['does not exist'])).to be_empty end end @@ -42,13 +50,15 @@ RSpec.describe Resolvers::Snippets::BlobsResolver do it 'returns an array of files' do paths = ['CHANGELOG', 'README.md'] - expect(resolve_blobs(snippet, args: { paths: paths }).map(&:path)).to contain_exactly(*paths) + expect(resolve_blobs(snippet, paths: paths)).to match_array(paths.map do |file| + have_attributes(path: file) + end) end end end end - def resolve_blobs(snippet, user: current_user, args: {}) + def resolve_blobs(snippet, user: current_user, paths: [], args: { paths: paths }) resolve(described_class, args: args, ctx: { current_user: user }, obj: snippet) end end diff --git a/spec/graphql/resolvers/snippets_resolver_spec.rb b/spec/graphql/resolvers/snippets_resolver_spec.rb index a58d9c5ac3a..11cb1c0ec4b 100644 --- a/spec/graphql/resolvers/snippets_resolver_spec.rb +++ b/spec/graphql/resolvers/snippets_resolver_spec.rb @@ -84,19 +84,18 @@ RSpec.describe Resolvers::SnippetsResolver do end it 'returns the snippets by single gid' do - snippets = resolve_snippets(args: { ids: personal_snippet.to_global_id }) + snippets = resolve_snippets(args: { ids: [global_id_of(personal_snippet)] }) expect(snippets).to contain_exactly(personal_snippet) end it 'returns the snippets by array of gid' do - args = { - ids: [personal_snippet.to_global_id, project_snippet.to_global_id] - } + snippets = [personal_snippet, project_snippet] + args = { ids: snippets.map { |s| global_id_of(s) } } - snippets = resolve_snippets(args: args) + found = resolve_snippets(args: args) - expect(snippets).to contain_exactly(personal_snippet, project_snippet) + expect(found).to match_array(snippets) end it 'returns an error if the id cannot be coerced' do diff --git a/spec/graphql/resolvers/todo_resolver_spec.rb b/spec/graphql/resolvers/todo_resolver_spec.rb index c764f389c16..ac14852b365 100644 --- a/spec/graphql/resolvers/todo_resolver_spec.rb +++ b/spec/graphql/resolvers/todo_resolver_spec.rb @@ -20,7 +20,7 @@ RSpec.describe Resolvers::TodoResolver do it 'calls TodosFinder' do expect_next_instance_of(TodosFinder) do |finder| - expect(finder).to receive(:execute) + expect(finder).to receive(:execute).and_call_original end resolve_todos @@ -48,7 +48,7 @@ RSpec.describe Resolvers::TodoResolver do end it 'returns the todos for single filter' do - todos = resolve_todos(type: 'MergeRequest') + todos = resolve_todos(type: ['MergeRequest']) expect(todos).to contain_exactly(merge_request_todo_pending) end diff --git a/spec/graphql/resolvers/user_discussions_count_resolver_spec.rb b/spec/graphql/resolvers/user_discussions_count_resolver_spec.rb new file mode 100644 index 00000000000..cc855bbcb53 --- /dev/null +++ b/spec/graphql/resolvers/user_discussions_count_resolver_spec.rb @@ -0,0 +1,54 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::UserDiscussionsCountResolver do + include GraphqlHelpers + + describe '#resolve' do + let_it_be(:user) { create(:user) } + let_it_be(:project) { create(:project, :public) } + let_it_be(:private_project) { create(:project, :private) } + let_it_be(:issue) { create(:issue, project: project) } + let_it_be(:private_issue) { create(:issue, project: private_project) } + let_it_be(:public_discussions) { create_list(:discussion_note_on_issue, 2, noteable: issue, project: project) } + let_it_be(:system_discussion) { create(:discussion_note_on_issue, system: true, noteable: issue, project: project) } + let_it_be(:private_discussion) { create_list(:discussion_note_on_issue, 3, noteable: private_issue, project: private_project) } + + specify do + expect(described_class).to have_nullable_graphql_type(GraphQL::INT_TYPE) + end + + context 'when counting discussions from a public issue' do + subject { batch_sync { resolve_user_discussions_count(issue) } } + + it 'returns the number of discussions for the issue' do + expect(subject).to eq(2) + end + end + + context 'when a user has permission to view discussions' do + before do + private_project.add_developer(user) + end + + subject { batch_sync { resolve_user_discussions_count(private_issue) } } + + it 'returns the number of non-system discussions for the issue' do + expect(subject).to eq(3) + end + end + + context 'when a user does not have permission to view discussions' do + subject { batch_sync { resolve_user_discussions_count(private_issue) } } + + it 'returns no discussions' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + end + + def resolve_user_discussions_count(obj) + resolve(described_class, obj: obj, ctx: { current_user: user }) + end +end diff --git a/spec/graphql/resolvers/user_notes_count_resolver_spec.rb b/spec/graphql/resolvers/user_notes_count_resolver_spec.rb new file mode 100644 index 00000000000..3cb0810c698 --- /dev/null +++ b/spec/graphql/resolvers/user_notes_count_resolver_spec.rb @@ -0,0 +1,93 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::UserNotesCountResolver do + include GraphqlHelpers + + describe '#resolve' do + let_it_be(:user) { create(:user) } + let_it_be(:project) { create(:project, :repository, :public) } + let_it_be(:private_project) { create(:project, :repository, :private) } + + specify do + expect(described_class).to have_nullable_graphql_type(GraphQL::INT_TYPE) + end + + context 'when counting notes from an issue' do + let_it_be(:issue) { create(:issue, project: project) } + let_it_be(:private_issue) { create(:issue, project: private_project) } + let_it_be(:public_notes) { create_list(:note, 2, noteable: issue, project: project) } + let_it_be(:system_note) { create(:note, system: true, noteable: issue, project: project) } + let_it_be(:private_notes) { create_list(:note, 3, noteable: private_issue, project: private_project) } + + context 'when counting notes from a public issue' do + subject { batch_sync { resolve_user_notes_count(issue) } } + + it 'returns the number of non-system notes for the issue' do + expect(subject).to eq(2) + end + end + + context 'when a user has permission to view notes' do + before do + private_project.add_developer(user) + end + + subject { batch_sync { resolve_user_notes_count(private_issue) } } + + it 'returns the number of notes for the issue' do + expect(subject).to eq(3) + end + end + + context 'when a user does not have permission to view notes' do + subject { batch_sync { resolve_user_notes_count(private_issue) } } + + it 'returns no notes' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + end + + context 'when counting notes from a merge request' do + let_it_be(:merge_request) { create(:merge_request, source_project: project) } + let_it_be(:private_merge_request) { create(:merge_request, source_project: private_project) } + let_it_be(:public_notes) { create_list(:note, 2, noteable: merge_request, project: project) } + let_it_be(:system_note) { create(:note, system: true, noteable: merge_request, project: project) } + let_it_be(:private_notes) { create_list(:note, 3, noteable: private_merge_request, project: private_project) } + + context 'when counting notes from a public merge request' do + subject { batch_sync { resolve_user_notes_count(merge_request) } } + + it 'returns the number of non-system notes for the merge request' do + expect(subject).to eq(2) + end + end + + context 'when a user has permission to view notes' do + before do + private_project.add_developer(user) + end + + subject { batch_sync { resolve_user_notes_count(private_merge_request) } } + + it 'returns the number of notes for the merge request' do + expect(subject).to eq(3) + end + end + + context 'when a user does not have permission to view notes' do + subject { batch_sync { resolve_user_notes_count(private_merge_request) } } + + it 'returns no notes' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + end + end + + def resolve_user_notes_count(obj) + resolve(described_class, obj: obj, ctx: { current_user: user }) + end +end diff --git a/spec/graphql/resolvers/users/snippets_resolver_spec.rb b/spec/graphql/resolvers/users/snippets_resolver_spec.rb index 9ccbebc59e6..11a5b7517e0 100644 --- a/spec/graphql/resolvers/users/snippets_resolver_spec.rb +++ b/spec/graphql/resolvers/users/snippets_resolver_spec.rb @@ -51,24 +51,23 @@ RSpec.describe Resolvers::Users::SnippetsResolver do end it 'returns the snippets by single gid' do - snippets = resolve_snippets(args: { ids: private_personal_snippet.to_global_id }) + snippets = resolve_snippets(args: { ids: [global_id_of(private_personal_snippet)] }) expect(snippets).to contain_exactly(private_personal_snippet) end it 'returns the snippets by array of gid' do - args = { - ids: [private_personal_snippet.to_global_id, public_personal_snippet.to_global_id] - } + snippets = [private_personal_snippet, public_personal_snippet] + args = { ids: snippets.map { |s| global_id_of(s) } } - snippets = resolve_snippets(args: args) + found = resolve_snippets(args: args) - expect(snippets).to contain_exactly(private_personal_snippet, public_personal_snippet) + expect(found).to match_array(snippets) end it 'returns an error if the gid is invalid' do args = { - ids: [private_personal_snippet.to_global_id, 'foo'] + ids: [global_id_of(private_personal_snippet), 'foo'] } expect do diff --git a/spec/graphql/types/alert_management/domain_filter_enum_spec.rb b/spec/graphql/types/alert_management/domain_filter_enum_spec.rb new file mode 100644 index 00000000000..2111a33b8b4 --- /dev/null +++ b/spec/graphql/types/alert_management/domain_filter_enum_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['AlertManagementDomainFilter'] do + specify { expect(described_class.graphql_name).to eq('AlertManagementDomainFilter') } + + it 'exposes all the severity values' do + expect(described_class.values.keys).to include(*%w[threat_monitoring operations]) + end +end diff --git a/spec/graphql/types/alert_management/prometheus_integration_type_spec.rb b/spec/graphql/types/alert_management/prometheus_integration_type_spec.rb index 0e9994035d8..b10c2a2ab2a 100644 --- a/spec/graphql/types/alert_management/prometheus_integration_type_spec.rb +++ b/spec/graphql/types/alert_management/prometheus_integration_type_spec.rb @@ -11,11 +11,14 @@ RSpec.describe GitlabSchema.types['AlertManagementPrometheusIntegration'] do describe 'resolvers' do shared_examples_for 'has field with value' do |field_name| it 'correctly renders the field' do - expect(resolve_field(field_name, integration)).to eq(value) + result = resolve_field(field_name, integration, current_user: user) + + expect(result).to eq(value) end end let_it_be_with_reload(:integration) { create(:prometheus_service) } + let_it_be(:user) { create(:user, maintainer_projects: [integration.project]) } it_behaves_like 'has field with value', 'name' do let(:value) { integration.title } diff --git a/spec/graphql/types/base_field_spec.rb b/spec/graphql/types/base_field_spec.rb index d61ea6aa6e9..54b59317b55 100644 --- a/spec/graphql/types/base_field_spec.rb +++ b/spec/graphql/types/base_field_spec.rb @@ -145,11 +145,11 @@ RSpec.describe Types::BaseField do describe '#description' do context 'feature flag given' do - let(:field) { described_class.new(name: 'test', type: GraphQL::STRING_TYPE, feature_flag: flag, null: false, description: 'Test description') } + let(:field) { described_class.new(name: 'test', type: GraphQL::STRING_TYPE, feature_flag: flag, null: false, description: 'Test description.') } let(:flag) { :test_flag } it 'prepends the description' do - expect(field.description). to eq 'Test description. Available only when feature flag `test_flag` is enabled' + expect(field.description). to eq 'Test description. Available only when feature flag `test_flag` is enabled.' end context 'falsey feature_flag values' do @@ -164,7 +164,7 @@ RSpec.describe Types::BaseField do with_them do it 'returns the correct description' do - expect(field.description).to eq('Test description') + expect(field.description).to eq('Test description.') end end end @@ -181,11 +181,11 @@ RSpec.describe Types::BaseField do it 'interacts well with the `feature_flag` property' do field = subject( deprecated: { milestone: '1.10', reason: 'Deprecation reason' }, - description: 'Field description', + description: 'Field description.', feature_flag: 'foo_flag' ) - expectation = 'Field description. Available only when feature flag `foo_flag` is enabled. Deprecated in 1.10: Deprecation reason' + expectation = 'Field description. Available only when feature flag `foo_flag` is enabled. Deprecated in 1.10: Deprecation reason.' expect(field.description).to eq(expectation) end diff --git a/spec/graphql/types/ci/analytics_type_spec.rb b/spec/graphql/types/ci/analytics_type_spec.rb new file mode 100644 index 00000000000..c8462d40769 --- /dev/null +++ b/spec/graphql/types/ci/analytics_type_spec.rb @@ -0,0 +1,23 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Ci::AnalyticsType do + it 'exposes the expected fields' do + expected_fields = %i[ + weekPipelinesTotals + weekPipelinesLabels + weekPipelinesSuccessful + monthPipelinesLabels + monthPipelinesTotals + monthPipelinesSuccessful + yearPipelinesLabels + yearPipelinesTotals + yearPipelinesSuccessful + pipelineTimesLabels + pipelineTimesValues + ] + + expect(described_class).to have_graphql_fields(*expected_fields) + end +end diff --git a/spec/graphql/types/ci/config/config_type_spec.rb b/spec/graphql/types/ci/config/config_type_spec.rb new file mode 100644 index 00000000000..edd190a4365 --- /dev/null +++ b/spec/graphql/types/ci/config/config_type_spec.rb @@ -0,0 +1,18 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Ci::Config::ConfigType do + specify { expect(described_class.graphql_name).to eq('CiConfig') } + + it 'exposes the expected fields' do + expected_fields = %i[ + errors + mergedYaml + stages + status + ] + + expect(described_class).to have_graphql_fields(*expected_fields) + end +end diff --git a/spec/graphql/types/ci/config/group_type_spec.rb b/spec/graphql/types/ci/config/group_type_spec.rb new file mode 100644 index 00000000000..7d808e85371 --- /dev/null +++ b/spec/graphql/types/ci/config/group_type_spec.rb @@ -0,0 +1,17 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Ci::Config::GroupType do + specify { expect(described_class.graphql_name).to eq('CiConfigGroup') } + + it 'exposes the expected fields' do + expected_fields = %i[ + name + jobs + size + ] + + expect(described_class).to have_graphql_fields(*expected_fields) + end +end diff --git a/spec/graphql/types/ci/config/job_type_spec.rb b/spec/graphql/types/ci/config/job_type_spec.rb new file mode 100644 index 00000000000..600d665a84b --- /dev/null +++ b/spec/graphql/types/ci/config/job_type_spec.rb @@ -0,0 +1,18 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Ci::Config::JobType do + specify { expect(described_class.graphql_name).to eq('CiConfigJob') } + + it 'exposes the expected fields' do + expected_fields = %i[ + name + group_name + stage + needs + ] + + expect(described_class).to have_graphql_fields(*expected_fields) + end +end diff --git a/spec/graphql/types/ci/config/need_type_spec.rb b/spec/graphql/types/ci/config/need_type_spec.rb new file mode 100644 index 00000000000..3387049a81d --- /dev/null +++ b/spec/graphql/types/ci/config/need_type_spec.rb @@ -0,0 +1,15 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Ci::Config::NeedType do + specify { expect(described_class.graphql_name).to eq('CiConfigNeed') } + + it 'exposes the expected fields' do + expected_fields = %i[ + name + ] + + expect(described_class).to have_graphql_fields(*expected_fields) + end +end diff --git a/spec/graphql/types/ci/config/stage_type_spec.rb b/spec/graphql/types/ci/config/stage_type_spec.rb new file mode 100644 index 00000000000..aba97f8c7ed --- /dev/null +++ b/spec/graphql/types/ci/config/stage_type_spec.rb @@ -0,0 +1,16 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Ci::Config::StageType do + specify { expect(described_class.graphql_name).to eq('CiConfigStage') } + + 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/job_artifact_file_type_enum_spec.rb b/spec/graphql/types/ci/job_artifact_file_type_enum_spec.rb new file mode 100644 index 00000000000..78a32595730 --- /dev/null +++ b/spec/graphql/types/ci/job_artifact_file_type_enum_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['JobArtifactFileType'] do + it 'exposes all job artifact file types' do + expect(described_class.values.keys).to contain_exactly( + *::Ci::JobArtifact::TYPE_AND_FORMAT_PAIRS.keys.map(&:to_s).map(&:upcase) + ) + end +end diff --git a/spec/graphql/types/ci/job_artifact_type_spec.rb b/spec/graphql/types/ci/job_artifact_type_spec.rb new file mode 100644 index 00000000000..d4dc5ef214d --- /dev/null +++ b/spec/graphql/types/ci/job_artifact_type_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['CiJobArtifact'] do + it 'has the correct fields' do + expected_fields = [:download_path, :file_type] + + 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 index 3dcb81eefbf..441a719df8c 100644 --- a/spec/graphql/types/ci/job_type_spec.rb +++ b/spec/graphql/types/ci/job_type_spec.rb @@ -12,6 +12,7 @@ RSpec.describe Types::Ci::JobType do needs detailedStatus scheduledAt + artifacts ] expect(described_class).to have_graphql_fields(*expected_fields) diff --git a/spec/graphql/types/ci/pipeline_type_spec.rb b/spec/graphql/types/ci/pipeline_type_spec.rb index f13f1c9afb2..d435e337ad7 100644 --- a/spec/graphql/types/ci/pipeline_type_spec.rb +++ b/spec/graphql/types/ci/pipeline_type_spec.rb @@ -6,4 +6,19 @@ RSpec.describe Types::Ci::PipelineType do specify { expect(described_class.graphql_name).to eq('Pipeline') } specify { expect(described_class).to expose_permissions_using(Types::PermissionTypes::Ci::Pipeline) } + + it 'contains attributes related to a pipeline' do + expected_fields = %w[ + id iid sha before_sha status detailed_status config_source duration + coverage created_at updated_at started_at finished_at committed_at + stages user retryable cancelable jobs source_job downstream + upstream path project active user_permissions + ] + + if Gitlab.ee? + expected_fields << 'security_report_summary' + end + + expect(described_class).to have_graphql_fields(*expected_fields) + end end diff --git a/spec/graphql/types/commit_type_spec.rb b/spec/graphql/types/commit_type_spec.rb index e9bc7f6bb94..b43693e5804 100644 --- a/spec/graphql/types/commit_type_spec.rb +++ b/spec/graphql/types/commit_type_spec.rb @@ -9,7 +9,7 @@ RSpec.describe GitlabSchema.types['Commit'] do it 'contains attributes related to commit' do expect(described_class).to have_graphql_fields( - :id, :sha, :title, :description, :description_html, :message, :title_html, :authored_date, + :id, :sha, :short_id, :title, :description, :description_html, :message, :title_html, :authored_date, :author_name, :author_gravatar, :author, :web_url, :web_path, :pipelines, :signature_html ) diff --git a/spec/graphql/types/container_repository_details_type_spec.rb b/spec/graphql/types/container_repository_details_type_spec.rb index b5ff460fcf7..45f6449d8c8 100644 --- a/spec/graphql/types/container_repository_details_type_spec.rb +++ b/spec/graphql/types/container_repository_details_type_spec.rb @@ -3,7 +3,7 @@ require 'spec_helper' RSpec.describe GitlabSchema.types['ContainerRepositoryDetails'] do - fields = %i[id name path location created_at updated_at expiration_policy_started_at status tags_count can_delete expiration_policy_cleanup_status tags] + fields = %i[id name path location created_at updated_at expiration_policy_started_at status tags_count can_delete expiration_policy_cleanup_status tags project] it { expect(described_class.graphql_name).to eq('ContainerRepositoryDetails') } diff --git a/spec/graphql/types/container_repository_type_spec.rb b/spec/graphql/types/container_repository_type_spec.rb index 3d3445ba5c3..87e1c11ce19 100644 --- a/spec/graphql/types/container_repository_type_spec.rb +++ b/spec/graphql/types/container_repository_type_spec.rb @@ -3,7 +3,7 @@ require 'spec_helper' RSpec.describe GitlabSchema.types['ContainerRepository'] do - fields = %i[id name path location created_at updated_at expiration_policy_started_at status tags_count can_delete expiration_policy_cleanup_status] + fields = %i[id name path location created_at updated_at expiration_policy_started_at status tags_count can_delete expiration_policy_cleanup_status project] it { expect(described_class.graphql_name).to eq('ContainerRepository') } diff --git a/spec/graphql/types/countable_connection_type_spec.rb b/spec/graphql/types/countable_connection_type_spec.rb index 3b3c02baa5d..648dbacff42 100644 --- a/spec/graphql/types/countable_connection_type_spec.rb +++ b/spec/graphql/types/countable_connection_type_spec.rb @@ -2,7 +2,7 @@ require 'spec_helper' -RSpec.describe GitlabSchema.types['MergeRequestConnection'] do +RSpec.describe GitlabSchema.types['PipelineConnection'] do it 'has the expected fields' do expected_fields = %i[count page_info edges nodes] diff --git a/spec/graphql/types/group_member_relation_enum_spec.rb b/spec/graphql/types/group_member_relation_enum_spec.rb new file mode 100644 index 00000000000..315809ef75e --- /dev/null +++ b/spec/graphql/types/group_member_relation_enum_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::GroupMemberRelationEnum do + specify { expect(described_class.graphql_name).to eq('GroupMemberRelation') } + + it 'exposes all the existing group member relation type values' do + expect(described_class.values.keys).to contain_exactly('DIRECT', 'INHERITED', 'DESCENDANTS') + end +end diff --git a/spec/graphql/types/group_type_spec.rb b/spec/graphql/types/group_type_spec.rb index 7d14ef87551..de19e8b602a 100644 --- a/spec/graphql/types/group_type_spec.rb +++ b/spec/graphql/types/group_type_spec.rb @@ -17,7 +17,7 @@ RSpec.describe GitlabSchema.types['Group'] do subgroup_creation_level require_two_factor_authentication two_factor_grace_period auto_devops_enabled emails_disabled mentions_disabled parent boards milestones group_members - merge_requests + merge_requests container_repositories container_repositories_count ] expect(described_class).to include_graphql_fields(*expected_fields) diff --git a/spec/graphql/types/merge_request_connection_type_spec.rb b/spec/graphql/types/merge_request_connection_type_spec.rb new file mode 100644 index 00000000000..f4ab6c79721 --- /dev/null +++ b/spec/graphql/types/merge_request_connection_type_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['MergeRequestConnection'] do + it 'has the expected fields' do + expected_fields = %i[count totalTimeToMerge page_info edges nodes] + + expect(described_class).to have_graphql_fields(*expected_fields) + end +end diff --git a/spec/graphql/types/merge_request_type_spec.rb b/spec/graphql/types/merge_request_type_spec.rb index 8800250b103..51e7b4029d5 100644 --- a/spec/graphql/types/merge_request_type_spec.rb +++ b/spec/graphql/types/merge_request_type_spec.rb @@ -27,18 +27,27 @@ RSpec.describe GitlabSchema.types['MergeRequest'] do upvotes downvotes head_pipeline pipelines task_completion_status milestone assignees participants subscribed labels discussion_locked time_estimate total_time_spent reference author merged_at commit_count current_user_todos - conflicts auto_merge_enabled approved_by + conflicts auto_merge_enabled approved_by source_branch_protected + default_merge_commit_message_with_description squash_on_merge available_auto_merge_strategies + has_ci mergeable commits_without_merge_commits security_auto_fix ] if Gitlab.ee? expected_fields << 'approved' expected_fields << 'approvals_left' expected_fields << 'approvals_required' + expected_fields << 'merge_trains_count' end expect(described_class).to have_graphql_fields(*expected_fields) end + describe '#pipelines' do + subject { described_class.fields['pipelines'] } + + it { is_expected.to have_attributes(max_page_size: 500) } + end + describe '#diff_stats_summary' do subject { GitlabSchema.execute(query, context: { current_user: current_user }).as_json } diff --git a/spec/graphql/types/permission_types/base_permission_type_spec.rb b/spec/graphql/types/permission_types/base_permission_type_spec.rb index 2ce02f1520c..68632a509ee 100644 --- a/spec/graphql/types/permission_types/base_permission_type_spec.rb +++ b/spec/graphql/types/permission_types/base_permission_type_spec.rb @@ -11,9 +11,13 @@ RSpec.describe Types::PermissionTypes::BasePermissionType do Class.new(described_class) do graphql_name 'TestClass' - permission_field :do_stuff, resolve: -> (_, _, _) { true } + permission_field :do_stuff ability_field(:read_issue) abilities :admin_issue + + define_method :do_stuff do + true + end end end diff --git a/spec/graphql/types/project_member_relation_enum_spec.rb b/spec/graphql/types/project_member_relation_enum_spec.rb new file mode 100644 index 00000000000..3c947bf8406 --- /dev/null +++ b/spec/graphql/types/project_member_relation_enum_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::ProjectMemberRelationEnum do + specify { expect(described_class.graphql_name).to eq('ProjectMemberRelation') } + + it 'exposes all the existing project member relation type values' do + expect(described_class.values.keys).to contain_exactly('DIRECT', 'INHERITED', 'DESCENDANTS', 'INVITED_GROUPS') + end +end diff --git a/spec/graphql/types/project_type_spec.rb b/spec/graphql/types/project_type_spec.rb index be579e92fb3..b3028e034cc 100644 --- a/spec/graphql/types/project_type_spec.rb +++ b/spec/graphql/types/project_type_spec.rb @@ -3,6 +3,8 @@ require 'spec_helper' RSpec.describe GitlabSchema.types['Project'] do + include GraphqlHelpers + specify { expect(described_class).to expose_permissions_using(Types::PermissionTypes::Project) } specify { expect(described_class.graphql_name).to eq('Project') } @@ -28,7 +30,8 @@ RSpec.describe GitlabSchema.types['Project'] do alert_management_alerts alert_management_alert alert_management_alert_status_counts container_expiration_policy service_desk_enabled service_desk_address issue_status_counts terraform_states alert_management_integrations - + container_repositories container_repositories_count + pipeline_analytics total_pipeline_duration squash_read_only ] expect(described_class).to include_graphql_fields(*expected_fields) @@ -76,6 +79,7 @@ RSpec.describe GitlabSchema.types['Project'] do :merged_before, :author_username, :assignee_username, + :reviewer_username, :milestone_title, :sort ) @@ -163,4 +167,32 @@ RSpec.describe GitlabSchema.types['Project'] do end it_behaves_like 'a GraphQL type with labels' + + describe 'jira_imports' do + subject { resolve_field(:jira_imports, project) } + + let_it_be(:project) { create(:project, :public) } + + context 'when project has Jira imports' do + let_it_be(:jira_import1) { create(:jira_import_state, :finished, project: project, jira_project_key: 'AA', created_at: 2.days.ago) } + let_it_be(:jira_import2) { create(:jira_import_state, :finished, project: project, jira_project_key: 'BB', created_at: 5.days.ago) } + + it 'retrieves the imports' do + expect(subject).to contain_exactly(jira_import1, jira_import2) + end + end + + context 'when project does not have Jira imports' do + it 'returns an empty result' do + expect(subject).to be_empty + end + end + end + + describe 'pipeline_analytics field' do + subject { described_class.fields['pipelineAnalytics'] } + + it { is_expected.to have_graphql_type(Types::Ci::AnalyticsType) } + it { is_expected.to have_graphql_resolver(Resolvers::ProjectPipelineStatisticsResolver) } + end end diff --git a/spec/graphql/types/terraform/state_version_type_spec.rb b/spec/graphql/types/terraform/state_version_type_spec.rb index 1c1e95039dc..18f869e4f1f 100644 --- a/spec/graphql/types/terraform/state_version_type_spec.rb +++ b/spec/graphql/types/terraform/state_version_type_spec.rb @@ -7,13 +7,15 @@ RSpec.describe GitlabSchema.types['TerraformStateVersion'] do it { expect(described_class).to require_graphql_authorizations(:read_terraform_state) } describe 'fields' do - let(:fields) { %i[id created_by_user job created_at updated_at] } + let(:fields) { %i[id created_by_user job download_path serial created_at updated_at] } it { expect(described_class).to have_graphql_fields(fields) } it { expect(described_class.fields['id'].type).to be_non_null } it { expect(described_class.fields['createdByUser'].type).not_to be_non_null } it { expect(described_class.fields['job'].type).not_to be_non_null } + it { expect(described_class.fields['downloadPath'].type).not_to be_non_null } + it { expect(described_class.fields['serial'].type).not_to be_non_null } it { expect(described_class.fields['createdAt'].type).to be_non_null } it { expect(described_class.fields['updatedAt'].type).to be_non_null } end diff --git a/spec/graphql/types/user_type_spec.rb b/spec/graphql/types/user_type_spec.rb index c8953d9ccb7..0eff33bb25b 100644 --- a/spec/graphql/types/user_type_spec.rb +++ b/spec/graphql/types/user_type_spec.rb @@ -15,14 +15,17 @@ RSpec.describe GitlabSchema.types['User'] do name username email + publicEmail avatarUrl webUrl webPath todos state status + location authoredMergeRequests assignedMergeRequests + reviewRequestedMergeRequests groupMemberships groupCount projectMemberships |