diff options
Diffstat (limited to 'spec/graphql')
36 files changed, 1177 insertions, 47 deletions
diff --git a/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb b/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb new file mode 100644 index 00000000000..fc025c8e3d3 --- /dev/null +++ b/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb @@ -0,0 +1,61 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Clusters::AgentTokens::Create do + subject(:mutation) { described_class.new(object: nil, context: context, field: nil) } + + let_it_be(:cluster_agent) { create(:cluster_agent) } + let_it_be(:user) { create(:user) } + + let(:context) do + GraphQL::Query::Context.new( + query: OpenStruct.new(schema: nil), + values: { current_user: user }, + object: nil + ) + end + + specify { expect(described_class).to require_graphql_authorizations(:create_cluster) } + + describe '#resolve' do + let(:description) { 'new token!' } + let(:name) { 'new name' } + + subject { mutation.resolve(cluster_agent_id: cluster_agent.to_global_id, description: description, name: name) } + + context 'without token permissions' do + it 'raises an error if the resource is not accessible to the user' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + + context 'with user permissions' do + before do + cluster_agent.project.add_maintainer(user) + end + + it 'creates a new token', :aggregate_failures do + expect { subject }.to change { ::Clusters::AgentToken.count }.by(1) + expect(subject[:errors]).to eq([]) + end + + it 'returns token information', :aggregate_failures do + token = subject[:token] + + expect(subject[:secret]).not_to be_nil + expect(token.created_by_user).to eq(user) + expect(token.description).to eq(description) + expect(token.name).to eq(name) + end + + context 'invalid params' do + subject { mutation.resolve(cluster_agent_id: cluster_agent.id) } + + it 'generates an error message when id invalid', :aggregate_failures do + expect { subject }.to raise_error(::GraphQL::CoercionError) + end + end + end + end +end diff --git a/spec/graphql/mutations/clusters/agent_tokens/delete_spec.rb b/spec/graphql/mutations/clusters/agent_tokens/delete_spec.rb new file mode 100644 index 00000000000..5cdbc0f6d72 --- /dev/null +++ b/spec/graphql/mutations/clusters/agent_tokens/delete_spec.rb @@ -0,0 +1,52 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Clusters::AgentTokens::Delete do + let(:token) { create(:cluster_agent_token) } + let(:user) { create(:user) } + + let(:mutation) do + described_class.new( + object: double, + context: { current_user: user }, + field: double + ) + end + + it { expect(described_class.graphql_name).to eq('ClusterAgentTokenDelete') } + it { expect(described_class).to require_graphql_authorizations(:admin_cluster) } + + describe '#resolve' do + let(:global_id) { token.to_global_id } + + subject { mutation.resolve(id: global_id) } + + context 'without user permissions' do + it 'fails to delete the cluster agent', :aggregate_failures do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + expect { token.reload }.not_to raise_error + end + end + + context 'with user permissions' do + before do + token.agent.project.add_maintainer(user) + end + + it 'deletes a cluster agent', :aggregate_failures do + expect { subject }.to change { ::Clusters::AgentToken.count }.by(-1) + expect { token.reload }.to raise_error(ActiveRecord::RecordNotFound) + end + end + + context 'with invalid params' do + let(:global_id) { token.id } + + it 'raises an error if the cluster agent id is invalid', :aggregate_failures do + expect { subject }.to raise_error(::GraphQL::CoercionError) + expect { token.reload }.not_to raise_error + end + end + end +end diff --git a/spec/graphql/mutations/clusters/agents/create_spec.rb b/spec/graphql/mutations/clusters/agents/create_spec.rb new file mode 100644 index 00000000000..c80b6f6cdad --- /dev/null +++ b/spec/graphql/mutations/clusters/agents/create_spec.rb @@ -0,0 +1,50 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Clusters::Agents::Create do + subject(:mutation) { described_class.new(object: nil, context: context, field: nil) } + + let(:project) { create(:project, :public, :repository) } + let(:user) { create(:user) } + let(:context) do + GraphQL::Query::Context.new( + query: OpenStruct.new(schema: nil), + values: { current_user: user }, + object: nil + ) + end + + specify { expect(described_class).to require_graphql_authorizations(:create_cluster) } + + describe '#resolve' do + subject { mutation.resolve(project_path: project.full_path, name: 'test-agent') } + + context 'without project permissions' do + it 'raises an error if the resource is not accessible to the user' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + + context 'with user permissions' do + before do + project.add_maintainer(user) + end + + it 'creates a new clusters_agent', :aggregate_failures do + expect { subject }.to change { ::Clusters::Agent.count }.by(1) + expect(subject[:cluster_agent].name).to eq('test-agent') + expect(subject[:errors]).to eq([]) + end + + context 'invalid params' do + subject { mutation.resolve(project_path: project.full_path, name: '@bad_name!') } + + it 'generates an error message when name is invalid', :aggregate_failures do + expect(subject[:clusters_agent]).to be_nil + expect(subject[:errors]).to eq(["Name can contain only lowercase letters, digits, and '-', but cannot start or end with '-'"]) + end + end + end + end +end diff --git a/spec/graphql/mutations/clusters/agents/delete_spec.rb b/spec/graphql/mutations/clusters/agents/delete_spec.rb new file mode 100644 index 00000000000..0aabf53391a --- /dev/null +++ b/spec/graphql/mutations/clusters/agents/delete_spec.rb @@ -0,0 +1,51 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::Clusters::Agents::Delete do + subject(:mutation) { described_class.new(object: nil, context: context, field: nil) } + + let(:cluster_agent) { create(:cluster_agent) } + let(:project) { cluster_agent.project } + let(:user) { create(:user) } + let(:context) do + GraphQL::Query::Context.new( + query: OpenStruct.new(schema: nil), + values: { current_user: user }, + object: nil + ) + end + + specify { expect(described_class).to require_graphql_authorizations(:admin_cluster) } + + describe '#resolve' do + subject { mutation.resolve(id: cluster_agent.to_global_id) } + + context 'without user permissions' do + it 'fails to delete the cluster agent', :aggregate_failures do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + expect { cluster_agent.reload }.not_to raise_error + end + end + + context 'with user permissions' do + before do + project.add_maintainer(user) + end + + it 'deletes a cluster agent', :aggregate_failures do + expect { subject }.to change { ::Clusters::Agent.count }.by(-1) + expect { cluster_agent.reload }.to raise_error(ActiveRecord::RecordNotFound) + end + end + + context 'with invalid params' do + subject { mutation.resolve(id: cluster_agent.id) } + + it 'raises an error if the cluster agent id is invalid', :aggregate_failures do + expect { subject }.to raise_error(::GraphQL::CoercionError) + expect { cluster_agent.reload }.not_to raise_error + end + end + end +end diff --git a/spec/graphql/mutations/customer_relations/contacts/create_spec.rb b/spec/graphql/mutations/customer_relations/contacts/create_spec.rb new file mode 100644 index 00000000000..21a1aa2741a --- /dev/null +++ b/spec/graphql/mutations/customer_relations/contacts/create_spec.rb @@ -0,0 +1,101 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::CustomerRelations::Contacts::Create do + let_it_be(:user) { create(:user) } + let_it_be(:group) { create(:group) } + + let(:not_found_or_does_not_belong) { 'The specified organization was not found or does not belong to this group' } + let(:valid_params) do + attributes_for(:contact, + group: group, + description: 'Managing Director' + ) + end + + describe '#resolve' do + subject(:resolve_mutation) do + described_class.new(object: nil, context: { current_user: user }, field: nil).resolve( + **valid_params, + group_id: group.to_global_id + ) + end + + context 'when the user does not have permission' do + before do + group.add_reporter(user) + end + + it 'raises an error' do + expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message("The resource that you are attempting to access does not exist or you don't have permission to perform this action") + end + end + + context 'when the user has permission' do + before_all do + group.add_developer(user) + end + + context 'when the feature is disabled' do + before do + stub_feature_flags(customer_relations: false) + end + + it 'raises an error' do + expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message('Feature disabled') + end + end + + context 'when the params are invalid' do + it 'returns the validation error' do + valid_params[:first_name] = nil + + expect(resolve_mutation[:errors]).to match_array(["First name can't be blank"]) + end + end + + context 'when attaching to an organization' do + context 'when all ok' do + before do + organization = create(:organization, group: group) + valid_params[:organization_id] = organization.to_global_id + end + + it 'creates contact with correct values' do + expect(resolve_mutation[:contact].organization).to be_present + end + end + + context 'when organization_id is invalid' do + before do + valid_params[:organization_id] = "gid://gitlab/CustomerRelations::Organization/#{non_existing_record_id}" + end + + it 'returns the relevant error' do + expect(resolve_mutation[:errors]).to match_array([not_found_or_does_not_belong]) + end + end + + context 'when organzation belongs to a different group' do + before do + organization = create(:organization) + valid_params[:organization_id] = organization.to_global_id + end + + it 'returns the relevant error' do + expect(resolve_mutation[:errors]).to match_array([not_found_or_does_not_belong]) + end + end + end + + it 'creates contact with correct values' do + expect(resolve_mutation[:contact]).to have_attributes(valid_params) + end + end + end + + specify { expect(described_class).to require_graphql_authorizations(:admin_contact) } +end diff --git a/spec/graphql/mutations/customer_relations/contacts/update_spec.rb b/spec/graphql/mutations/customer_relations/contacts/update_spec.rb new file mode 100644 index 00000000000..93bc6f53cf9 --- /dev/null +++ b/spec/graphql/mutations/customer_relations/contacts/update_spec.rb @@ -0,0 +1,75 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::CustomerRelations::Contacts::Update do + let_it_be(:user) { create(:user) } + let_it_be(:group) { create(:group) } + + let(:first_name) { 'Lionel' } + let(:last_name) { 'Smith' } + let(:email) { 'ls@gitlab.com' } + let(:description) { 'VIP' } + let(:does_not_exist_or_no_permission) { "The resource that you are attempting to access does not exist or you don't have permission to perform this action" } + let(:contact) { create(:contact, group: group) } + let(:attributes) do + { + id: contact.to_global_id, + first_name: first_name, + last_name: last_name, + email: email, + description: description + } + end + + describe '#resolve' do + subject(:resolve_mutation) do + described_class.new(object: nil, context: { current_user: user }, field: nil).resolve( + attributes + ) + end + + context 'when the user does not have permission to update a contact' do + before do + group.add_reporter(user) + end + + it 'raises an error' do + expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message(does_not_exist_or_no_permission) + end + end + + context 'when the contact does not exist' do + it 'raises an error' do + attributes[:id] = "gid://gitlab/CustomerRelations::Contact/#{non_existing_record_id}" + + expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message(does_not_exist_or_no_permission) + end + end + + context 'when the user has permission to update a contact' do + before_all do + group.add_developer(user) + end + + it 'updates the organization with correct values' do + expect(resolve_mutation[:contact]).to have_attributes(attributes) + end + + context 'when the feature is disabled' do + before do + stub_feature_flags(customer_relations: false) + end + + it 'raises an error' do + expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message('Feature disabled') + end + end + end + end + + specify { expect(described_class).to require_graphql_authorizations(:admin_contact) } +end diff --git a/spec/graphql/mutations/customer_relations/organizations/create_spec.rb b/spec/graphql/mutations/customer_relations/organizations/create_spec.rb index ab430b9240b..738a8d724ab 100644 --- a/spec/graphql/mutations/customer_relations/organizations/create_spec.rb +++ b/spec/graphql/mutations/customer_relations/organizations/create_spec.rb @@ -4,6 +4,7 @@ require 'spec_helper' RSpec.describe Mutations::CustomerRelations::Organizations::Create do let_it_be(:user) { create(:user) } + let_it_be(:group) { create(:group) } let(:valid_params) do attributes_for(:organization, @@ -23,22 +24,19 @@ RSpec.describe Mutations::CustomerRelations::Organizations::Create do end context 'when the user does not have permission' do - let_it_be(:group) { create(:group) } - before do - group.add_guest(user) + group.add_reporter(user) end it 'raises an error' do expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message("The resource that you are attempting to access does not exist or you don't have permission to perform this action") end end context 'when the user has permission' do - let_it_be(:group) { create(:group) } - before_all do - group.add_reporter(user) + group.add_developer(user) end context 'when the feature is disabled' do @@ -48,6 +46,7 @@ RSpec.describe Mutations::CustomerRelations::Organizations::Create do it 'raises an error' do expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message('Feature disabled') end end diff --git a/spec/graphql/mutations/customer_relations/organizations/update_spec.rb b/spec/graphql/mutations/customer_relations/organizations/update_spec.rb index f5aa6c00301..0bc6f184fe3 100644 --- a/spec/graphql/mutations/customer_relations/organizations/update_spec.rb +++ b/spec/graphql/mutations/customer_relations/organizations/update_spec.rb @@ -4,10 +4,12 @@ require 'spec_helper' RSpec.describe Mutations::CustomerRelations::Organizations::Update do let_it_be(:user) { create(:user) } - let_it_be(:name) { 'GitLab' } - let_it_be(:default_rate) { 1000.to_f } - let_it_be(:description) { 'VIP' } + let_it_be(:group) { create(:group) } + let(:name) { 'GitLab' } + let(:default_rate) { 1000.to_f } + let(:description) { 'VIP' } + let(:does_not_exist_or_no_permission) { "The resource that you are attempting to access does not exist or you don't have permission to perform this action" } let(:organization) { create(:organization, group: group) } let(:attributes) do { @@ -26,32 +28,28 @@ RSpec.describe Mutations::CustomerRelations::Organizations::Update do end context 'when the user does not have permission to update an organization' do - let_it_be(:group) { create(:group) } - before do - group.add_guest(user) + group.add_reporter(user) end it 'raises an error' do expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message(does_not_exist_or_no_permission) end end context 'when the organization does not exist' do - let_it_be(:group) { create(:group) } - it 'raises an error' do - attributes[:id] = 'gid://gitlab/CustomerRelations::Organization/999' + attributes[:id] = "gid://gitlab/CustomerRelations::Organization/#{non_existing_record_id}" expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message(does_not_exist_or_no_permission) end end context 'when the user has permission to update an organization' do - let_it_be(:group) { create(:group) } - before_all do - group.add_reporter(user) + group.add_developer(user) end it 'updates the organization with correct values' do @@ -65,6 +63,7 @@ RSpec.describe Mutations::CustomerRelations::Organizations::Update do it 'raises an error' do expect { resolve_mutation }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + .with_message('Feature disabled') end end end diff --git a/spec/graphql/mutations/dependency_proxy/group_settings/update_spec.rb b/spec/graphql/mutations/dependency_proxy/group_settings/update_spec.rb new file mode 100644 index 00000000000..35d3224d5ba --- /dev/null +++ b/spec/graphql/mutations/dependency_proxy/group_settings/update_spec.rb @@ -0,0 +1,55 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Mutations::DependencyProxy::GroupSettings::Update do + using RSpec::Parameterized::TableSyntax + + let_it_be_with_reload(:group) { create(:group) } + let_it_be_with_reload(:group_settings) { create(:dependency_proxy_group_setting, group: group) } + let_it_be(:user) { create(:user) } + + let(:params) { { group_path: group.full_path, enabled: false } } + + specify { expect(described_class).to require_graphql_authorizations(:admin_dependency_proxy) } + + describe '#resolve' do + subject { described_class.new(object: group, context: { current_user: user }, field: nil).resolve(**params) } + + shared_examples 'updating the dependency proxy group settings' do + it_behaves_like 'updating the dependency proxy group settings attributes', + from: { enabled: true }, + to: { enabled: false } + + it 'returns the dependency proxy settings no errors' do + expect(subject).to eq( + dependency_proxy_setting: group_settings, + errors: [] + ) + end + end + + shared_examples 'denying access to dependency proxy group settings' do + it 'raises Gitlab::Graphql::Errors::ResourceNotAvailable' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable) + end + end + + where(:user_role, :shared_examples_name) do + :maintainer | 'updating the dependency proxy group settings' + :developer | 'updating the dependency proxy group settings' + :reporter | 'denying access to dependency proxy group settings' + :guest | 'denying access to dependency proxy group settings' + :anonymous | 'denying access to dependency proxy group settings' + end + + with_them do + before do + stub_config(dependency_proxy: { enabled: true }) + group.send("add_#{user_role}", user) unless user_role == :anonymous + end + + it_behaves_like params[:shared_examples_name] + end + end +end diff --git a/spec/graphql/mutations/groups/update_spec.rb b/spec/graphql/mutations/groups/update_spec.rb index 2118134e8e6..620c9d6ee91 100644 --- a/spec/graphql/mutations/groups/update_spec.rb +++ b/spec/graphql/mutations/groups/update_spec.rb @@ -18,7 +18,7 @@ RSpec.describe Mutations::Groups::Update do RSpec.shared_examples 'updating the group shared runners setting' do it 'updates the group shared runners setting' do expect { subject } - .to change { group.reload.shared_runners_setting }.from('enabled').to('disabled_and_unoverridable') + .to change { group.reload.shared_runners_setting }.from('enabled').to(Namespace::SR_DISABLED_AND_UNOVERRIDABLE) end it 'returns no errors' do @@ -51,7 +51,7 @@ RSpec.describe Mutations::Groups::Update do context 'changing shared runners setting' do let_it_be(:params) do { full_path: group.full_path, - shared_runners_setting: 'disabled_and_unoverridable' } + shared_runners_setting: Namespace::SR_DISABLED_AND_UNOVERRIDABLE } end where(:user_role, :shared_examples_name) do diff --git a/spec/graphql/mutations/issues/create_spec.rb b/spec/graphql/mutations/issues/create_spec.rb index 0e7ef0e55b9..825d04ff827 100644 --- a/spec/graphql/mutations/issues/create_spec.rb +++ b/spec/graphql/mutations/issues/create_spec.rb @@ -53,7 +53,11 @@ RSpec.describe Mutations::Issues::Create do stub_spam_services end - subject { mutation.resolve(**mutation_params) } + def resolve + mutation.resolve(**mutation_params) + end + + subject { resolve } context 'when the user does not have permission to create an issue' do it 'raises an error' do @@ -61,6 +65,15 @@ RSpec.describe Mutations::Issues::Create do end end + context 'when the user has exceeded the rate limit' do + it 'raises an error' do + allow(::Gitlab::ApplicationRateLimiter).to receive(:throttled?).and_return(true) + project.add_developer(user) + + expect { resolve }.to raise_error(RateLimitedService::RateLimitedError, _('This endpoint has been requested too many times. Try again later.')) + end + end + context 'when the user can create an issue' do context 'when creating an issue a developer' do before do diff --git a/spec/graphql/resolvers/board_list_issues_resolver_spec.rb b/spec/graphql/resolvers/board_list_issues_resolver_spec.rb index 26040f4ec1a..53d2c8a853c 100644 --- a/spec/graphql/resolvers/board_list_issues_resolver_spec.rb +++ b/spec/graphql/resolvers/board_list_issues_resolver_spec.rb @@ -31,12 +31,11 @@ RSpec.describe Resolvers::BoardListIssuesResolver do end.to raise_error(Gitlab::Graphql::Errors::ArgumentError) end - it 'returns issues in the correct order with non-nil relative positions', :aggregate_failures do + it 'returns the issues in the correct order' do # by relative_position and then ID result = resolve_board_list_issues - expect(result.map(&:id)).to eq [issue3.id, issue1.id, issue2.id, issue4.id] - expect(result.map(&:relative_position)).not_to include(nil) + expect(result.map(&:id)).to eq [issue1.id, issue3.id, issue2.id, issue4.id] end it 'finds only issues matching filters' do @@ -57,6 +56,13 @@ RSpec.describe Resolvers::BoardListIssuesResolver do expect(result).to match_array([issue1]) end + it 'filters issues by negated issue type' do + incident = create(:incident, project: project, labels: [label], relative_position: 15) + result = resolve_board_list_issues(args: { filters: { not: { types: ['issue'] } } }) + + expect(result).to contain_exactly(incident) + end + it 'raises an exception if both assignee_username and assignee_wildcard_id are present' do expect do resolve_board_list_issues(args: { filters: { assignee_username: ['username'], assignee_wildcard_id: 'NONE' } }) @@ -112,6 +118,6 @@ RSpec.describe Resolvers::BoardListIssuesResolver do end def resolve_board_list_issues(args: {}, current_user: user) - resolve(described_class, obj: list, args: args, ctx: { current_user: current_user }).items + resolve(described_class, obj: list, args: args, ctx: { current_user: current_user }) end end diff --git a/spec/graphql/resolvers/board_list_resolver_spec.rb b/spec/graphql/resolvers/board_list_resolver_spec.rb new file mode 100644 index 00000000000..5cf9e4b14ea --- /dev/null +++ b/spec/graphql/resolvers/board_list_resolver_spec.rb @@ -0,0 +1,39 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::BoardListResolver do + include GraphqlHelpers + include Gitlab::Graphql::Laziness + + let_it_be(:guest) { create(:user) } + let_it_be(:unauth_user) { create(:user) } + let_it_be(:group) { create(:group, :private) } + let_it_be(:group_label) { create(:group_label, group: group, name: 'Development') } + let_it_be(:board) { create(:board, resource_parent: group) } + let_it_be(:label_list) { create(:list, board: board, label: group_label) } + + describe '#resolve' do + subject { resolve_board_list(args: { id: global_id_of(label_list) }, current_user: current_user) } + + context 'with unauthorized user' do + let(:current_user) { unauth_user } + + it { is_expected.to be_nil } + end + + context 'when authorized' do + let(:current_user) { guest } + + before do + group.add_guest(guest) + end + + it { is_expected.to eq label_list } + end + end + + def resolve_board_list(args: {}, current_user: user) + force(resolve(described_class, obj: nil, args: args, ctx: { current_user: current_user })) + end +end diff --git a/spec/graphql/resolvers/clusters/agent_tokens_resolver_spec.rb b/spec/graphql/resolvers/clusters/agent_tokens_resolver_spec.rb new file mode 100644 index 00000000000..6b8b88928d8 --- /dev/null +++ b/spec/graphql/resolvers/clusters/agent_tokens_resolver_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::Clusters::AgentTokensResolver do + include GraphqlHelpers + + it { expect(described_class.type).to eq(Types::Clusters::AgentTokenType) } + it { expect(described_class.null).to be_truthy } + + describe '#resolve' do + let(:agent) { create(:cluster_agent) } + let(:user) { create(:user, maintainer_projects: [agent.project]) } + let(:ctx) { Hash(current_user: user) } + + let!(:matching_token1) { create(:cluster_agent_token, agent: agent, last_used_at: 5.days.ago) } + let!(:matching_token2) { create(:cluster_agent_token, agent: agent, last_used_at: 2.days.ago) } + let!(:other_token) { create(:cluster_agent_token) } + + subject { resolve(described_class, obj: agent, ctx: ctx) } + + it 'returns tokens associated with the agent, ordered by last_used_at' do + expect(subject).to eq([matching_token2, matching_token1]) + end + + context 'user does not have permission' do + let(:user) { create(:user, developer_projects: [agent.project]) } + + it { is_expected.to be_empty } + end + end +end diff --git a/spec/graphql/resolvers/clusters/agents_resolver_spec.rb b/spec/graphql/resolvers/clusters/agents_resolver_spec.rb new file mode 100644 index 00000000000..70f40748e1d --- /dev/null +++ b/spec/graphql/resolvers/clusters/agents_resolver_spec.rb @@ -0,0 +1,77 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::Clusters::AgentsResolver do + include GraphqlHelpers + + specify do + expect(described_class).to have_nullable_graphql_type(Types::Clusters::AgentType.connection_type) + end + + specify do + expect(described_class.field_options).to include(extras: include(:lookahead)) + end + + describe '#resolve' do + let_it_be(:project) { create(:project) } + let_it_be(:maintainer) { create(:user, maintainer_projects: [project]) } + let_it_be(:developer) { create(:user, developer_projects: [project]) } + let_it_be(:agents) { create_list(:cluster_agent, 2, project: project) } + + let(:ctx) { { current_user: current_user } } + + subject { resolve_agents } + + context 'the current user has access to clusters' do + let(:current_user) { maintainer } + + it 'finds all agents' do + expect(subject).to match_array(agents) + end + end + + context 'the current user does not have access to clusters' do + let(:current_user) { developer } + + it 'returns an empty result' do + expect(subject).to be_empty + end + end + end + + def resolve_agents(args = {}) + resolve(described_class, obj: project, ctx: ctx, lookahead: positive_lookahead, args: args) + end +end + +RSpec.describe Resolvers::Clusters::AgentsResolver.single do + it { expect(described_class).to be < Resolvers::Clusters::AgentsResolver } + + describe '.field_options' do + subject { described_class.field_options } + + specify do + expect(subject).to include( + type: ::Types::Clusters::AgentType, + null: true, + extras: [:lookahead] + ) + end + end + + describe 'arguments' do + subject { described_class.arguments[argument] } + + describe 'name' do + let(:argument) { 'name' } + + it do + expect(subject).to be_present + expect(subject.type).to be_kind_of GraphQL::Schema::NonNull + expect(subject.type.unwrap).to eq GraphQL::Types::String + expect(subject.description).to be_present + end + end + end +end diff --git a/spec/graphql/resolvers/issues_resolver_spec.rb b/spec/graphql/resolvers/issues_resolver_spec.rb index e992b2b04ae..9897e697009 100644 --- a/spec/graphql/resolvers/issues_resolver_spec.rb +++ b/spec/graphql/resolvers/issues_resolver_spec.rb @@ -26,7 +26,14 @@ RSpec.describe Resolvers::IssuesResolver do expect(described_class).to have_nullable_graphql_type(Types::IssueType.connection_type) end + shared_context 'filtering for confidential issues' do + let_it_be(:confidential_issue1) { create(:issue, project: project, confidential: true) } + let_it_be(:confidential_issue2) { create(:issue, project: other_project, confidential: true) } + end + context "with a project" do + let(:obj) { project } + before_all do project.add_developer(current_user) project.add_reporter(reporter) @@ -222,6 +229,42 @@ RSpec.describe Resolvers::IssuesResolver do end end + context 'confidential issues' do + include_context 'filtering for confidential issues' + + context "when user is allowed to view confidential issues" do + it 'returns all viewable issues by default' do + expect(resolve_issues).to contain_exactly(issue1, issue2, confidential_issue1) + end + + it 'returns only the non-confidential issues for the project when filter is set to false' do + expect(resolve_issues({ confidential: false })).to contain_exactly(issue1, issue2) + end + + it "returns only the confidential issues for the project when filter is set to true" do + expect(resolve_issues({ confidential: true })).to contain_exactly(confidential_issue1) + end + end + + context "when user is not allowed to see confidential issues" do + before do + project.add_guest(current_user) + end + + it 'returns all viewable issues by default' do + expect(resolve_issues).to contain_exactly(issue1, issue2) + end + + it 'does not return the confidential issues when filter is set to false' do + expect(resolve_issues({ confidential: false })).to contain_exactly(issue1, issue2) + end + + it 'does not return the confidential issues when filter is set to true' do + expect(resolve_issues({ confidential: true })).to be_empty + end + end + end + context 'when searching issues' do it 'returns correct issues' do expect(resolve_issues(search: 'foo')).to contain_exactly(issue2) @@ -236,6 +279,36 @@ RSpec.describe Resolvers::IssuesResolver do resolve_issues(search: 'foo') end + + context 'with anonymous user' do + let_it_be(:public_project) { create(:project, :public) } + let_it_be(:public_issue) { create(:issue, project: public_project, title: 'Test issue') } + + context 'with disable_anonymous_search enabled' do + before do + stub_feature_flags(disable_anonymous_search: true) + end + + it 'returns an error' do + error_message = "User must be authenticated to include the `search` argument." + + expect { resolve(described_class, obj: public_project, args: { search: 'test' }, ctx: { current_user: nil }) } + .to raise_error(Gitlab::Graphql::Errors::ArgumentError, error_message) + end + end + + context 'with disable_anonymous_search disabled' do + before do + stub_feature_flags(disable_anonymous_search: false) + end + + it 'returns correct issues' do + expect( + resolve(described_class, obj: public_project, args: { search: 'test' }, ctx: { current_user: nil }) + ).to contain_exactly(public_issue) + end + end + end end describe 'filters by negated params' do @@ -260,6 +333,10 @@ RSpec.describe Resolvers::IssuesResolver do expect(resolve_issues(not: { assignee_id: [assignee.id] })).to contain_exactly(issue1) end + it 'returns issues without the specified issue_type' do + expect(resolve_issues(not: { types: ['issue'] })).to contain_exactly(issue1) + end + context 'when filtering by negated author' do let_it_be(:issue_by_reporter) { create(:issue, author: reporter, project: project, state: :opened) } @@ -304,7 +381,7 @@ RSpec.describe Resolvers::IssuesResolver do 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_a).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_issue2, relative_issue4] end end @@ -485,26 +562,72 @@ RSpec.describe Resolvers::IssuesResolver do end context "with a group" do + let(:obj) { group } + before do group.add_developer(current_user) end describe '#resolve' do it 'finds all group issues' do - result = resolve(described_class, obj: group, ctx: { current_user: current_user }) + expect(resolve_issues).to contain_exactly(issue1, issue2, issue3) + end + + it 'returns issues without the specified issue_type' do + expect(resolve_issues({ not: { types: ['issue'] } })).to contain_exactly(issue1) + end + + context "confidential issues" do + include_context 'filtering for confidential issues' + + context "when user is allowed to view confidential issues" do + it 'returns all viewable issues by default' do + expect(resolve_issues).to contain_exactly(issue1, issue2, issue3, confidential_issue1, confidential_issue2) + end + + context 'filtering for confidential issues' do + it 'returns only the non-confidential issues for the group when filter is set to false' do + expect(resolve_issues({ confidential: false })).to contain_exactly(issue1, issue2, issue3) + end - expect(result).to contain_exactly(issue1, issue2, issue3) + it "returns only the confidential issues for the group when filter is set to true" do + expect(resolve_issues({ confidential: true })).to contain_exactly(confidential_issue1, confidential_issue2) + end + end + end + + context "when user is not allowed to see confidential issues" do + before do + group.add_guest(current_user) + end + + it 'returns all viewable issues by default' do + expect(resolve_issues).to contain_exactly(issue1, issue2, issue3) + end + + context 'filtering for confidential issues' do + it 'does not return the confidential issues when filter is set to false' do + expect(resolve_issues({ confidential: false })).to contain_exactly(issue1, issue2, issue3) + end + + it 'does not return the confidential issues when filter is set to true' do + expect(resolve_issues({ confidential: true })).to be_empty + end + end + end end end end context "when passing a non existent, batch loaded project" do - let(:project) do + let!(:project) do BatchLoader::GraphQL.for("non-existent-path").batch do |_fake_paths, loader, _| loader.call("non-existent-path", nil) end end + let(:obj) { project } + it "returns nil without breaking" do expect(resolve_issues(iids: ["don't", "break"])).to be_empty end @@ -525,6 +648,6 @@ RSpec.describe Resolvers::IssuesResolver do end def resolve_issues(args = {}, context = { current_user: current_user }) - resolve(described_class, obj: project, args: args, ctx: context) + resolve(described_class, obj: obj, args: args, ctx: context) end end diff --git a/spec/graphql/resolvers/kas/agent_configurations_resolver_spec.rb b/spec/graphql/resolvers/kas/agent_configurations_resolver_spec.rb new file mode 100644 index 00000000000..bdb1ced46ae --- /dev/null +++ b/spec/graphql/resolvers/kas/agent_configurations_resolver_spec.rb @@ -0,0 +1,48 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::Kas::AgentConfigurationsResolver do + include GraphqlHelpers + + it { expect(described_class.type).to eq(Types::Kas::AgentConfigurationType) } + it { expect(described_class.null).to be_truthy } + it { expect(described_class.field_options).to include(calls_gitaly: true) } + + describe '#resolve' do + let_it_be(:project) { create(:project) } + + let(:user) { create(:user, maintainer_projects: [project]) } + let(:ctx) { Hash(current_user: user) } + + let(:agent1) { double } + let(:agent2) { double } + let(:kas_client) { instance_double(Gitlab::Kas::Client, list_agent_config_files: [agent1, agent2]) } + + subject { resolve(described_class, obj: project, ctx: ctx) } + + before do + allow(Gitlab::Kas::Client).to receive(:new).and_return(kas_client) + end + + it 'returns agents configured for the project' do + expect(subject).to contain_exactly(agent1, agent2) + end + + context 'an error is returned from the KAS client' do + before do + allow(kas_client).to receive(:list_agent_config_files).and_raise(GRPC::DeadlineExceeded) + end + + it 'raises a graphql error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable, 'GRPC::DeadlineExceeded') + end + end + + context 'user does not have permission' do + let(:user) { create(:user) } + + it { is_expected.to be_empty } + end + end +end diff --git a/spec/graphql/resolvers/kas/agent_connections_resolver_spec.rb b/spec/graphql/resolvers/kas/agent_connections_resolver_spec.rb new file mode 100644 index 00000000000..fe6509bcb3c --- /dev/null +++ b/spec/graphql/resolvers/kas/agent_connections_resolver_spec.rb @@ -0,0 +1,66 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Resolvers::Kas::AgentConnectionsResolver do + include GraphqlHelpers + + it { expect(described_class.type).to eq(Types::Kas::AgentConnectionType) } + it { expect(described_class.null).to be_truthy } + + describe '#resolve' do + let_it_be(:project) { create(:project) } + let_it_be(:agent1) { create(:cluster_agent, project: project) } + let_it_be(:agent2) { create(:cluster_agent, project: project) } + + let(:user) { create(:user, maintainer_projects: [project]) } + let(:ctx) { Hash(current_user: user) } + + let(:connection1) { double(agent_id: agent1.id) } + let(:connection2) { double(agent_id: agent1.id) } + let(:connection3) { double(agent_id: agent2.id) } + let(:connected_agents) { [connection1, connection2, connection3] } + let(:kas_client) { instance_double(Gitlab::Kas::Client, get_connected_agents: connected_agents) } + + subject do + batch_sync do + resolve(described_class, obj: agent1, ctx: ctx) + end + end + + before do + allow(Gitlab::Kas::Client).to receive(:new).and_return(kas_client) + end + + it 'returns active connections for the agent' do + expect(subject).to contain_exactly(connection1, connection2) + end + + it 'queries KAS once when multiple agents are requested' do + expect(kas_client).to receive(:get_connected_agents).once + + response = batch_sync do + resolve(described_class, obj: agent1, ctx: ctx) + resolve(described_class, obj: agent2, ctx: ctx) + end + + expect(response).to contain_exactly(connection3) + end + + context 'an error is returned from the KAS client' do + before do + allow(kas_client).to receive(:get_connected_agents).and_raise(GRPC::DeadlineExceeded) + end + + it 'raises a graphql error' do + expect { subject }.to raise_error(Gitlab::Graphql::Errors::ResourceNotAvailable, 'GRPC::DeadlineExceeded') + end + end + + context 'user does not have permission' do + let(:user) { create(:user) } + + it { is_expected.to be_empty } + end + end +end diff --git a/spec/graphql/resolvers/project_pipelines_resolver_spec.rb b/spec/graphql/resolvers/project_pipelines_resolver_spec.rb index c7c00f54c0c..51a63e66b93 100644 --- a/spec/graphql/resolvers/project_pipelines_resolver_spec.rb +++ b/spec/graphql/resolvers/project_pipelines_resolver_spec.rb @@ -11,15 +11,23 @@ RSpec.describe Resolvers::ProjectPipelinesResolver do let(:current_user) { create(:user) } - before do - project.add_developer(current_user) + context 'when the user does have access' do + before do + project.add_developer(current_user) + end + + it 'resolves only MRs for the passed merge request' do + expect(resolve_pipelines).to contain_exactly(pipeline) + end end - def resolve_pipelines - resolve(described_class, obj: project, ctx: { current_user: current_user }) + context 'when the user does not have access' do + it 'does not return pipeline data' do + expect(resolve_pipelines).to be_empty + end end - it 'resolves only MRs for the passed merge request' do - expect(resolve_pipelines).to contain_exactly(pipeline) + def resolve_pipelines + resolve(described_class, obj: project, ctx: { current_user: current_user }) end end diff --git a/spec/graphql/types/base_field_spec.rb b/spec/graphql/types/base_field_spec.rb index 82efd618e38..31d07f701e8 100644 --- a/spec/graphql/types/base_field_spec.rb +++ b/spec/graphql/types/base_field_spec.rb @@ -154,6 +154,17 @@ RSpec.describe Types::BaseField do end end + describe '#resolve' do + context "late_extensions is given" do + it 'registers the late extensions after the regular extensions' do + extension_class = Class.new(GraphQL::Schema::Field::ConnectionExtension) + field = described_class.new(name: 'test', type: GraphQL::Types::String.connection_type, null: true, late_extensions: [extension_class]) + + expect(field.extensions.last.class).to be(extension_class) + end + end + end + describe '#description' do context 'feature flag given' do let(:field) { described_class.new(name: 'test', type: GraphQL::Types::String, feature_flag: flag, null: false, description: 'Test description.') } diff --git a/spec/graphql/types/board_list_type_spec.rb b/spec/graphql/types/board_list_type_spec.rb index 7976936fc1f..d78d87c57bd 100644 --- a/spec/graphql/types/board_list_type_spec.rb +++ b/spec/graphql/types/board_list_type_spec.rb @@ -3,11 +3,36 @@ require 'spec_helper' RSpec.describe GitlabSchema.types['BoardList'] do + include GraphqlHelpers + include Gitlab::Graphql::Laziness + specify { expect(described_class.graphql_name).to eq('BoardList') } it 'has specific fields' do - expected_fields = %w[id list_type position label issues_count issues] + expected_fields = %w[id title list_type position label issues_count issues] expect(described_class).to include_graphql_fields(*expected_fields) end + + describe 'issues field' do + subject { described_class.fields['issues'] } + + it 'has a correct extension' do + is_expected.to have_graphql_extension(Gitlab::Graphql::Board::IssuesConnectionExtension) + end + end + + describe 'title' do + subject(:field) { described_class.fields['title'] } + + it 'preloads the label association' do + a, b, c = create_list(:list, 3).map { _1.class.find(_1.id) } + + baseline = ActiveRecord::QueryRecorder.new { force(resolve_field(field, a)) } + + expect do + [resolve_field(field, b), resolve_field(field, c)].each { force _1 } + end.not_to exceed_query_limit(baseline) + end + end end diff --git a/spec/graphql/types/ci/pipeline_type_spec.rb b/spec/graphql/types/ci/pipeline_type_spec.rb index 9ba4252bcd5..8c849114cf6 100644 --- a/spec/graphql/types/ci/pipeline_type_spec.rb +++ b/spec/graphql/types/ci/pipeline_type_spec.rb @@ -18,7 +18,7 @@ RSpec.describe Types::Ci::PipelineType do ] if Gitlab.ee? - expected_fields += %w[security_report_summary security_report_findings code_quality_reports] + expected_fields += %w[security_report_summary security_report_findings code_quality_reports dast_profile] end expect(described_class).to have_graphql_fields(*expected_fields) diff --git a/spec/graphql/types/ci/runner_type_spec.rb b/spec/graphql/types/ci/runner_type_spec.rb index cff4c459d79..cf8650a4a03 100644 --- a/spec/graphql/types/ci/runner_type_spec.rb +++ b/spec/graphql/types/ci/runner_type_spec.rb @@ -11,7 +11,7 @@ RSpec.describe GitlabSchema.types['CiRunner'] do expected_fields = %w[ id description contacted_at maximum_timeout access_level active status version short_sha revision locked run_untagged ip_address runner_type tag_list - project_count job_count + project_count job_count admin_url user_permissions ] expect(described_class).to include_graphql_fields(*expected_fields) diff --git a/spec/graphql/types/clusters/agent_token_type_spec.rb b/spec/graphql/types/clusters/agent_token_type_spec.rb new file mode 100644 index 00000000000..c872d201fd9 --- /dev/null +++ b/spec/graphql/types/clusters/agent_token_type_spec.rb @@ -0,0 +1,13 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['ClusterAgentToken'] do + let(:fields) { %i[cluster_agent created_at created_by_user description id last_used_at name] } + + it { expect(described_class.graphql_name).to eq('ClusterAgentToken') } + + it { expect(described_class).to require_graphql_authorizations(:admin_cluster) } + + it { expect(described_class).to have_graphql_fields(fields) } +end diff --git a/spec/graphql/types/clusters/agent_type_spec.rb b/spec/graphql/types/clusters/agent_type_spec.rb new file mode 100644 index 00000000000..4b4b601b230 --- /dev/null +++ b/spec/graphql/types/clusters/agent_type_spec.rb @@ -0,0 +1,13 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['ClusterAgent'] do + let(:fields) { %i[created_at created_by_user id name project updated_at tokens web_path connections] } + + it { expect(described_class.graphql_name).to eq('ClusterAgent') } + + it { expect(described_class).to require_graphql_authorizations(:admin_cluster) } + + it { expect(described_class).to have_graphql_fields(fields) } +end diff --git a/spec/graphql/types/container_expiration_policy_older_than_enum_spec.rb b/spec/graphql/types/container_expiration_policy_older_than_enum_spec.rb index 72ab605f2e6..1989b87a28f 100644 --- a/spec/graphql/types/container_expiration_policy_older_than_enum_spec.rb +++ b/spec/graphql/types/container_expiration_policy_older_than_enum_spec.rb @@ -3,7 +3,7 @@ require 'spec_helper' RSpec.describe GitlabSchema.types['ContainerExpirationPolicyOlderThanEnum'] do - let_it_be(:expected_values) { %w[SEVEN_DAYS FOURTEEN_DAYS THIRTY_DAYS NINETY_DAYS] } + let_it_be(:expected_values) { %w[SEVEN_DAYS FOURTEEN_DAYS THIRTY_DAYS SIXTY_DAYS NINETY_DAYS] } it_behaves_like 'exposing container expiration policy option', :older_than end diff --git a/spec/graphql/types/error_tracking/sentry_detailed_error_type_spec.rb b/spec/graphql/types/error_tracking/sentry_detailed_error_type_spec.rb index 8723c212486..09746750adc 100644 --- a/spec/graphql/types/error_tracking/sentry_detailed_error_type_spec.rb +++ b/spec/graphql/types/error_tracking/sentry_detailed_error_type_spec.rb @@ -10,6 +10,7 @@ RSpec.describe GitlabSchema.types['SentryDetailedError'] do it 'exposes the expected fields' do expected_fields = %i[ id + integrated sentryId title type diff --git a/spec/graphql/types/issue_type_spec.rb b/spec/graphql/types/issue_type_spec.rb index 559f347810b..c0a0fdf3b0b 100644 --- a/spec/graphql/types/issue_type_spec.rb +++ b/spec/graphql/types/issue_type_spec.rb @@ -18,7 +18,7 @@ RSpec.describe GitlabSchema.types['Issue'] do confidential hidden discussion_locked upvotes downvotes merge_requests_count user_notes_count user_discussions_count web_path web_url relative_position emails_disabled subscribed time_estimate total_time_spent human_time_estimate human_total_time_spent closed_at created_at updated_at task_completion_status design_collection alert_management_alert severity current_user_todos moved moved_to - create_note_email timelogs project_id] + create_note_email timelogs project_id customer_relations_contacts] fields.each do |field_name| expect(described_class).to have_graphql_field(field_name) diff --git a/spec/graphql/types/kas/agent_configuration_type_spec.rb b/spec/graphql/types/kas/agent_configuration_type_spec.rb new file mode 100644 index 00000000000..e6cccfa56d2 --- /dev/null +++ b/spec/graphql/types/kas/agent_configuration_type_spec.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe GitlabSchema.types['AgentConfiguration'] do + let(:fields) { %i[agent_name] } + + it { expect(described_class.graphql_name).to eq('AgentConfiguration') } + it { expect(described_class.description).to eq('Configuration details for an Agent') } + it { expect(described_class).to have_graphql_fields(fields) } +end diff --git a/spec/graphql/types/kas/agent_connection_type_spec.rb b/spec/graphql/types/kas/agent_connection_type_spec.rb new file mode 100644 index 00000000000..0990d02af11 --- /dev/null +++ b/spec/graphql/types/kas/agent_connection_type_spec.rb @@ -0,0 +1,22 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Kas::AgentConnectionType do + include GraphqlHelpers + + let(:fields) { %i[connected_at connection_id metadata] } + + it { expect(described_class.graphql_name).to eq('ConnectedAgent') } + it { expect(described_class.description).to eq('Connection details for an Agent') } + it { expect(described_class).to have_graphql_fields(fields) } + + describe '#connected_at' do + let(:connected_at) { double(Google::Protobuf::Timestamp, seconds: 123456, nanos: 654321) } + let(:object) { double(Gitlab::Agent::AgentTracker::ConnectedAgentInfo, connected_at: connected_at) } + + it 'converts the seconds value to a timestamp' do + expect(resolve_field(:connected_at, object)).to eq(Time.at(connected_at.seconds)) + end + end +end diff --git a/spec/graphql/types/kas/agent_metadata_type_spec.rb b/spec/graphql/types/kas/agent_metadata_type_spec.rb new file mode 100644 index 00000000000..ebc12ebb72a --- /dev/null +++ b/spec/graphql/types/kas/agent_metadata_type_spec.rb @@ -0,0 +1,13 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::Kas::AgentMetadataType do + include GraphqlHelpers + + let(:fields) { %i[version commit pod_namespace pod_name] } + + it { expect(described_class.graphql_name).to eq('AgentMetadata') } + it { expect(described_class.description).to eq('Information about a connected Agent') } + it { expect(described_class).to have_graphql_fields(fields) } +end diff --git a/spec/graphql/types/packages/nuget/metadatum_type_spec.rb b/spec/graphql/types/packages/nuget/metadatum_type_spec.rb index e5baa7522e4..94a1dbaee43 100644 --- a/spec/graphql/types/packages/nuget/metadatum_type_spec.rb +++ b/spec/graphql/types/packages/nuget/metadatum_type_spec.rb @@ -10,4 +10,10 @@ RSpec.describe GitlabSchema.types['NugetMetadata'] do expect(described_class).to include_graphql_fields(*expected_fields) end + + %w[projectUrl licenseUrl iconUrl].each do |optional_field| + it "#{optional_field} can be null" do + expect(described_class.fields[optional_field].type).to be_nullable + end + end end diff --git a/spec/graphql/types/packages/package_type_spec.rb b/spec/graphql/types/packages/package_type_spec.rb index 07573044abb..3267c765dc7 100644 --- a/spec/graphql/types/packages/package_type_spec.rb +++ b/spec/graphql/types/packages/package_type_spec.rb @@ -9,7 +9,7 @@ RSpec.describe GitlabSchema.types['Package'] do created_at updated_at project tags pipelines metadata versions - status + status can_destroy ] expect(described_class).to include_graphql_fields(*expected_fields) diff --git a/spec/graphql/types/permission_types/ci/runner_spec.rb b/spec/graphql/types/permission_types/ci/runner_spec.rb new file mode 100644 index 00000000000..e5fbbb346e4 --- /dev/null +++ b/spec/graphql/types/permission_types/ci/runner_spec.rb @@ -0,0 +1,15 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Types::PermissionTypes::Ci::Runner do + it do + expected_permissions = [ + :read_runner, :update_runner, :delete_runner + ] + + expected_permissions.each do |permission| + expect(described_class).to have_graphql_field(permission) + end + end +end diff --git a/spec/graphql/types/project_type_spec.rb b/spec/graphql/types/project_type_spec.rb index d825bd7ebd4..45a718683be 100644 --- a/spec/graphql/types/project_type_spec.rb +++ b/spec/graphql/types/project_type_spec.rb @@ -33,6 +33,7 @@ RSpec.describe GitlabSchema.types['Project'] do issue_status_counts terraform_states alert_management_integrations container_repositories container_repositories_count pipeline_analytics squash_read_only sast_ci_configuration + cluster_agent cluster_agents agent_configurations ci_template timelogs ] @@ -186,7 +187,7 @@ RSpec.describe GitlabSchema.types['Project'] do expect(analyzer['enabled']).to eq(true) end - context "with guest user" do + context 'with guest user' do before do project.add_guest(user) end @@ -194,7 +195,7 @@ RSpec.describe GitlabSchema.types['Project'] do context 'when project is private' do let(:project) { create(:project, :private, :repository) } - it "returns no configuration" do + it 'returns no configuration' do secure_analyzers_prefix = subject.dig('data', 'project', 'sastCiConfiguration') expect(secure_analyzers_prefix).to be_nil end @@ -214,7 +215,7 @@ RSpec.describe GitlabSchema.types['Project'] do end end - context "with non-member user" do + context 'with non-member user', :sidekiq_inline do before do project.team.truncate end @@ -222,7 +223,7 @@ RSpec.describe GitlabSchema.types['Project'] do context 'when project is private' do let(:project) { create(:project, :private, :repository) } - it "returns no configuration" do + it 'returns no configuration' do secure_analyzers_prefix = subject.dig('data', 'project', 'sastCiConfiguration') expect(secure_analyzers_prefix).to be_nil end @@ -240,7 +241,7 @@ RSpec.describe GitlabSchema.types['Project'] do end context 'when repository is accessible only by team members' do - it "returns no configuration" do + it 'returns no configuration' do project.project_feature.update!( merge_requests_access_level: ProjectFeature::DISABLED, builds_access_level: ProjectFeature::DISABLED, @@ -458,4 +459,137 @@ RSpec.describe GitlabSchema.types['Project'] do it { is_expected.to have_graphql_type(Types::Ci::JobTokenScopeType) } it { is_expected.to have_graphql_resolver(Resolvers::Ci::JobTokenScopeResolver) } end + + describe 'agent_configurations' do + let_it_be(:project) { create(:project) } + let_it_be(:user) { create(:user) } + let_it_be(:query) do + %( + query { + project(fullPath: "#{project.full_path}") { + agentConfigurations { + nodes { + agentName + } + } + } + } + ) + end + + let(:agent_name) { 'example-agent-name' } + let(:kas_client) { instance_double(Gitlab::Kas::Client, list_agent_config_files: [double(agent_name: agent_name)]) } + + subject { GitlabSchema.execute(query, context: { current_user: user }).as_json } + + before do + project.add_maintainer(user) + allow(Gitlab::Kas::Client).to receive(:new).and_return(kas_client) + end + + it 'returns configured agents' do + agents = subject.dig('data', 'project', 'agentConfigurations', 'nodes') + + expect(agents.count).to eq(1) + expect(agents.first['agentName']).to eq(agent_name) + end + end + + describe 'cluster_agents' do + let_it_be(:project) { create(:project) } + let_it_be(:user) { create(:user) } + let_it_be(:cluster_agent) { create(:cluster_agent, project: project, name: 'agent-name') } + let_it_be(:query) do + %( + query { + project(fullPath: "#{project.full_path}") { + clusterAgents { + count + nodes { + id + name + createdAt + updatedAt + + project { + id + } + } + } + } + } + ) + end + + subject { GitlabSchema.execute(query, context: { current_user: user }).as_json } + + before do + project.add_maintainer(user) + end + + it 'returns associated cluster agents' do + agents = subject.dig('data', 'project', 'clusterAgents', 'nodes') + + expect(agents.count).to be(1) + expect(agents.first['id']).to eq(cluster_agent.to_global_id.to_s) + expect(agents.first['name']).to eq('agent-name') + expect(agents.first['createdAt']).to be_present + expect(agents.first['updatedAt']).to be_present + expect(agents.first['project']['id']).to eq(project.to_global_id.to_s) + end + + it 'returns count of cluster agents' do + count = subject.dig('data', 'project', 'clusterAgents', 'count') + + expect(count).to be(project.cluster_agents.size) + end + end + + describe 'cluster_agent' do + let_it_be(:project) { create(:project) } + let_it_be(:user) { create(:user) } + let_it_be(:cluster_agent) { create(:cluster_agent, project: project, name: 'agent-name') } + let_it_be(:agent_token) { create(:cluster_agent_token, agent: cluster_agent) } + let_it_be(:query) do + %( + query { + project(fullPath: "#{project.full_path}") { + clusterAgent(name: "#{cluster_agent.name}") { + id + + tokens { + count + nodes { + id + } + } + } + } + } + ) + end + + subject { GitlabSchema.execute(query, context: { current_user: user }).as_json } + + before do + project.add_maintainer(user) + end + + it 'returns associated cluster agents' do + agent = subject.dig('data', 'project', 'clusterAgent') + tokens = agent.dig('tokens', 'nodes') + + expect(agent['id']).to eq(cluster_agent.to_global_id.to_s) + + expect(tokens.count).to be(1) + expect(tokens.first['id']).to eq(agent_token.to_global_id.to_s) + end + + it 'returns count of agent tokens' do + agent = subject.dig('data', 'project', 'clusterAgent') + count = agent.dig('tokens', 'count') + + expect(cluster_agent.agent_tokens.size).to be(count) + end + end end diff --git a/spec/graphql/types/query_type_spec.rb b/spec/graphql/types/query_type_spec.rb index 6a43867f1fe..14ef03a64f9 100644 --- a/spec/graphql/types/query_type_spec.rb +++ b/spec/graphql/types/query_type_spec.rb @@ -27,6 +27,7 @@ RSpec.describe GitlabSchema.types['Query'] do runner runners timelogs + board_list ] expect(described_class).to have_graphql_fields(*expected_fields).at_least @@ -136,4 +137,14 @@ RSpec.describe GitlabSchema.types['Query'] do is_expected.to have_graphql_resolver(Resolvers::TimelogResolver) end end + + describe 'boardList field' do + subject { described_class.fields['boardList'] } + + it 'finds a board list by its gid' do + is_expected.to have_graphql_arguments(:id, :issue_filters) + is_expected.to have_graphql_type(Types::BoardListType) + is_expected.to have_graphql_resolver(Resolvers::BoardListResolver) + end + end end |