INSTRUCTION stringlengths 202 35.5k | RESPONSE stringlengths 75 161k |
|---|---|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
# This class serves as more of an app-wide way we add/create members
# All roads to add members should take this path.
class CreatorService
class << self
def parsed_access_level(access_level)
acc... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::CreatorService, feature_category: :groups_and_projects do
let_it_be(:source, reload: true) { create(:group, :public) }
let_it_be(:member_type) { GroupMember }
let_it_be(:user) { create(:user) }
let_it_be(:current_user) { create(:user)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class InviteService < Members::CreateService
extend ::Gitlab::Utils::Override
def initialize(*args)
super
@invites += parsed_emails
@errors = {}
end
private
alias_method :for... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::InviteService, :aggregate_failures, :clean_gitlab_redis_shared_state, :sidekiq_inline,
feature_category: :groups_and_projects do
let_it_be(:project, reload: true) { create(:project) }
let_it_be(:user) { project.first_owner }
let_it_be... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class DestroyService < Members::BaseService
include Gitlab::ExclusiveLeaseHelpers
def execute(
member,
skip_authorization: false,
skip_subresources: false,
unassign_issuables: false,
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::DestroyService, feature_category: :groups_and_projects do
let(:current_user) { create(:user) }
let(:member_user) { create(:user) }
let(:group) { create(:group, :public) }
let(:group_project) { create(:project, :public, group: group) }... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class RequestAccessService < Members::BaseService
def execute(source)
raise Gitlab::Access::AccessDeniedError unless can_request_access?(source)
source.members.create(
access_level: Gitlab::Ac... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::RequestAccessService, feature_category: :groups_and_projects do
let(:user) { create(:user) }
shared_examples 'a service raising Gitlab::Access::AccessDeniedError' do
it 'raises Gitlab::Access::AccessDeniedError' do
expect { des... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class UpdateService < Members::BaseService
# @param members [Member, Array<Member>]
# returns the updated member(s)
def execute(members, permission: :update)
members = Array.wrap(members)
old_... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::UpdateService, feature_category: :groups_and_projects do
let_it_be(:project) { create(:project, :public) }
let_it_be(:group) { create(:group, :public) }
let_it_be(:current_user) { create(:user) }
let_it_be(:member_user1) { create(:use... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class CreateService < Members::BaseService
BlankInvitesError = Class.new(StandardError)
TooManyInvitesError = Class.new(StandardError)
MembershipLockedError = Class.new(StandardError)
DEFAULT_INVITE_L... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::CreateService, :aggregate_failures, :clean_gitlab_redis_cache, :clean_gitlab_redis_shared_state, :sidekiq_inline,
feature_category: :groups_and_projects do
let_it_be(:source, reload: true) { create(:project) }
let_it_be(:user) { create(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class ImportProjectTeamService < BaseService
ImportProjectTeamForbiddenError = Class.new(StandardError)
def initialize(*args)
super
@errors = {}
end
def execute
check_target_and_so... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::ImportProjectTeamService, feature_category: :groups_and_projects do
describe '#execute' do
let_it_be(:source_project) { create(:project) }
let_it_be(:target_project) { create(:project) }
let_it_be(:user) { create(:user) }
l... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class ApproveAccessRequestService < Members::BaseService
def execute(access_requester, skip_authorization: false, skip_log_audit_event: false)
validate_access!(access_requester) unless skip_authorization
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::ApproveAccessRequestService, feature_category: :groups_and_projects do
let(:project) { create(:project, :public) }
let(:group) { create(:group, :public) }
let(:current_user) { create(:user) }
let(:access_requester_user) { create(:user... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
module Projects
class CreatorService < Members::CreatorService
class << self
def cannot_manage_owners?(source, current_user)
!Ability.allowed?(current_user, :manage_owners, source)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::Projects::CreatorService, feature_category: :groups_and_projects do
let_it_be(:source, reload: true) { create(:project, :public) }
let_it_be(:source2, reload: true) { create(:project, :public) }
let_it_be(:user) { create(:user) }
des... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
module Groups
class CreatorService < Members::CreatorService
class << self
def cannot_manage_owners?(source, current_user)
source.max_member_access_for_user(current_user) < Gitlab::Access::... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::Groups::CreatorService, feature_category: :groups_and_projects do
let_it_be(:source, reload: true) { create(:group, :public) }
let_it_be(:source2, reload: true) { create(:group, :public) }
let_it_be(:user) { create(:user) }
describe ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
class ProcessPrometheusAlertService
extend ::Gitlab::Utils::Override
include ::AlertManagement::AlertProcessing
include ::AlertManagement::Responses
def initialize(project, payload, integratio... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::ProcessPrometheusAlertService, feature_category: :incident_management do
let_it_be(:project, reload: true) { create(:project, :repository) }
let(:service) { described_class.new(project, payload) }
describe '#execute' do
in... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
class CreateAlertIssueService
include Gitlab::Utils::StrongMemoize
DEFAULT_ALERT_TITLE = ::Gitlab::AlertManagement::Payload::Generic::DEFAULT_TITLE
DEFAULT_INCIDENT_TITLE = 'New: Incident'
# ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::CreateAlertIssueService, feature_category: :incident_management do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:payload) do
{
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
module HttpIntegrations
class DestroyService
# @param integration [AlertManagement::HttpIntegration]
# @param current_user [User]
def initialize(integration, current_user)
@integr... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::HttpIntegrations::DestroyService, feature_category: :incident_management do
let_it_be(:user_with_permissions) { create(:user) }
let_it_be(:user_without_permissions) { create(:user) }
let_it_be(:project) { create(:project) }
l... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
module HttpIntegrations
class UpdateService < BaseService
# @param integration [AlertManagement::HttpIntegration]
# @param current_user [User]
# @param params [Hash]
def initialize(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::HttpIntegrations::UpdateService, feature_category: :incident_management do
let_it_be(:user_with_permissions) { create(:user) }
let_it_be(:user_without_permissions) { create(:user) }
let_it_be(:project) { create(:project) }
let... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
module HttpIntegrations
class CreateService < BaseService
def execute
return error_no_permissions unless allowed?
::AlertManagement::HttpIntegration.transaction do
integrat... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::HttpIntegrations::CreateService, feature_category: :incident_management do
let_it_be(:user_with_permissions) { create(:user) }
let_it_be(:user_without_permissions) { create(:user) }
let_it_be_with_reload(:project) { create(:proj... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
module MetricImages
class UploadService < BaseService
attr_reader :alert, :file, :url, :url_text, :metric
def initialize(alert, current_user, params = {})
super
@alert = alert... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::MetricImages::UploadService, feature_category: :metrics do
subject(:service) { described_class.new(alert, current_user, params) }
let_it_be_with_refind(:project) { create(:project) }
let_it_be_with_refind(:alert) { create(:aler... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
module Alerts
class UpdateService < ::BaseProjectService
include Gitlab::Utils::StrongMemoize
# @param alert [AlertManagement::Alert]
# @param current_user [User]
# @param params [... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::Alerts::UpdateService, feature_category: :incident_management do
let_it_be(:user_with_permissions) { create(:user) }
let_it_be(:other_user_with_permissions) { create(:user) }
let_it_be(:user_without_permissions) { create(:user) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AlertManagement
module Alerts
module Todo
class CreateService
# @param alert [AlertManagement::Alert]
# @param current_user [User]
def initialize(alert, current_user)
@alert = alert... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AlertManagement::Alerts::Todo::CreateService, feature_category: :incident_management do
let_it_be(:user) { create(:user) }
let_it_be(:alert) { create(:alert_management_alert) }
let(:current_user) { user }
describe '#execute' do
subject(:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Suggestions
class OutdateService
def execute(merge_request)
# rubocop: disable CodeReuse/ActiveRecord
suggestions = merge_request.suggestions.active.includes(:note)
suggestions.find_in_batches(batch_siz... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Suggestions::OutdateService, feature_category: :code_suggestions do
describe '#execute' do
let(:merge_request) { create(:merge_request) }
let(:project) { merge_request.target_project }
let(:user) { merge_request.author }
let(:file_pa... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Suggestions
class ApplyService < ::BaseService
def initialize(current_user, *suggestions, message: nil)
@current_user = current_user
@message = message
@suggestion_set = Gitlab::Suggestions::SuggestionSe... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Suggestions::ApplyService, feature_category: :code_suggestions do
include ProjectForksHelper
def build_position(**optional_args)
args = { old_path: "files/ruby/popen.rb",
new_path: "files/ruby/popen.rb",
old_line: ni... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Suggestions
class CreateService
def initialize(note)
@note = note
end
def execute
return unless @note.supports_suggestion?
suggestions = Gitlab::Diff::SuggestionsParser.parse(
@note.not... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Suggestions::CreateService, feature_category: :code_suggestions do
let(:project_with_repo) { create(:project, :repository) }
let(:merge_request) do
create(
:merge_request,
source_project: project_with_repo,
target_project: pr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Mattermost
class CreateTeamService < ::BaseService
def initialize(group, current_user)
@group = group
@current_user = current_user
end
def execute
# The user that creates the team will be Team A... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Mattermost::CreateTeamService, feature_category: :integrations do
let(:user) { create(:user) }
let(:group) { create(:group) }
subject { described_class.new(group, user) }
it 'creates a team' do
expect_next_instance_of(::Mattermost::Team)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Branches
class ValidateNewService < BaseService
def initialize(project)
@project = project
end
def execute(branch_name, force: false)
return error('Branch name is invalid') unless valid_name?(branch_n... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Branches::ValidateNewService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
subject(:service) { described_class.new(project) }
describe '#execute' do
context 'validation' do
it 'returns ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Branches
class DeleteMergedService < BaseService
def async_execute
DeleteMergedBranchesWorker.perform_async(project.id, current_user.id)
end
def execute
raise Gitlab::Access::AccessDeniedError unless ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Branches::DeleteMergedService, feature_category: :source_code_management do
include ProjectForksHelper
subject(:service) { described_class.new(project, project.first_owner) }
let(:project) { create(:project, :repository) }
describe '#execut... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Branches
class DivergingCommitCountsService
def initialize(repository)
@repository = repository
@cache = Gitlab::RepositoryCache.new(repository)
end
def call(branch)
diverging_commit_counts(bran... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Branches::DivergingCommitCountsService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
describe '#call' do
let(:diverged_branch) { repository.find_branch(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Branches
class CreateService < BaseService
def initialize(project, user = nil, params = {})
super(project, user, params)
@errors = []
end
def execute(branch_name, ref, create_default_branch_if_empty:... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Branches::CreateService, :use_clean_rails_redis_caching, feature_category: :source_code_management do
subject(:service) { described_class.new(project, user) }
let_it_be(:project) { create(:project_empty_repo) }
let_it_be(:user) { create(:user) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Branches
class DeleteService < BaseService
def execute(branch_name)
repository = project.repository
branch = repository.find_branch(branch_name)
unless current_user.can?(:push_code, project)
ret... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Branches::DeleteService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
let(:user) { create(:user) }
subject(:service) { described_class.new(project, user) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module NamespaceSettings
class UpdateService
include ::Gitlab::Allowable
attr_reader :current_user, :group, :settings_params
def initialize(current_user, group, settings)
@current_user = current_user
@group... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe NamespaceSettings::UpdateService, feature_category: :groups_and_projects do
let(:user) { create(:user) }
let(:group) { create(:group) }
let(:settings) { {} }
subject(:service) { described_class.new(user, group, settings) }
describe "#execu... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ObjectStorage
class DeleteStaleDirectUploadsService < BaseService
MAX_EXEC_DURATION = 250.seconds.freeze
def initialize; end
def execute
total_pending_entries = ObjectStorage::PendingDirectUpload.count
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ObjectStorage::DeleteStaleDirectUploadsService, :direct_uploads, :clean_gitlab_redis_shared_state, feature_category: :shared do
let(:service) { described_class.new }
describe '#execute', :aggregate_failures do
subject(:execute_result) { servi... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
class AllowedTargetFilterService
include Gitlab::Allowable
def initialize(todos, current_user)
@todos = todos
@current_user = current_user
end
def execute
Preloaders::UserMaxAccessLev... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::AllowedTargetFilterService, feature_category: :team_planning do
include DesignManagementTestHelpers
let_it_be(:authorized_group) { create(:group, :private) }
let_it_be(:authorized_project) { create(:project, group: authorized_group) }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
class UnauthorizedFeaturesService < ::Todos::Destroy::BaseService
attr_reader :project_id, :user_id
BATCH_SIZE = 1000
def initialize(project_id, user_id = nil)
@project_id ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::UnauthorizedFeaturesService, feature_category: :team_planning do
let_it_be(:project, reload: true) { create(:project, :public, :repository) }
let_it_be(:issue) { create(:issue, project: project) }
let_it_be(:mr) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
class DestroyedIssuableService
BATCH_SIZE = 100
# Since we are moving towards work items, in some instances we create todos with
# `target_type: WorkItem` in other instances we stil... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::DestroyedIssuableService, feature_category: :team_planning do
describe '#execute' do
let_it_be(:user) { create(:user) }
subject { described_class.new(target.id, target.class.name).execute }
context 'when target is merge... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
# Service class for deleting todos that belongs to a deleted/archived design.
class DesignService
attr_reader :design_ids
def initialize(design_ids)
@design_ids = design_ids
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::DesignService, feature_category: :design_management do
let_it_be(:user) { create(:user) }
let_it_be(:user_2) { create(:user) }
let_it_be(:design) { create(:design) }
let_it_be(:design_2) { create(:design) }
let_it_be(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
class GroupPrivateService < ::Todos::Destroy::BaseService
extend ::Gitlab::Utils::Override
attr_reader :group
def initialize(group_id)
@group = Group.find_by_id(group_id)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::GroupPrivateService, feature_category: :team_planning do
let(:group) { create(:group, :public) }
let(:project) { create(:project, group: group) }
let(:user) { create(:user) }
let(:group_member) { create(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
class ProjectPrivateService < ::Todos::Destroy::BaseService
extend ::Gitlab::Utils::Override
attr_reader :project
def initialize(project_id)
@project = Project.find_by_id(p... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::ProjectPrivateService, feature_category: :team_planning do
let(:group) { create(:group, :public) }
let(:project) { create(:project, :public, group: group) }
let(:user) { create(:user) }
let(:project_me... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
class EntityLeaveService < ::Todos::Destroy::BaseService
extend ::Gitlab::Utils::Override
attr_reader :user, :entity
def initialize(user_id, entity_id, entity_type)
unless ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::EntityLeaveService, feature_category: :team_planning do
let_it_be(:user, reload: true) { create(:user) }
let_it_be(:user2, reload: true) { create(:user) }
let_it_be_with_refind(:group) { create(:group, :private) }
let_it_be(:pr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Todos
module Destroy
# Service class for deleting todos that belongs to confidential issues.
# It deletes todos for users that are not at least reporters, issue author or assignee.
#
# Accepts issue_id or proj... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Todos::Destroy::ConfidentialIssueService, feature_category: :team_planning do
let(:project) { create(:project, :public) }
let(:user) { create(:user) }
let(:author) { create(:user) }
let(:assignee) { create(:user)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Events
class DestroyService
BATCH_SIZE = 50
def initialize(project)
@project = project
end
def execute
loop do
count = delete_events_in_batches
break if count < BATCH_SIZE
e... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Events::DestroyService, feature_category: :user_profile do
subject(:service) { described_class.new(project) }
let_it_be(:project, reload: true) { create(:project, :repository) }
let_it_be(:another_project) { create(:project) }
let_it_be(:merg... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Events
class RenderService < BaseRenderer
def execute(events, atom_request: false)
notes = events.map(&:note).compact
render_notes(notes, atom_request)
end
private
def render_notes(notes, atom_r... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Events::RenderService, feature_category: :user_profile do
describe '#execute' do
let!(:note) { build(:note) }
let!(:event) { build(:event, target: note, project: note.project) }
let!(:user) { build(:user) }
context 'when the request... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
class FogbugzService < Import::BaseService
attr_reader :client, :params, :current_user
def execute(credentials)
url = credentials[:uri]
if blocked_url?(url)
return log_and_return_error("In... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::FogbugzService, feature_category: :importers do
let_it_be(:user) { create(:user) }
let(:base_uri) { "https://test:7990" }
let(:token) { "asdasd12345" }
let(:repo_id) { "fogbugz_id" }
let(:repo) { instance_double(Gitlab::FogbugzImpor... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
class PrepareService < ::BaseService
def execute
uploader = UploadService.new(project, params[:file]).execute
if uploader
enqueue_import(uploader.upload)
ServiceResponse.success(messag... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::PrepareService, feature_category: :importers do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let(:file) { double }
let(:upload_service) { double }
let(:uploader) { double }
let(:upload) { double }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
class ValidateRemoteGitEndpointService
# Validates if the remote endpoint is a valid GIT repository
# Only smart protocol is supported
# Validation rules are taken from https://git-scm.com/docs/http-protoco... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::ValidateRemoteGitEndpointService, feature_category: :importers do
include StubRequests
let_it_be(:base_url) { 'http://demo.host/path' }
let_it_be(:endpoint_url) { "#{base_url}/info/refs?service=git-upload-pack" }
let_it_be(:endpoint_e... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
class BitbucketServerService < Import::BaseService
attr_reader :client, :params, :current_user
def execute(credentials)
if blocked_url?
return log_and_return_error("Invalid URL: #{url}", :bad_req... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::BitbucketServerService, feature_category: :importers do
let_it_be(:user) { create(:user) }
let(:base_uri) { "https://test:7990" }
let(:token) { "asdasd12345" }
let(:secret) { "sekrettt" }
let(:project_key) { 'TES' }
let(:repo_slug... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
class GithubService < Import::BaseService
include ActiveSupport::NumberHelper
include Gitlab::Utils::StrongMemoize
attr_accessor :client
attr_reader :params, :current_user
def execute(access_param... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::GithubService, feature_category: :importers do
let_it_be(:user) { create(:user) }
let_it_be(:token) { 'complex-token' }
let_it_be(:access_params) do
{
github_access_token: 'github-complex-token',
additional_access_tokens:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# Creates a new project with an associated project export file to be imported
# The associated project export file might be associated with different strategies
# to acquire the file to be imported, the default file_acquisition_strate... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Import::GitlabProjects::CreateProjectService, :aggregate_failures, feature_category: :importers do
let(:fake_file_acquisition_strategy) do
Class.new do
attr_reader :errors
def initialize(...)
@errors = ActiveModel::Errors.... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
module GitlabProjects
module FileAcquisitionStrategies
class FileUpload
include ActiveModel::Validations
validate :uploaded_file
def initialize(params:, current_user: nil)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Import::GitlabProjects::FileAcquisitionStrategies::FileUpload, :aggregate_failures, feature_category: :importers do
let(:file) { UploadedFile.new(File.join('spec', 'features', 'projects', 'import_export', 'test_project_export.tar.gz')) }
descri... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
module GitlabProjects
module FileAcquisitionStrategies
class RemoteFileS3
include ActiveModel::Validations
include Gitlab::Utils::StrongMemoize
def self.allow_local_requests?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Import::GitlabProjects::FileAcquisitionStrategies::RemoteFileS3, :aggregate_failures, feature_category: :importers do
let(:region_name) { 'region_name' }
let(:bucket_name) { 'bucket_name' }
let(:file_key) { 'file_key' }
let(:access_key_id) {... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
module GitlabProjects
module FileAcquisitionStrategies
class RemoteFile
include ActiveModel::Validations
def self.allow_local_requests?
::Gitlab::CurrentSettings.allow_local_request... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Import::GitlabProjects::FileAcquisitionStrategies::RemoteFile, :aggregate_failures, feature_category: :importers do
let(:remote_url) { 'https://external.file.path/file.tar.gz' }
let(:params) { { remote_import_url: remote_url } }
subject { des... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
module Github
class GistsImportService < ::BaseService
def initialize(user, client, params)
@current_user = user
@params = params
@client = client
end
def execute
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::Github::GistsImportService, feature_category: :importers do
subject(:import) { described_class.new(user, client, params) }
let_it_be(:user) { create(:user) }
let(:params) { { github_access_token: 'token' } }
let(:import_status) { inst... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
module Github
class CancelProjectImportService < ::BaseService
def execute
return error('Not Found', :not_found) unless authorized_to_read?
return error('Unauthorized access', :forbidden) unle... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::Github::CancelProjectImportService, feature_category: :importers do
subject(:import_cancel) { described_class.new(project, project.owner) }
let_it_be(:user) { create(:user) }
let_it_be_with_reload(:project) { create(:project, :import_st... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Import
module Github
module Notes
class CreateService < ::Notes::CreateService
# Github does not have support to quick actions in notes (like /assign)
# Therefore, when importing notes we skip the qu... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Import::Github::Notes::CreateService, feature_category: :importers do
it 'does not support quick actions' do
project = create(:project, :repository)
user = create(:user)
merge_request = create(:merge_request, source_project: project)
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module QuickActions
class TargetService < BaseService
def execute(type, type_iid)
case type&.downcase
when 'workitem'
work_item(type_iid)
when 'issue'
issue(type_iid)
when 'mergerequest'
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe QuickActions::TargetService, feature_category: :team_planning do
let(:project) { create(:project) }
let(:user) { create(:user) }
let(:service) { described_class.new(project, user) }
before do
project.add_maintainer(user)
end
describe... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module QuickActions
class InterpretService < BaseService
include Gitlab::Utils::StrongMemoize
include Gitlab::QuickActions::Dsl
include Gitlab::QuickActions::IssueActions
include Gitlab::QuickActions::IssuableActions... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe QuickActions::InterpretService, feature_category: :team_planning do
include AfterNextHelpers
let_it_be(:group) { create(:group, :crm_enabled) }
let_it_be(:public_project) { create(:project, :public, group: group) }
let_it_be(:repository_proje... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class ExportCsvService < ExportCsv::BaseService
include Gitlab::Routing.url_helpers
include GitlabRoutingHelper
def initialize(relation, resource_parent, user = nil)
super(relation, resource_parent)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::ExportCsvService, :with_license, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, :public, group: group) }
let_it_be(:issue) { create(:is... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class ReferencedMergeRequestsService < Issues::BaseService
# rubocop: disable CodeReuse/ActiveRecord
def execute(issue)
referenced = referenced_merge_requests(issue)
closed_by = closed_by_merge_requ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::ReferencedMergeRequestsService, feature_category: :team_planning do
def create_referencing_mr(attributes = {})
create(:merge_request, attributes).tap do |merge_request|
create(:note, :system, project: project, noteable: issue, auth... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# This service fetches all branches containing the current issue's ID, except for
# those with a merge request open referencing the current issue.
module Issues
class RelatedBranchesService < Issues::BaseService
def execute(issu... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::RelatedBranchesService, feature_category: :team_planning do
let_it_be(:project) { create(:project, :repository, :public, public_builds: false) }
let_it_be(:developer) { create(:user) }
let_it_be(:issue) { create(:issue, project: project)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class ReopenService < Issues::BaseService
def execute(issue, skip_authorization: false)
return issue unless can_reopen?(issue, skip_authorization: skip_authorization)
if issue.reopen
event_serv... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::ReopenService, feature_category: :team_planning do
let(:project) { create(:project) }
let(:issue) { create(:issue, :closed, project: project) }
describe '#execute' do
context 'when user is not authorized to reopen issue' do
it... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class DuplicateService < Issues::BaseService
def execute(duplicate_issue, canonical_issue)
return if canonical_issue == duplicate_issue
return unless can?(current_user, :update_issue, duplicate_issue)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::DuplicateService, feature_category: :team_planning do
let(:user) { create(:user) }
let(:canonical_project) { create(:project) }
let(:duplicate_project) { create(:project) }
let(:canonical_issue) { create(:issue, project: canonical_pro... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class SetCrmContactsService < ::BaseProjectService
MAX_ADDITIONAL_CONTACTS = 6
# Replacing contacts by email is not currently supported
def execute(issue)
@issue = issue
@errors = []
ret... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::SetCrmContactsService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group, :crm_enabled) }
let_it_be(:project) { create(:project, group: create(:group, :crm_enabled, parent: group)) }... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class RelativePositionRebalancingService
UPDATE_BATCH_SIZE = 100
PREFETCH_ISSUES_BATCH_SIZE = 10_000
SMALLEST_BATCH_SIZE = 5
RETRIES_LIMIT = 3
TooManyConcurrentRebalances = Class.new(StandardError)... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::RelativePositionRebalancingService, :clean_gitlab_redis_shared_state, feature_category: :team_planning do
let_it_be(:project, reload: true) { create(:project, :repository_disabled, skip_disk_validation: true) }
let_it_be(:user) { project.c... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class BaseService < ::IssuableBaseService
extend ::Gitlab::Utils::Override
include IncidentManagement::UsageData
include IssueTypeHelpers
def hook_data(issue, action, old_associations: {})
hook_d... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::BaseService, feature_category: :team_planning do
describe '#constructor_container_arg' do
it { expect(described_class.constructor_container_arg("some-value")).to eq({ container: "some-value" }) }
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class MoveService < Issuable::Clone::BaseService
extend ::Gitlab::Utils::Override
MoveError = Class.new(StandardError)
def execute(issue, target_project)
@target_project = target_project
veri... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::MoveService, feature_category: :team_planning do
include DesignManagementTestHelpers
let_it_be(:user) { create(:user) }
let_it_be(:author) { create(:user) }
let_it_be(:title) { 'Some issue' }
let_it_be(:description) { "Some issue de... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class CloneService < Issuable::Clone::BaseService
CloneError = Class.new(StandardError)
def execute(issue, target_project, with_notes: false)
@target_project = target_project
@with_notes = with_not... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::CloneService, feature_category: :team_planning do
include DesignManagementTestHelpers
let_it_be(:user) { create(:user) }
let_it_be(:author) { create(:user) }
let_it_be(:title) { 'Some issue' }
let_it_be(:description) { "Some issue d... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class ReorderService < Issues::BaseService
include Gitlab::Utils::StrongMemoize
def execute(issue)
return false unless can?(current_user, :update_issue, issue)
return false unless move_between_ids
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::ReorderService, feature_category: :team_planning do
let_it_be(:user) { create_default(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:project, reload: true) { create(:project, namespace: group) }
shared_examples 'issues ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class PrepareImportCsvService < Import::PrepareService
extend ::Gitlab::Utils::Override
private
override :worker
def worker
ImportIssuesCsvWorker
end
override :success_message
def s... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::PrepareImportCsvService, feature_category: :team_planning do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let(:file) { double }
let(:upload_service) { double }
let(:uploader) { double }
let(:upload) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class ImportCsvService < Issuable::ImportCsv::BaseService
def execute
record_import_attempt
super
end
def email_results_to_user
Notify.import_issues_csv_email(user.id, project.id, result... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::ImportCsvService, feature_category: :team_planning do
let(:project) { create(:project) }
let(:user) { create(:user) }
let(:assignee) { create(:user, username: 'csv_assignee') }
let(:file) { fixture_file_upload('spec/fixtures/csv_comple... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class BuildService < Issues::BaseService
include ResolveDiscussions
def execute(initialize_callbacks: true)
filter_resolve_discussion_params
container_param = case container
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::BuildService, feature_category: :team_planning do
using RSpec::Parameterized::TableSyntax
let_it_be(:project) { create(:project, :repository) }
let_it_be(:developer) { create(:user) }
let_it_be(:reporter) { create(:user) }
let_it_be... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class CloseService < Issues::BaseService
# Closes the supplied issue if the current user is able to do so.
def execute(issue, commit: nil, notifications: true, system_note: true, skip_authorization: false)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::CloseService, feature_category: :team_planning do
let(:project) { create(:project, :repository) }
let(:delegated_project) { project.project_namespace.project }
let(:user) { create(:user, email: "user@example.com") }
let(:user2) { creat... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class AfterCreateService < Issues::BaseService
def execute(issue)
todo_service.new_issue(issue, current_user)
track_incident_action(current_user, issue, :incident_created)
end
end
end
Issues::Aft... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::AfterCreateService, feature_category: :team_planning do
include AfterNextHelpers
let_it_be(:project) { create(:project) }
let_it_be(:current_user) { create(:user) }
let_it_be(:assignee) { create(:user) }
let_it_be(:milestone) { crea... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class ZoomLinkService < Issues::BaseService
def initialize(container:, current_user:, params:)
super
@issue = params.fetch(:issue)
@added_meeting = ZoomMeeting.canonical_meeting(@issue)
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::ZoomLinkService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:issue) { create(:issue) }
let(:project) { issue.project }
let(:service) { described_class.new(container: project, current_user: user, p... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class UpdateService < Issues::BaseService
# NOTE: For Issues::UpdateService, we default perform_spam_check to false, because spam_checking is not
# necessary in many cases, and we don't want to require every ca... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::UpdateService, :mailer, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:user2) { create(:user) }
let_it_be(:user3) { create(:user) }
let_it_be(:guest) { create(:user) }
let_it_be(:group) { create(:gr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Issues
class CreateService < Issues::BaseService
include ResolveDiscussions
prepend RateLimitedService
include ::Services::ReturnServiceResponses
rate_limit key: :issues_create,
opts: { scope: [:project... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Issues::CreateService, feature_category: :team_planning do
include AfterNextHelpers
let_it_be(:group) { create(:group, :crm_enabled) }
let_it_be_with_reload(:project) { create(:project, :public, group: group) }
let_it_be(:user) { create(:user... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Pages
class DestroyDeploymentsService
def initialize(project, last_deployment_id = nil)
@project = project
@last_deployment_id = last_deployment_id
end
def execute
deployments_to_destroy = @proj... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Pages::DestroyDeploymentsService, feature_category: :pages do
let_it_be(:project) { create(:project) }
let!(:old_deployments) { create_list(:pages_deployment, 2, project: project) }
let!(:last_deployment) { create(:pages_deployment, project: pro... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Pages
class DeleteService < BaseService
def execute
PagesDeployment.deactivate_all(project)
# project.pages_domains.delete_all will just nullify project_id:
# > If no :dependent option is given, then it... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Pages::DeleteService, feature_category: :pages do
let_it_be(:admin) { create(:admin) }
let(:project) { create(:project, path: "my.project") }
let(:service) { described_class.new(project, admin) }
it 'marks pages as not deployed' do
creat... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Timelogs
class CreateService < Timelogs::BaseService
attr_accessor :issuable, :time_spent, :spent_at, :summary
def initialize(issuable, time_spent, spent_at, summary, user)
super(user)
@issuable = issuab... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Timelogs::CreateService, feature_category: :team_planning do
let_it_be(:author) { create(:user) }
let_it_be(:project) { create(:project, :public) }
let(:issuable) { nil }
let(:users_container) { project }
describe '#execute' do
subject... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Timelogs
class DeleteService < Timelogs::BaseService
attr_accessor :timelog
def initialize(timelog, user)
super(user)
@timelog = timelog
end
def execute
unless can?(current_user, :admin_ti... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Timelogs::DeleteService, feature_category: :team_planning do
let_it_be(:author) { create(:user) }
let_it_be(:project) { create(:project, :public) }
let_it_be(:issue) { create(:issue, project: project) }
let_it_be(:timelog) { create(:timelog, u... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ActivityPub
class InboxResolverService
attr_reader :subscription
def initialize(subscription)
@subscription = subscription
end
def execute
profile = subscriber_profile
unless profile.has_ke... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ActivityPub::InboxResolverService, feature_category: :integrations do
let_it_be(:project) { create(:project, :public) }
let_it_be_with_reload(:existing_subscription) { create(:activity_pub_releases_subscription, project: project) }
let(:service)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ActivityPub
class AcceptFollowService
MissingInboxURLError = Class.new(StandardError)
attr_reader :subscription, :actor
def initialize(subscription, actor)
@subscription = subscription
@actor = actor... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ActivityPub::AcceptFollowService, feature_category: :integrations do
let_it_be(:project) { create(:project, :public) }
let_it_be_with_reload(:existing_subscription) do
create(:activity_pub_releases_subscription, :inbox, project: project)
end... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ActivityPub
module Projects
class ReleasesUnfollowService < ReleasesSubscriptionService
def execute
unless subscriber_url
errors << "You need to provide an actor id for your unsubscribe activity"
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ActivityPub::Projects::ReleasesUnfollowService, feature_category: :release_orchestration do
let_it_be(:project) { create(:project, :public) }
let_it_be_with_reload(:existing_subscription) { create(:activity_pub_releases_subscription, project: proj... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ActivityPub
module Projects
class ReleasesFollowService < ReleasesSubscriptionService
def execute
unless subscriber_url
errors << "You need to provide an actor id for your subscriber"
ret... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ActivityPub::Projects::ReleasesFollowService, feature_category: :release_orchestration do
let_it_be(:project) { create(:project, :public) }
let_it_be_with_reload(:existing_subscription) { create(:activity_pub_releases_subscription, project: projec... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class TagPushService < ::BaseService
include ChangeParams
def execute
return unless Gitlab::Git.tag_ref?(ref)
project.repository.before_push_tag
TagHooksService.new(project, current_user, param... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::TagPushService, feature_category: :source_code_management do
include RepoHelpers
let(:user) { create(:user) }
let(:project) { create(:project, :repository) }
let(:service) { described_class.new(project, user, change: { oldrev: oldrev, ne... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class ProcessRefChangesService < BaseService
PIPELINE_PROCESS_LIMIT = 4
def execute
changes = params[:changes]
process_changes_by_action(:branch, changes.branch_changes)
process_changes_by_acti... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::ProcessRefChangesService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:user) { project.first_owner }
let(:params) { { changes: git_changes } }
subject { described_class.new(project, us... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class TagHooksService < ::Git::BaseHooksService
private
def hook_name
:tag_push_hooks
end
def limited_commits
[tag_commit].compact
end
def commits_count
limited_commits.count
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::TagHooksService, :service, feature_category: :source_code_management do
let(:user) { create(:user) }
let(:project) { create(:project, :repository) }
let(:oldrev) { Gitlab::Git::BLANK_SHA }
let(:newrev) { "8a2a6eb295bb170b34c24c76c49ed0e9... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class BaseHooksService < ::BaseService
include Gitlab::Utils::StrongMemoize
include ChangeParams
# The N most recent commits to process in a single push payload.
PROCESS_COMMIT_LIMIT = 100
def execut... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::BaseHooksService, feature_category: :source_code_management do
include RepoHelpers
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :repository) }
let(:oldrev) { Gitlab::Git::BLANK_SHA }
let(:newrev) { "8a2a6e... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class WikiPushService < ::BaseService
# Maximum number of change events we will process on any single push
MAX_CHANGES = 100
attr_reader :wiki
def initialize(wiki, current_user, params)
@wiki = wik... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::WikiPushService, services: true, feature_category: :wiki do
include RepoHelpers
let_it_be(:current_user) { create(:user) }
let_it_be(:key_id) { create(:key, user: current_user).shell_id }
let(:wiki) { create(:project_wiki, user: current... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class BranchHooksService < ::Git::BaseHooksService
extend ::Gitlab::Utils::Override
JIRA_SYNC_BATCH_SIZE = 20
JIRA_SYNC_BATCH_DELAY = 10.seconds
def execute
execute_branch_hooks
super.tap do... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::BranchHooksService, :clean_gitlab_redis_shared_state, feature_category: :source_code_management do
include RepoHelpers
include ProjectForksHelper
let(:project) { create(:project, :repository) }
let(:user) { project.creator }
let(:bran... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class BranchPushService < ::BaseService
include Gitlab::Access
include Gitlab::Utils::StrongMemoize
include ChangeParams
# This method will be called after each git update
# and only if the provided u... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::BranchPushService, :use_clean_rails_redis_caching, services: true, feature_category: :source_code_management do
include RepoHelpers
let_it_be(:user) { create(:user) }
let_it_be_with_refind(:project) { create(:project, :repository) }
let... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Git
class WikiPushService
class Change
include Gitlab::Utils::StrongMemoize
# @param [Wiki] wiki
# @param [Hash] change - must have keys `:oldrev` and `:newrev`
# @param [Gitlab::Git::RawDiffChang... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Git::WikiPushService::Change, feature_category: :source_code_management do
subject { described_class.new(project_wiki, change, raw_change) }
let(:project_wiki) { double('ProjectWiki') }
let(:raw_change) { double('RawChange', new_path: new_path,... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Onboarding
class ProgressService
class Async
attr_reader :namespace_id
def initialize(namespace_id)
@namespace_id = namespace_id
end
def execute(action:)
return unless Onboarding:... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Onboarding::ProgressService, feature_category: :onboarding do
describe '.async' do
let_it_be(:namespace) { create(:namespace) }
let_it_be(:action) { :git_pull }
subject(:execute_service) { described_class.async(namespace.id).execute(act... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PagesDomains
class CreateAcmeOrderService
attr_reader :pages_domain
def initialize(pages_domain)
@pages_domain = pages_domain
end
def execute
lets_encrypt_client = Gitlab::LetsEncrypt::Client.new... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PagesDomains::CreateAcmeOrderService, feature_category: :pages do
include LetsEncryptHelpers
let(:pages_domain) { create(:pages_domain) }
let(:challenge) { ::Gitlab::LetsEncrypt::Challenge.new(acme_challenge_double) }
let(:order_double) do
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PagesDomains
class RetryAcmeOrderService
attr_reader :pages_domain
def initialize(pages_domain)
@pages_domain = pages_domain
end
def execute
updated = pages_domain.with_lock do
next unles... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PagesDomains::RetryAcmeOrderService, feature_category: :pages do
let_it_be(:project) { create(:project) }
let(:domain) { create(:pages_domain, project: project, auto_ssl_enabled: true, auto_ssl_failed: true) }
let(:service) { described_class.n... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PagesDomains
class UpdateService < BaseService
def execute(domain)
return unless authorized?
return false unless domain.update(params)
publish_event(domain)
true
end
private
def au... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PagesDomains::UpdateService, feature_category: :pages do
let_it_be(:user) { create(:user) }
let_it_be(:pages_domain) { create(:pages_domain, :with_project) }
let(:params) do
attributes_for(:pages_domain, :with_trusted_chain).slice(:key, :ce... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PagesDomains
class ObtainLetsEncryptCertificateService
# time for processing validation requests for acme challenges
# 5-15 seconds is usually enough
CHALLENGE_PROCESSING_DELAY = 1.minute.freeze
# time LetsEn... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe PagesDomains::ObtainLetsEncryptCertificateService, feature_category: :pages do
include LetsEncryptHelpers
let(:pages_domain) { create(:pages_domain, :without_certificate, :without_key) }
let(:service) { described_class.new(pages_domain) }
be... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PagesDomains
class CreateService < BaseService
def execute
return unless authorized?
domain = project.pages_domains.create(params)
publish_event(domain) if domain.persisted?
domain
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::PagesDomains::CreateService, feature_category: :pages do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :in_subgroup) }
let(:domain) { 'new.domain.com' }
let(:attributes) { { domain: domain } }
subject(:service... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module PagesDomains
class DeleteService < BaseService
def execute(domain)
return unless authorized?
domain.destroy
publish_event(domain)
end
private
def authorized?
current_user.can?(:upda... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::PagesDomains::DeleteService, feature_category: :pages do
let_it_be(:user) { create(:user) }
let_it_be(:pages_domain) { create(:pages_domain, :with_project) }
let(:params) do
attributes_for(:pages_domain, :with_trusted_chain).slice(:key, :... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
#
# Concern that helps with getting an exclusive lease for running a block
# of code.
#
# `#try_obtain_lease` takes a block which will be run if it was able to
# obtain the lease. Implement `#lease_timeout` to configure the timeout
#... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ExclusiveLeaseGuard, :clean_gitlab_redis_shared_state, feature_category: :shared do
subject :subject_class do
Class.new do
include ExclusiveLeaseGuard
def self.name
'ExclusiveLeaseGuardTestClass'
end
def call(&b... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module RateLimitedService
extend ActiveSupport::Concern
RateLimitedNotSetupError = Class.new(StandardError)
class RateLimitedError < StandardError
def initialize(key:, rate_limiter:)
@key = key
@rate_limiter = ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe RateLimitedService, feature_category: :rate_limiting do
let(:key) { :issues_create }
let(:scope) { [:container, :current_user] }
let(:opts) { { scope: scope, users_allowlist: -> { [Users::Internal.support_bot.username] } } }
let(:rate_limiter)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AuditEventSaveType
SAVE_TYPES = {
database: 0b01,
stream: 0b10,
database_and_stream: 0b11
}.freeze
# def should_save_stream?(type)
# def should_save_database?(type)
[:database, :stream].each do |type|
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AuditEventSaveType, feature_category: :audit_events do
subject(:target) { Object.new.extend(described_class) }
describe '#should_save_database? and #should_save_stream?' do
using RSpec::Parameterized::TableSyntax
where(:query_method, :qu... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
module AssignsMergeParams
def self.included(klass)
raise "#{self} can not be included in #{klass} without implementing #current_user" unless klass.method_defined?(:current_user)
end
def assign... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe MergeRequests::AssignsMergeParams, feature_category: :code_review_workflow do
it 'raises an error when used from an instance that does not respond to #current_user' do
define_class = -> { Class.new { include MergeRequests::AssignsMergeParams }.n... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Services
# adapter for existing services over BaseServiceUtility - add error and
# success methods returning ServiceResponse objects
module ReturnServiceResponses
def error(message, http_status, pass_back: {})
S... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Services::ReturnServiceResponses, feature_category: :rate_limiting do
subject(:object) { Class.new { include Services::ReturnServiceResponses }.new }
let(:message) { 'a delivering message' }
let(:payload) { 'string payload' }
describe '#succ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.