INSTRUCTION stringlengths 202 35.5k | RESPONSE stringlengths 75 161k |
|---|---|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
class CreateService < Groups::BaseService
def initialize(user, params = {})
@current_user = user
@params = params.dup
@chat_team = @params.delete(:create_chat_team)
@create_event = @params.d... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::CreateService, '#execute', feature_category: :groups_and_projects do
let!(:user) { create(:user) }
let!(:group_params) { { path: "group_path", visibility_level: Gitlab::VisibilityLevel::PUBLIC } }
subject { service.execute }
shared_e... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
class NestedCreateService < Groups::BaseService
attr_reader :group_path, :visibility_level
def initialize(user, params)
@current_user = user
@params = params.dup
@group_path = @params.delete(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::NestedCreateService, feature_category: :groups_and_projects do
let(:user) { create(:user) }
subject(:service) { described_class.new(user, params) }
shared_examples 'with a visibility level' do
it 'creates the group with correct vis... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module GroupLinks
class DestroyService < ::Groups::BaseService
def execute(one_or_more_links, skip_authorization: false)
unless skip_authorization || group && can?(current_user, :admin_group_member, g... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::GroupLinks::DestroyService, '#execute', feature_category: :groups_and_projects do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group, :private) }
let_it_be(:shared_group) { create(:group, :private) }
let_it_be(:projec... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module GroupLinks
class UpdateService < ::Groups::BaseService
def initialize(group_link, user = nil)
super(group_link.shared_group, user)
@group_link = group_link
end
def execute... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::GroupLinks::UpdateService, '#execute', feature_category: :groups_and_projects do
let(:user) { create(:user) }
let_it_be(:group) { create(:group, :private) }
let_it_be(:shared_group) { create(:group, :private) }
let_it_be(:project) { c... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module GroupLinks
class CreateService < ::Groups::BaseService
include GroupLinkable
def initialize(group, shared_with_group, user, params)
@shared_with_group = shared_with_group
super(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::GroupLinks::CreateService, '#execute', feature_category: :groups_and_projects do
let_it_be(:shared_with_group_parent) { create(:group, :private) }
let_it_be(:shared_with_group) { create(:group, :private, parent: shared_with_group_parent) }... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module ImportExport
class ImportService
attr_reader :current_user, :group, :shared
def initialize(group:, user:)
@group = group
@current_user = user
@user_role = user_role
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::ImportExport::ImportService, feature_category: :importers do
describe '#async_execute' do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
before do
allow(GroupImportWorker).to receive(:with_status).... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module ImportExport
class ExportService
def initialize(group:, user:, params: {})
@group = group
@current_user = user
@params = params
@shared = @params[:shared] || Gitlab::Imp... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::ImportExport::ExportService, feature_category: :importers do
describe '#async_execute' do
let(:user) { create(:user) }
let(:group) { create(:group) }
context 'when the job can be successfully scheduled' do
let(:export_serv... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module DeployTokens
class RevokeService < BaseService
attr_accessor :token
def execute
@token = group.deploy_tokens.find(params[:id])
@token.revoke!
end
end
end
end
Groups:... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::DeployTokens::RevokeService, feature_category: :deployment_management do
let_it_be(:entity) { create(:group) }
let_it_be(:deploy_token) { create(:deploy_token, :group, groups: [entity]) }
let_it_be(:user) { create(:user) }
let_it_be(:d... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module DeployTokens
class DestroyService < BaseService
include DeployTokenMethods
def execute
destroy_deploy_token(@group, params)
end
end
end
end
Groups::DeployTokens::DestroyServ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::DeployTokens::DestroyService, feature_category: :deployment_management do
it_behaves_like 'a deploy token deletion service' do
let_it_be(:entity) { create(:group) }
let_it_be(:deploy_token_class) { GroupDeployToken }
let_it_be(:d... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Groups
module DeployTokens
class CreateService < BaseService
include DeployTokenMethods
def execute
deploy_token = create_deploy_token_for(@group, current_user, params)
create_deploy_token_pa... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Groups::DeployTokens::CreateService, feature_category: :deployment_management do
it_behaves_like 'a deploy token creation service' do
let(:entity) { create(:group) }
let(:deploy_token_class) { GroupDeployToken }
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PersonalAccessTokens
class LastUsedService
def initialize(personal_access_token)
@personal_access_token = personal_access_token
end
def execute
# Needed to avoid calling service on Oauth tokens
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PersonalAccessTokens::LastUsedService, feature_category: :system_access do
describe '#execute' do
subject { described_class.new(personal_access_token).execute }
context 'when the personal access token was used 10 minutes ago', :freeze_time ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PersonalAccessTokens
class RotateService
EXPIRATION_PERIOD = 1.week
def initialize(current_user, token)
@current_user = current_user
@token = token
end
def execute(params = {})
return error... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PersonalAccessTokens::RotateService, feature_category: :system_access do
describe '#execute' do
let_it_be(:token, reload: true) { create(:personal_access_token) }
subject(:response) { described_class.new(token.user, token).execute }
it... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PersonalAccessTokens
class RevokeService < BaseService
attr_reader :token, :current_user, :group
VALID_SOURCES = %i[self secret_detection].freeze
def initialize(current_user = nil, token: nil, group: nil, source... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PersonalAccessTokens::RevokeService, feature_category: :system_access do
shared_examples_for 'a successfully revoked token' do
it { expect(subject.success?).to be true }
it { expect(service.token.revoked?).to be true }
it 'logs the even... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PersonalAccessTokens
class RevokeTokenFamilyService
def initialize(token)
@token = token
end
def execute
# A token family is a chain of rotated tokens. Once rotated, the previous
# token is revo... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PersonalAccessTokens::RevokeTokenFamilyService, feature_category: :system_access do
describe '#execute' do
let_it_be(:token_3) { create(:personal_access_token, :revoked) }
let_it_be(:token_2) { create(:personal_access_token, :revoked, previo... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PersonalAccessTokens
class CreateService < BaseService
def initialize(current_user:, target_user:, params: {}, concatenate_errors: true)
@current_user = current_user
@target_user = target_user
@params = ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PersonalAccessTokens::CreateService, feature_category: :system_access do
shared_examples_for 'a successfully created token' do
it 'creates personal access token record' do
expect(subject.success?).to be true
expect(token.name).to eq(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ExportCsv
class MapExportFieldsService < BaseService
attr_reader :fields, :data
def initialize(fields, data)
@fields = fields
@data = data
end
def execute
return data if fields.empty?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ExportCsv::MapExportFieldsService, feature_category: :team_planning do
let(:selected_fields) { ['Title', 'Author username', 'state'] }
let(:invalid_fields) { ['Title', 'Author Username', 'State', 'Invalid Field', 'Other Field'] }
let(:data) do
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ExportCsv
class BaseService
# Target attachment size before base64 encoding
TARGET_FILESIZE = 15.megabytes
def initialize(relation, resource_parent, fields = [])
@objects = relation
@resource_parent =... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ExportCsv::BaseService, feature_category: :importers do
let_it_be(:issue) { create(:issue) }
let_it_be(:relation) { Issue.all }
let_it_be(:resource_parent) { issue.project }
subject { described_class.new(relation, resource_parent) }
descri... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class PushedBranchesService < MergeRequests::BaseService
include ::Gitlab::Utils::StrongMemoize
# Skip moving this logic into models since it's too specific
# rubocop: disable CodeReuse/ActiveRecord... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::PushedBranchesService, feature_category: :source_code_management do
let(:project) { create(:project) }
let!(:service) { described_class.new(project: project, current_user: nil, params: { changes: pushed_branches }) }
context 'whe... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class RebaseService < MergeRequests::BaseService
REBASE_ERROR = 'Rebase failed: Rebase locally, resolve all conflicts, then push the branch.'
attr_reader :merge_request, :rebase_error
def validate(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::RebaseService, feature_category: :source_code_management do
include ProjectForksHelper
let(:user) { create(:user) }
let(:rebase_jid) { 'fake-rebase-jid' }
let(:merge_request) do
create(
:merge_request,
source_br... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ExportCsvService < ExportCsv::BaseService
include Gitlab::Routing.url_helpers
include GitlabRoutingHelper
def email(user)
Notify.merge_requests_csv_email(user, resource_parent, csv_data,... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ExportCsvService, feature_category: :importers do
let_it_be(:merge_request) { create(:merge_request) }
let(:csv) { CSV.parse(subject.csv_data, headers: true).first }
subject { described_class.new(MergeRequest.where(id: merge_req... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class LinkLfsObjectsService < ::BaseProjectService
def execute(merge_request, oldrev: merge_request.diff_base_sha, newrev: merge_request.diff_head_sha)
return if merge_request.source_project == project... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::LinkLfsObjectsService, :sidekiq_inline, feature_category: :code_review_workflow do
include ProjectForksHelper
include RepoHelpers
let(:target_project) { create(:project, :public, :repository) }
let(:merge_request) do
creat... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class MergeabilityCheckService < ::BaseService
include Gitlab::Utils::StrongMemoize
include Gitlab::ExclusiveLeaseHelpers
delegate :project, to: :@merge_request
delegate :repository, to: :projec... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MergeabilityCheckService, :clean_gitlab_redis_shared_state, feature_category: :code_review_workflow do
shared_examples_for 'unmergeable merge request' do
it 'updates or keeps merge status as cannot_be_merged' do
subject
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class AssignIssuesService < BaseProjectService
def assignable_issues
@assignable_issues ||= if current_user == merge_request.author
closes_issues.select do |issue|
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::AssignIssuesService, feature_category: :code_review_workflow do
let(:user) { create(:user) }
let(:project) { create(:project, :public, :repository) }
let(:issue) { create(:issue, project: project) }
let(:merge_request) { create(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ReloadDiffsService
def initialize(merge_request, current_user)
@merge_request = merge_request
@current_user = current_user
end
def execute
old_diff_refs = merge_request.diff_... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ReloadDiffsService, :use_clean_rails_memory_store_caching,
feature_category: :code_review_workflow do
let(:current_user) { create(:user) }
let(:merge_request) { create(:merge_request) }
let(:subject) { described_class.new(merge_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class MigrateExternalDiffsService < ::BaseService
MAX_JOBS = 1000
attr_reader :diff
def self.enqueue!
ids = MergeRequestDiff.ids_for_external_storage_migration(limit: MAX_JOBS)
# ruboc... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MigrateExternalDiffsService, feature_category: :code_review_workflow do
let(:merge_request) { create(:merge_request) }
let(:diff) { merge_request.merge_request_diff }
describe '.enqueue!' do
around do |example|
Sidekiq:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class UpdateReviewerStateService < MergeRequests::BaseService
def execute(merge_request, state)
return error("Invalid permissions") unless can?(current_user, :update_merge_request, merge_request)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::UpdateReviewerStateService, feature_category: :code_review_workflow do
let_it_be(:current_user) { create(:user) }
let_it_be(:merge_request) { create(:merge_request, reviewers: [current_user]) }
let(:reviewer) { merge_request.merge... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class RetargetChainService < MergeRequests::BaseService
MAX_RETARGET_MERGE_REQUESTS = 4
def execute(merge_request)
# we can only retarget MRs that are targeting the same project
return unles... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::RetargetChainService, feature_category: :code_review_workflow do
include ProjectForksHelper
let_it_be(:user) { create(:user) }
let_it_be(:merge_request, reload: true) { create(:merge_request, assignees: [user]) }
let_it_be(:pro... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class CleanupRefsService
include BaseServiceUtility
TIME_THRESHOLD = 14.days
attr_reader :merge_request
def self.schedule(merge_request)
merge_request.create_cleanup_schedule(scheduled_a... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CleanupRefsService, feature_category: :code_review_workflow do
describe '.schedule' do
let(:merge_request) { create(:merge_request) }
it 'creates a merge request cleanup schedule' do
freeze_time do
described_cla... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
# Performs the merge between source SHA and the target branch or the specified first parent ref. Instead
# of writing the result to the MR target branch, it targets the `target_ref`.
#
# Ideally this shoul... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MergeToRefService, feature_category: :code_review_workflow do
shared_examples_for 'MergeService for target ref' do
it 'target_ref has the same state of target branch' do
repo = merge_request.target_project.repository
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class CreateApprovalEventService < MergeRequests::BaseService
def execute(merge_request)
event_service.approve_mr(merge_request, current_user)
end
end
end
MergeRequests::CreateApprovalEventServi... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CreateApprovalEventService, feature_category: :code_review_workflow do
let(:user) { create(:user) }
let(:merge_request) { create(:merge_request) }
let(:project) { merge_request.project }
subject(:service) { described_class.new(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ReopenService < MergeRequests::BaseService
def execute(merge_request)
return merge_request unless can?(current_user, :reopen_merge_request, merge_request)
if merge_request.reopen
u... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ReopenService, feature_category: :code_review_workflow do
let(:user) { create(:user) }
let(:user2) { create(:user) }
let(:guest) { create(:user) }
let(:merge_request) { create(:merge_request, :closed, assignees: [user2], author:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class CreateFromIssueService < MergeRequests::CreateService
# TODO: This constructor does not use the "params:" argument from the superclass,
# but instead has a custom "mr_params:" argument. This is b... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CreateFromIssueService, feature_category: :code_review_workflow do
include ProjectForksHelper
let(:project) { create(:project, :repository) }
let(:user) { create(:user) }
let(:label_ids) { create_pair(:label, project: project).... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class UpdateAssigneesService < UpdateService
# a stripped down service that only does what it must to update the
# assignees, and knows that it does not have to check for other updates.
# This saves ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::UpdateAssigneesService, feature_category: :code_review_workflow do
include AfterNextHelpers
let_it_be(:group) { create(:group, :public) }
let_it_be(:project) { create(:project, :private, :repository, group: group) }
let_it_be(:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ReloadMergeHeadDiffService
include BaseServiceUtility
def initialize(merge_request)
@merge_request = merge_request
end
def execute
return error("Merge request has no merge ref... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ReloadMergeHeadDiffService, feature_category: :code_review_workflow do
let(:merge_request) { create(:merge_request) }
subject { described_class.new(merge_request).execute }
describe '#execute' do
before do
MergeRequest... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class SquashService
include BaseServiceUtility
include MergeRequests::ErrorLogger
def initialize(merge_request:, current_user:, commit_message:)
@merge_request = merge_request
@target_pr... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::SquashService, feature_category: :source_code_management do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:user) { project.first_owner }
let(:service) { described_class.new(merge_request: merge_request, current_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class DeleteNonLatestDiffsService
BATCH_SIZE = 10
def initialize(merge_request)
@merge_request = merge_request
end
def execute
diffs = @merge_request.non_latest_diffs.with_files
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::DeleteNonLatestDiffsService, :clean_gitlab_redis_shared_state,
feature_category: :code_review_workflow do
let(:merge_request) { create(:merge_request) }
let!(:subject) { described_class.new(merge_request) }
describe '#execute'... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class AddSpentTimeService < UpdateService
def execute(merge_request)
old_associations = { total_time_spent: merge_request.total_time_spent }
merge_request.spend_time(params[:spend_time])
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::AddSpentTimeService, feature_category: :code_review_workflow do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :public, :repository) }
let_it_be_with_reload(:merge_request) { create(:merge_request, :simp... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class UpdateReviewersService < UpdateService
def execute(merge_request)
return merge_request unless current_user&.can?(:update_merge_request, merge_request)
old_reviewers = merge_request.reviewe... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::UpdateReviewersService, feature_category: :code_review_workflow do
include AfterNextHelpers
let_it_be(:group) { create(:group, :public) }
let_it_be(:project) { create(:project, :private, :repository, group: group) }
let_it_be(:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class PushOptionsHandlerService < ::BaseProjectService
LIMIT = 10
attr_reader :errors, :changes, :push_options, :target_project
def initialize(project:, current_user:, changes:, push_options:, para... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::PushOptionsHandlerService, feature_category: :source_code_management do
include ProjectForksHelper
let_it_be(:parent_group) { create(:group, :public) }
let_it_be(:child_group) { create(:group, :public, parent: parent_group) }
l... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class BaseService < ::IssuableBaseService
extend ::Gitlab::Utils::Override
include MergeRequests::AssignsMergeParams
include MergeRequests::ErrorLogger
delegate :repository, to: :project
de... | # frozen_string_literal: true
require 'spec_helper'
module MergeRequests
class ExampleService < MergeRequests::BaseService
def execute(merge_request, async: false, allow_duplicate: false)
create_pipeline_for(merge_request, current_user, async: async, allow_duplicate: allow_duplicate)
end
end
end
RS... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class RequestReviewService < MergeRequests::BaseService
def execute(merge_request, user)
return error("Invalid permissions") unless can?(current_user, :update_merge_request, merge_request)
revie... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::RequestReviewService, feature_category: :code_review_workflow do
let(:current_user) { create(:user) }
let(:user) { create(:user) }
let(:merge_request) { create(:merge_request, reviewers: [user]) }
let(:reviewer) { merge_request.... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class GetUrlsService < BaseProjectService
def execute(changes)
return [] unless project&.printing_merge_request_link_enabled
branches = get_branches(changes)
merge_requests_map = opened_me... | # frozen_string_literal: true
require "spec_helper"
RSpec.describe MergeRequests::GetUrlsService, feature_category: :code_review_workflow do
include ProjectForksHelper
let(:project) { create(:project, :public, :repository) }
let(:service) { described_class.new(project: project) }
let(:source_branch) { "merge... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
# PostMergeService class
#
# Mark existing merge request as merged
# and execute all hooks and notifications
#
class PostMergeService < MergeRequests::BaseService
include RemovesRefs
MAX_RETAR... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::PostMergeService, feature_category: :code_review_workflow do
include ProjectForksHelper
let_it_be(:user) { create(:user) }
let_it_be(:merge_request, reload: true) { create(:merge_request, assignees: [user]) }
let_it_be(:project... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ResolvedDiscussionNotificationService < MergeRequests::BaseService
def execute(merge_request)
return unless merge_request.discussions_resolved?
SystemNoteService.resolve_all_discussions(me... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ResolvedDiscussionNotificationService, feature_category: :code_review_workflow do
let(:merge_request) { create(:merge_request) }
let(:user) { create(:user) }
let(:project) { merge_request.project }
subject { described_class.new... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class RemoveApprovalService < MergeRequests::BaseService
# rubocop: disable CodeReuse/ActiveRecord
def execute(merge_request)
return unless merge_request.approved_by?(current_user)
# paranoi... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::RemoveApprovalService, feature_category: :code_review_workflow do
describe '#execute' do
let(:user) { create(:user) }
let(:project) { create(:project) }
let(:merge_request) { create(:merge_request, source_project: project)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ApprovalService < MergeRequests::BaseService
def execute(merge_request)
return unless eligible_for_approval?(merge_request)
approval = merge_request.approvals.new(
user: current_us... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ApprovalService, feature_category: :code_review_workflow do
describe '#execute' do
let(:user) { create(:user) }
let(:merge_request) { create(:merge_request, reviewers: [user]) }
let(:project) { merge_request... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class AddTodoWhenBuildFailsService < MergeRequests::BaseService
# Adds a todo to the parent merge_request when a CI build fails
#
def execute(commit_status)
return if commit_status.allow_failur... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::MergeRequests::AddTodoWhenBuildFailsService, feature_category: :code_review_workflow do
let(:user) { create(:user) }
let(:project) { create(:project, :repository) }
let(:sha) { '1234567890abcdef1234567890abcdef12345678' }
let(:ref) { merge_r... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class BuildService < MergeRequests::BaseService
include Gitlab::Utils::StrongMemoize
def execute
@params_issue_iid = params.delete(:issue_iid)
self.merge_request = MergeRequest.new
# T... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::BuildService, feature_category: :code_review_workflow do
using RSpec::Parameterized::TableSyntax
include RepoHelpers
include ProjectForksHelper
let(:project) { create(:project, :repository) }
let(:source_project) { nil }
let... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ResolveTodosService
include BaseServiceUtility
def initialize(merge_request, user)
@merge_request = merge_request
@user = user
end
def async_execute
MergeRequests::Resol... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ResolveTodosService, feature_category: :code_review_workflow do
let_it_be(:merge_request) { create(:merge_request) }
let_it_be(:user) { create(:user) }
let(:service) { described_class.new(merge_request, user) }
describe '#asyn... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class CloseService < MergeRequests::BaseService
include RemovesRefs
def execute(merge_request, commit = nil)
return merge_request unless can?(current_user, :update_merge_request, merge_request)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CloseService, feature_category: :code_review_workflow do
let(:user) { create(:user) }
let(:user2) { create(:user) }
let(:guest) { create(:user) }
let(:merge_request) { create(:merge_request, assignees: [user2], author: create(:u... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class AfterCreateService < MergeRequests::BaseService
include Gitlab::Utils::StrongMemoize
def execute(merge_request)
merge_request.ensure_merge_request_diff
logger.info(**log_payload(merge... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::AfterCreateService, feature_category: :code_review_workflow do
let_it_be(:merge_request) { create(:merge_request) }
let(:project) { merge_request.project }
subject(:after_create_service) do
described_class.new(project: merge_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class CreatePipelineService < MergeRequests::BaseService
def execute(merge_request)
return cannot_create_pipeline_error unless can_create_pipeline_for?(merge_request)
create_detached_merge_reque... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CreatePipelineService, :clean_gitlab_redis_cache, feature_category: :code_review_workflow do
include ProjectForksHelper
let_it_be(:project, refind: true) { create(:project, :repository) }
let_it_be(:user) { create(:user) }
let... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class MergeOrchestrationService < ::BaseService
def execute(merge_request)
return unless can_merge?(merge_request)
merge_request.update(merge_error: nil)
if can_merge_automatically?(merge... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MergeOrchestrationService, feature_category: :code_review_workflow do
let_it_be(:maintainer) { create(:user) }
let(:merge_params) { { sha: merge_request.diff_head_sha } }
let(:user) { maintainer }
let(:service) { described_clas... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class UpdateService < MergeRequests::BaseService
extend ::Gitlab::Utils::Override
def initialize(project:, current_user: nil, params: {})
super
@target_branch_was_deleted = @params.delete(:... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::UpdateService, :mailer, feature_category: :code_review_workflow do
include ProjectForksHelper
let(:group) { create(:group, :public) }
let(:project) { create(:project, :private, :repository, group: group) }
let(:user) { create(:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class MergeabilityCheckBatchService
def initialize(merge_requests, user)
@merge_requests = merge_requests
@user = user
end
def execute
return unless merge_requests.present?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MergeabilityCheckBatchService, feature_category: :code_review_workflow do
describe '#execute' do
subject { described_class.new(merge_requests, user).execute }
let(:merge_requests) { [] }
let_it_be(:user) { create(:user) }... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class RefreshService < MergeRequests::BaseService
include Gitlab::Utils::StrongMemoize
attr_reader :push
def execute(oldrev, newrev, ref)
@push = Gitlab::Git::Push.new(@project, oldrev, newrev... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::RefreshService, feature_category: :code_review_workflow do
include ProjectForksHelper
include UserHelpers
let(:project) { create(:project, :repository) }
let(:user) { create(:user) }
let(:service) { described_class }
descr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class ExecuteApprovalHooksService < MergeRequests::BaseService
def execute(merge_request)
# Only one approval is required for a merge request to be approved
notification_service.async.approve_mr(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::ExecuteApprovalHooksService, feature_category: :code_review_workflow do
let(:user) { create(:user) }
let(:merge_request) { create(:merge_request) }
let(:project) { merge_request.project }
subject(:service) { described_class.new... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class CreateService < MergeRequests::BaseService
def execute
set_projects!
set_default_attributes!
merge_request = MergeRequest.new
merge_request.target_project = @project
merg... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CreateService, :clean_gitlab_redis_shared_state, feature_category: :code_review_workflow do
include ProjectForksHelper
include AfterNextHelpers
let(:project) { create(:project, :repository) }
let(:user) { create(:user) }
let(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class HandleAssigneesChangeService < MergeRequests::BaseService
def async_execute(merge_request, old_assignees, options = {})
MergeRequests::HandleAssigneesChangeWorker
.perform_async(
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::HandleAssigneesChangeService, feature_category: :code_review_workflow do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:user) { create(:user) }
let_it_be(:assignee) { create(:user) }
let_it_be_with_reload(:merg... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
class AddContextService < MergeRequests::BaseService
def execute
return error("You are not allowed to access the requested resource", 403) unless current_user&.can?(:update_merge_request, merge_request... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::AddContextService, feature_category: :code_review_workflow do
let(:project) { create(:project, :repository) }
let(:admin) { create(:admin) }
let(:merge_request) { create(:merge_request, source_project: project, target_project: pro... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
# CreateRefService creates or overwrites a ref under "refs/merge-requests/"
# with a commit for the merged result.
class CreateRefService
include Gitlab::Utils::StrongMemoize
CreateRefError = Class.... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::CreateRefService, feature_category: :merge_trains do
using RSpec::Parameterized::TableSyntax
describe '#execute' do
let_it_be_with_reload(:project) { create(:project, :empty_repo) }
let_it_be(:user) { project.creator }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
# MergeService class
#
# Do git merge and in case of success
# mark merge request as merged and execute all hooks and notifications
# Executed when you do merge via GitLab UI
#
class MergeService < M... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MergeService, feature_category: :code_review_workflow do
include ExclusiveLeaseHelpers
let_it_be(:user) { create(:user) }
let_it_be(:user2) { create(:user) }
let(:merge_request) { create(:merge_request, :simple, author: user2,... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class RunChecksService
include Gitlab::Utils::StrongMemoize
def initialize(merge_request:, params:)
@merge_request = merge_request
@params = params
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::RunChecksService, :clean_gitlab_redis_cache, feature_category: :code_review_workflow do
let(:checks) { MergeRequest.all_mergeability_checks }
let(:execute_all) { false }
subject(:run_checks) { described_class.new(me... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class DetailedMergeStatusService
include ::Gitlab::Utils::StrongMemoize
def initialize(merge_request:)
@merge_request = merge_request
end
def execute
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::MergeRequests::Mergeability::DetailedMergeStatusService, feature_category: :code_review_workflow do
subject(:detailed_merge_status) { described_class.new(merge_request: merge_request).execute }
context 'when merge status is cannot_be_merged_rec... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckDraftStatusService < CheckBaseService
identifier :draft_status
description 'Checks whether the merge request is draft'
def execute
if merge_request.d... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckDraftStatusService, feature_category: :code_review_workflow do
subject(:check_draft_status) { described_class.new(merge_request: merge_request, params: params) }
let_it_be(:merge_request) { build(:merge_request) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckRebaseStatusService < CheckBaseService
identifier :need_rebase
description 'Checks whether the merge request needs to be rebased'
def execute
return ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckRebaseStatusService, feature_category: :code_review_workflow do
subject(:check_rebase_status) { described_class.new(merge_request: merge_request, params: params) }
let_it_be(:project) { build(:project) }
let_it... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class Logger
include Gitlab::Utils::StrongMemoize
def initialize(merge_request:, destination: Gitlab::AppJsonLogger)
@destination = destination
@merge_request... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::Logger, :request_store, feature_category: :code_review_workflow do
let_it_be(:merge_request) { create(:merge_request) }
subject(:logger) { described_class.new(merge_request: merge_request) }
let(:caller_id) { 'a' }... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckCiStatusService < CheckBaseService
identifier :ci_must_pass
description 'Checks whether CI has passed'
def execute
return inactive unless merge_reque... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckCiStatusService, feature_category: :code_review_workflow do
subject(:check_ci_status) { described_class.new(merge_request: merge_request, params: params) }
let_it_be(:project) { build(:project) }
let_it_be(:mer... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckOpenStatusService < CheckBaseService
identifier :not_open
description 'Checks whether the merge request is open'
def execute
if merge_request.open?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckOpenStatusService, feature_category: :code_review_workflow do
subject(:check_open_status) { described_class.new(merge_request: merge_request, params: {}) }
let(:merge_request) { build(:merge_request) }
it_beha... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckBrokenStatusService < CheckBaseService
identifier :broken_status
description 'Checks whether the merge request is broken'
def execute
if merge_request... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckBrokenStatusService, feature_category: :code_review_workflow do
subject(:check_broken_status) { described_class.new(merge_request: merge_request, params: {}) }
let(:merge_request) { build(:merge_request) }
it_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckConflictStatusService < CheckBaseService
identifier :conflict
description 'Checks whether the merge request has a conflict'
def execute
if merge_requ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckConflictStatusService, feature_category: :code_review_workflow do
subject(:check_conflict_status) { described_class.new(merge_request: merge_request, params: {}) }
let(:merge_request) { build(:merge_request) }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckDiscussionsStatusService < CheckBaseService
identifier :discussions_not_resolved
description 'Checks whether the merge request has open discussions'
def execu... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckDiscussionsStatusService, feature_category: :code_review_workflow do
subject(:check_discussions_status) { described_class.new(merge_request: merge_request, params: params) }
let_it_be(:project) { build(:project) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Mergeability
class CheckBaseService
attr_reader :merge_request, :params
class_attribute :identifier, :description
def self.identifier(new_identifier)
self.identifier = new_i... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Mergeability::CheckBaseService, feature_category: :code_review_workflow do
subject(:check_base_service) { described_class.new(merge_request: merge_request, params: params) }
let(:merge_request) { double }
let(:params) { double }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module MergeStrategies
# FromSourceBranch performs a git merge from a merge request's source branch
# to the target branch, including a squash if needed.
class FromSourceBranch
include Gitlab::... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::MergeStrategies::FromSourceBranch, feature_category: :code_review_workflow do
let_it_be(:user) { create(:user) }
let_it_be(:user2) { create(:user) }
let(:merge_request) { create(:merge_request, :simple, author: user2, assignees: ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Conflicts
class ResolveService < MergeRequests::Conflicts::BaseService
def execute(current_user, params)
conflicts = Gitlab::Conflict::FileCollection.new(merge_request)
conflict... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Conflicts::ResolveService, feature_category: :code_review_workflow do
include ProjectForksHelper
let(:user) { create(:user) }
let(:project) { create(:project, :public, :repository) }
let(:forked_project) do
fork_project_wit... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module Conflicts
class ListService < MergeRequests::Conflicts::BaseService
delegate :file_for_path, :to_json, to: :conflicts
def can_be_resolved_by?(user)
return false unless merge_reque... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::Conflicts::ListService, feature_category: :code_review_workflow do
describe '#can_be_resolved_in_ui?' do
def create_merge_request(source_branch, target_branch = 'conflict-start')
create(:merge_request, source_branch: source_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Captcha
##
# Encapsulates logic of checking captchas.
#
class CaptchaVerificationService
include Recaptcha::Adapters::ControllerMethods
# Currently the only value that is used out of the request by the reCAPTCH... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Captcha::CaptchaVerificationService, feature_category: :team_planning do
describe '#execute' do
let(:captcha_response) { 'abc123' }
let(:fake_ip) { '1.2.3.4' }
let(:spam_params) do
::Spam::SpamParams.new(
captcha_response: ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module JiraImport
class ServerUsersMapperService < UsersMapperService
private
def url
"/rest/api/2/user/search?username=''&maxResults=#{MAX_USERS}&startAt=#{start_at.to_i}"
end
def jira_user_id(jira_user)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe JiraImport::ServerUsersMapperService, feature_category: :integrations do
let(:start_at) { 7 }
let(:url) { "/rest/api/2/user/search?username=''&maxResults=50&startAt=#{start_at}" }
let_it_be(:user_1) { create(:user, username: 'randomuser', name:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module JiraImport
class CloudUsersMapperService < UsersMapperService
private
def url
"/rest/api/2/users?maxResults=#{MAX_USERS}&startAt=#{start_at.to_i}"
end
def jira_user_id(jira_user)
jira_user['accou... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe JiraImport::CloudUsersMapperService, feature_category: :integrations do
let(:start_at) { 7 }
let(:url) { "/rest/api/2/users?maxResults=50&startAt=#{start_at}" }
let_it_be(:user_1) { create(:user, username: 'randomuser', name: 'USER-name1', emai... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module JiraImport
class UsersImporter
def initialize(user, project, start_at)
@project = project
@start_at = start_at
@user = user
end
def execute
Gitlab::JiraImport.validate_project_settings!(pr... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe JiraImport::UsersImporter, feature_category: :integrations do
include JiraIntegrationHelpers
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:project, reload: true) { create(:project, group: group) }
let_it... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module JiraImport
class StartImportService
attr_reader :user, :project, :jira_project_key, :users_mapping
def initialize(user, project, jira_project_key, users_mapping)
@user = user
@project = project
@jir... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe JiraImport::StartImportService, feature_category: :integrations do
include JiraIntegrationHelpers
let_it_be(:user) { create(:user) }
let_it_be(:project, reload: true) { create(:project) }
let(:key) { 'KEY' }
let(:mapping) do
[
{ ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Tags
class DestroyService < BaseService
def execute(tag_name)
repository = project.repository
tag = repository.find_tag(tag_name)
unless tag
return error('No such tag', 404)
end
if ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Tags::DestroyService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
let(:user) { create(:user) }
let(:service) { described_class.new(project, user) }
des... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Tags
class CreateService < BaseService
def execute(tag_name, target, message)
return error('Target is empty', 400) if target.blank?
valid_tag = Gitlab::GitRefValidator.validate(tag_name)
return error('T... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Tags::CreateService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
let(:user) { create(:user) }
let(:service) { described_class.new(project, user) }
desc... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Search
class GlobalService
include Search::Filter
include Gitlab::Utils::StrongMemoize
DEFAULT_SCOPE = 'projects'
ALLOWED_SCOPES = %w[projects issues merge_requests milestones users].freeze
attr_accessor... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Search::GlobalService, feature_category: :global_search do
let_it_be(:user) { create(:user) }
let_it_be(:internal_user) { create(:user) }
let_it_be(:found_project) { create(:project, :private, name: 'searchable_project') }
let_it_be(:unfou... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Search
class SnippetService < Search::GlobalService
def execute
Gitlab::SnippetSearchResults.new(current_user, params[:search])
end
def scope
@scope ||= 'snippet_titles'
end
end
end
Search::Sni... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Search::SnippetService, feature_category: :global_search do
let_it_be(:author) { create(:author) }
let_it_be(:project) { create(:project, :public) }
let_it_be(:public_snippet) { create(:snippet, :public, title: 'Foo Bar Title') }
let_it_be(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Search
class GroupService < Search::GlobalService
attr_accessor :group
def initialize(user, group, params)
super(user, params)
@group = group
end
def execute
Gitlab::GroupSearchResults.new... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Search::GroupService, feature_category: :global_search do
shared_examples_for 'group search' do
context 'finding projects by name' do
let(:user) { create(:user) }
let(:term) { "Project Name" }
let(:nested_group) { create(:group... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issuable
class DestroyLabelLinksService
BATCH_SIZE = 100
def initialize(target_id, target_type)
@target_id = target_id
@target_type = target_type
end
def execute
inner_query =
Label... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::DestroyLabelLinksService, feature_category: :team_planning do
describe '#execute' do
context 'when target is an Issue' do
let_it_be(:target) { create(:issue) }
it_behaves_like 'service deleting label links of an issuable'
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issuable
class CommonSystemNotesService < ::BaseProjectService
attr_reader :issuable
def execute(issuable, old_labels: [], old_milestone: nil, is_update: true)
@issuable = issuable
# We disable touch so ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::CommonSystemNotesService, feature_category: :team_planning do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let(:issuable) { create(:issue, project: project) }
shared_examples 'system note for issuable... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issuable
class DestroyService < IssuableBaseService
# TODO: this is to be removed once we get to rename the IssuableBaseService project param to container
def initialize(container:, current_user: nil, params: {})
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::DestroyService, feature_category: :team_planning do
let(:user) { create(:user) }
let(:group) { create(:group, :public) }
let(:project) { create(:project, :public, group: group) }
subject(:service) { described_class.new(container: pr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# This service return notes grouped by discussion ID and paginated per discussion.
# System notes also have a discussion ID assigned including Synthetic system notes.
module Issuable
class DiscussionsListService
include Gitlab::... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::DiscussionsListService, feature_category: :team_planning do
let_it_be(:current_user) { create(:user) }
let_it_be(:group) { create(:group, :private) }
let_it_be(:project) { create(:project, :repository, :private, group: group) }
let_i... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# This follows the rules specified in the specs.
# See spec/requests/api/graphql/mutations/merge_requests/set_assignees_spec.rb
module Issuable
class ProcessAssignees
def initialize(assignee_ids:, add_assignee_ids:, remove_assi... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::ProcessAssignees, feature_category: :team_planning do
describe '#execute' do
it 'returns assignee_ids when add_assignee_ids and remove_assignee_ids are not specified' do
process = described_class.new(
assignee_ids: %w[5 7... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issuable
class BulkUpdateService
include Gitlab::Allowable
attr_accessor :parent, :current_user, :params
def initialize(parent, user = nil, params = {})
@parent = parent
@current_user = user
@p... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::BulkUpdateService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :repository, namespace: user.namespace) }
def bulk_update(issuables, extra_params = {})
bulk_updat... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issuable
module ImportCsv
class BaseService < ::ImportCsv::BaseService
extend ::Gitlab::Utils::Override
private
override :attributes_for
def attributes_for(row)
{
title: row[:ti... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::ImportCsv::BaseService, feature_category: :importers do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:csv_io) { double }
let(:importer_kla... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issuable
module Callbacks
class Milestone < Base
ALLOWED_PARAMS = %i[milestone milestone_id skip_milestone_email].freeze
def after_initialize
params[:milestone_id] = nil if excluded_in_new_type?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issuable::Callbacks::Milestone, feature_category: :team_planning do
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, :private, group: group) }
let_it_be(:project_milestone) { create(:milestone, project: project) }
le... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Namespaces
class StatisticsRefresherService
RefresherError = Class.new(StandardError)
def execute(root_namespace)
root_namespace = root_namespace.root_ancestor # just in case the true root isn't passed
ro... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Namespaces::StatisticsRefresherService, '#execute', feature_category: :groups_and_projects do
let(:group) { create(:group) }
let(:subgroup) { create(:group, parent: group) }
let(:projects) { create_list(:project, 5, namespace: group) }
let(:se... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Namespaces
module PackageSettings
class UpdateService < BaseContainerService
include Gitlab::Utils::StrongMemoize
ALLOWED_ATTRIBUTES = %i[maven_duplicates_allowed
maven_duplicate... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Namespaces::PackageSettings::UpdateService, feature_category: :package_registry do
using RSpec::Parameterized::TableSyntax
let_it_be_with_reload(:namespace) { create(:group) }
let_it_be(:user) { create(:user) }
let_it_be(:params) { {} }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module TestHooks
class ProjectService < TestHooks::BaseService
include Integrations::ProjectTestData
include Gitlab::Utils::StrongMemoize
attr_writer :project
def project
@project ||= hook.project
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe TestHooks::ProjectService, feature_category: :code_testing do
include AfterNextHelpers
let(:current_user) { create(:user) }
describe '#execute' do
let_it_be(:project) { create(:project, :repository) }
let(:hook) { create(:project_hook... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module TestHooks
class SystemService < TestHooks::BaseService
include Gitlab::Utils::StrongMemoize
private
def data
strong_memoize(:data) do
case trigger
when 'push_events', 'tag_push_events'
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe TestHooks::SystemService, feature_category: :code_testing do
include AfterNextHelpers
describe '#execute' do
let_it_be(:project) { create(:project, :repository) }
let(:hook) { create(:system_hook) }
let(:service) { described_class... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# GroupMentionService class
#
# Used for sending group mention notifications
#
# Ex.
# Integrations::GroupMentionService.new(mentionable, hook_data: data, is_confidential: true).execute
#
module Integrations
class GroupMentionServ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Integrations::GroupMentionService, feature_category: :integrations do
subject(:execute) { described_class.new(mentionable, hook_data: hook_data, is_confidential: is_confidential).execute }
let_it_be(:user) { create(:user) }
let_it_be(:group) { ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Integrations
class SlackOptionService
UnknownOptionError = Class.new(StandardError)
OPTIONS = {
'assignee' => SlackOptions::UserSearchHandler,
'labels' => SlackOptions::LabelSearchHandler
}.freeze
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Integrations::SlackOptionService, feature_category: :integrations do
describe '#execute' do
subject(:execute) { described_class.new(params).execute }
let_it_be(:slack_installation) { create(:slack_integration) }
let_it_be(:user) { creat... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.