INSTRUCTION stringlengths 202 35.5k | RESPONSE stringlengths 75 161k |
|---|---|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class DismissProjectCalloutService < DismissCalloutService
private
def callout
current_user.find_or_initialize_project_callout(params[:feature_name], params[:project_id])
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::DismissProjectCalloutService, feature_category: :user_management do
describe '#execute' do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }
let(:params) { { feature_name: feature_name, project_id: proje... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UnblockService < BaseService
def initialize(current_user)
@current_user = current_user
end
def execute(user)
if user.activate
after_unblock_hook(user)
ServiceResponse.succe... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UnblockService, feature_category: :user_management do
let_it_be(:current_user) { create(:admin) }
subject(:service) { described_class.new(current_user) }
describe '#execute' do
subject(:operation) { service.execute(user) }
cont... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UntrustService < BaseService
def initialize(current_user)
@current_user = current_user
end
def execute(user)
user.trusted_with_spam_attribute.delete
success
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UntrustService, feature_category: :user_management do
let_it_be(:current_user) { create(:admin) }
subject(:service) { described_class.new(current_user) }
describe '#execute' do
let(:user) { create(:user) }
subject(:operation) {... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class AssignedIssuesCountService < ::BaseCountService
def initialize(current_user:, max_limit: User::MAX_LIMIT_FOR_ASSIGNEED_ISSUES_COUNT)
@current_user = current_user
@max_limit = max_limit
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::AssignedIssuesCountService, :use_clean_rails_memory_store_caching,
feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:max_limit) { 10 }
let(:current_user) { user }
subject { described_class.new(current... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class RegistrationsBuildService < BuildService
extend ::Gitlab::Utils::Override
private
def signup_params
super + [:skip_confirmation]
end
override :assign_skip_confirmation_from_settings?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::RegistrationsBuildService, feature_category: :system_access do
describe '#execute' do
let(:base_params) { build_stubbed(:user).slice(:first_name, :last_name, :username, :email, :password) }
let(:skip_param) { {} }
let(:params) { b... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class DismissGroupCalloutService < DismissCalloutService
private
def callout
current_user.find_or_initialize_group_callout(params[:feature_name], params[:group_id])
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::DismissGroupCalloutService, feature_category: :user_management do
describe '#execute' do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let(:params) { { feature_name: feature_name, group_id: group.id } }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class RepairLdapBlockedService
attr_accessor :user
def initialize(user)
@user = user
end
def execute
user.block if ldap_hard_blocked?
end
private
def ldap_hard_blocked?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::RepairLdapBlockedService, feature_category: :system_access do
let(:user) { create(:omniauth_user, provider: 'ldapmain', state: 'ldap_blocked') }
let(:identity) { user.ldap_identity }
subject(:service) { described_class.new(user) }
des... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UpdateCanonicalEmailService
extend ActiveSupport::Concern
INCLUDED_DOMAINS_PATTERN = [/gmail.com/].freeze
def initialize(user:)
raise ArgumentError, "Please provide a user" unless user.is_a?(Us... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UpdateCanonicalEmailService, feature_category: :user_profile do
let(:other_email) { "differentaddress@includeddomain.com" }
before do
stub_const("Users::UpdateCanonicalEmailService::INCLUDED_DOMAINS_PATTERN", [/includeddomain/])
end
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class BanService < BannedUserBaseService
extend ::Gitlab::Utils::Override
private
def update_user(user)
user.ban
end
def valid_state?(user)
user.active?
end
def action
:... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::BanService, feature_category: :user_management do
let(:user) { create(:user) }
let_it_be(:current_user) { create(:admin) }
shared_examples 'does not modify the BannedUser record or user state' do
it 'does not modify the BannedUser r... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class BuildService < BaseService
ALLOWED_USER_TYPES = %i[project_bot security_policy_bot].freeze
delegate :user_default_internal_regex_enabled?,
:user_default_internal_regex_instance,
to: :'Gitlab::... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::BuildService, feature_category: :user_management do
using RSpec::Parameterized::TableSyntax
describe '#execute' do
let_it_be(:current_user) { nil }
let(:params) { build_stubbed(:user).slice(:first_name, :last_name, :username, :ema... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class DismissCalloutService < BaseContainerService
def execute
callout.tap do |record|
record.update(dismissed_at: Time.current) if record.valid?
end
end
private
def callout
c... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::DismissCalloutService, feature_category: :user_management do
describe '#execute' do
let_it_be(:user) { create(:user) }
let(:params) { { feature_name: feature_name } }
let(:feature_name) { Users::Callout.feature_names.each_key.fir... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class AutoBanService < BaseService
def initialize(user:, reason:)
@user = user
@reason = reason
end
def execute
if user.ban
record_custom_attribute
success
else
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::AutoBanService, feature_category: :instance_resiliency do
let_it_be_with_reload(:user) { create(:user) }
let(:reason) { :auto_ban_reason }
context 'when auto banning a user', :aggregate_failures do
subject(:auto_ban_user) { described... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UnbanService < BannedUserBaseService
private
def update_user(user)
user.unban
end
def valid_state?(user)
user.banned?
end
def action
:unban
end
end
end
Users::Un... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UnbanService, feature_category: :user_management do
let(:user) { create(:user) }
let_it_be(:current_user) { create(:admin) }
shared_examples 'does not modify the BannedUser record or user state' do
it 'does not modify the BannedUser... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class DeactivateService < BaseService
def initialize(current_user, skip_authorization: false)
@current_user = current_user
@skip_authorization = skip_authorization
end
def execute(user)
un... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::DeactivateService, feature_category: :user_management do
let_it_be(:current_user) { build(:admin) }
let_it_be(:user) { build(:user) }
subject(:service) { described_class.new(current_user) }
describe '#execute' do
subject(:operatio... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class ValidatePushOtpService < BaseService
include ::Gitlab::Auth::Otp::Fortinet
def initialize(current_user)
@current_user = current_user
@strategy = if forti_authenticator_enabled?(current_user)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::ValidatePushOtpService, feature_category: :user_profile do
let_it_be(:user) { create(:user) }
subject(:validate) { described_class.new(user).execute }
context 'FortiAuthenticator' do
before do
stub_feature_flags(forti_authenti... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
# Service class for getting the number of SSH keys that belong to a user.
class KeysCountService < BaseCountService
attr_reader :user
# user - The User for which to get the number of SSH keys.
def initial... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::KeysCountService, :use_clean_rails_memory_store_caching, feature_category: :system_access do
let(:user) { create(:user) }
subject { described_class.new(user) }
it_behaves_like 'a counter caching service'
describe '#count' do
befo... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class DestroyService
DestroyError = Class.new(StandardError)
attr_accessor :current_user
def initialize(current_user)
@current_user = current_user
@scheduled_records_gauge = Gitlab::Metrics.ga... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::DestroyService, feature_category: :user_management do
let!(:user) { create(:user) }
let!(:admin) { create(:admin) }
let!(:namespace) { user.namespace }
let!(:project) { create(:project, namespace: namespace) }
let(:service)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UpdateService < BaseService
include NewUserNotifier
attr_reader :user, :identity_params
ATTRS_REQUIRING_PASSWORD_CHECK = %w[email].freeze
BATCH_SIZE = 100
def initialize(current_user, params ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UpdateService, feature_category: :user_profile do
let(:password) { User.random_password }
let(:user) { create(:user, password: password, password_confirmation: password) }
describe '#execute' do
it 'updates time preferences' do
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UpdateHighestMemberRoleService < BaseService
attr_reader :user
def initialize(user)
@user = user
end
def execute
return true if user_highest_role.persisted? && highest_access_level ==... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UpdateHighestMemberRoleService, feature_category: :user_management do
let(:user) { create(:user) }
let(:execute_service) { described_class.new(user).execute }
describe '#execute' do
context 'when user_highest_role already exists' do
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class ApproveService < BaseService
def initialize(current_user)
@current_user = current_user
end
def execute(user)
return error(_('You are not allowed to approve a user'), :forbidden) unless all... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::ApproveService, feature_category: :user_management do
let_it_be(:current_user) { create(:admin) }
let(:user) { create(:user, :blocked_pending_approval) }
subject(:execute) { described_class.new(current_user).execute(user) }
describe ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class RespondToTermsService
def initialize(user, term)
@user = user
@term = term
end
# rubocop: disable CodeReuse/ActiveRecord
def execute(accepted:)
agreement = @user.term_agreements.... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::RespondToTermsService, feature_category: :user_profile do
let(:user) { create(:user) }
let(:term) { create(:term) }
subject(:service) { described_class.new(user, term) }
describe '#execute' do
it 'creates a new agreement if it did... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class UpdateTodoCountCacheService < BaseService
QUERY_BATCH_SIZE = 10
attr_reader :user_ids
# user_ids - An array of User IDs
def initialize(user_ids)
@user_ids = user_ids
end
def execut... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::UpdateTodoCountCacheService, feature_category: :team_planning do
describe '#execute' do
let_it_be(:user1) { create(:user) }
let_it_be(:user2) { create(:user) }
let_it_be(:todo1) { create(:todo, user: user1, state: :done) }
le... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class ActivateService < BaseService
def initialize(current_user)
@current_user = current_user
end
def execute(user)
return error(_('You are not authorized to perform this action'), :forbidden) u... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::ActivateService, feature_category: :user_management do
let_it_be(:current_user) { build(:admin) }
subject(:service) { described_class.new(current_user) }
describe '#execute' do
let!(:user) { create(:user, :deactivated) }
subjec... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class MigrateRecordsToGhostUserInBatchesService
LIMIT_SIZE = 1000
def initialize
@execution_tracker = Gitlab::Utils::ExecutionTracker.new
end
def execute
ghost_user_migrations.each do |job|... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::MigrateRecordsToGhostUserInBatchesService, feature_category: :user_management do
let(:service) { described_class.new }
let_it_be(:ghost_user_migration) { create(:ghost_user_migration) }
describe '#execute' do
it 'stops when executio... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class CreateService < BaseService
include NewUserNotifier
def initialize(current_user, params = {})
@current_user = current_user
@params = params.dup
end
def execute
user = build_clas... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::CreateService, feature_category: :user_management do
describe '#execute' do
let(:password) { User.random_password }
let(:admin_user) { create(:admin) }
context 'with an admin user' do
let(:service) { described_class.new(adm... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
class BatchStatusCleanerService
BATCH_SIZE = 100
# Cleanup BATCH_SIZE user_statuses records
# rubocop: disable CodeReuse/ActiveRecord
def self.execute(batch_size: BATCH_SIZE)
scope = UserStatus
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::BatchStatusCleanerService, feature_category: :user_management do
let_it_be(:user_status_1) { create(:user_status, emoji: 'coffee', message: 'msg1', clear_status_at: 1.year.ago) }
let_it_be(:user_status_2) { create(:user_status, emoji: 'coff... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
module SavedReplies
class DestroyService
def initialize(saved_reply:)
@saved_reply = saved_reply
end
def execute
if saved_reply.destroy
ServiceResponse.success(payload: {... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::SavedReplies::DestroyService, feature_category: :team_planning do
describe '#execute' do
let!(:saved_reply) { create(:saved_reply) }
subject { described_class.new(saved_reply: saved_reply).execute }
context 'when destroy fails' ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
module SavedReplies
class UpdateService
def initialize(saved_reply:, name:, content:)
@saved_reply = saved_reply
@name = name
@content = content
end
def execute
if ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::SavedReplies::UpdateService, feature_category: :team_planning do
describe '#execute' do
let_it_be(:current_user) { create(:user) }
let_it_be(:saved_reply) { create(:saved_reply, user: current_user) }
let_it_be(:other_saved_reply) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
module SavedReplies
class CreateService
def initialize(current_user:, name:, content:)
@current_user = current_user
@name = name
@content = content
end
def execute
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::SavedReplies::CreateService, feature_category: :team_planning do
describe '#execute' do
let_it_be(:current_user) { create(:user) }
let_it_be(:saved_reply) { create(:saved_reply, user: current_user) }
subject { described_class.new... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
module EmailVerification
class ValidateTokenService < EmailVerification::BaseService
include ActionView::Helpers::DateHelper
TOKEN_VALID_FOR_MINUTES = 60
def initialize(attr:, user:, token:)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::EmailVerification::ValidateTokenService, :clean_gitlab_redis_rate_limiting, feature_category: :system_access do
using RSpec::Parameterized::TableSyntax
let(:service) { described_class.new(attr: attr, user: user, token: token) }
let(:emai... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
module EmailVerification
class GenerateTokenService < EmailVerification::BaseService
TOKEN_LENGTH = 6
def execute
@token = generate_token
[token, digest]
end
private
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::EmailVerification::GenerateTokenService, feature_category: :system_access do
using RSpec::Parameterized::TableSyntax
let(:user) { build_stubbed(:user) }
let(:service) { described_class.new(attr: attr, user: user) }
let(:token) { 'token... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Users
module EmailVerification
class UpdateEmailService
include ActionView::Helpers::DateHelper
RATE_LIMIT = :email_verification_code_send
def initialize(user:)
@user = user
end
de... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Users::EmailVerification::UpdateEmailService, feature_category: :instance_resiliency do
let_it_be_with_reload(:user) { create(:user) }
let(:email) { build_stubbed(:user).email }
describe '#execute' do
subject(:execute_service) { described_c... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module ServiceDeskSettings
class UpdateService < BaseService
include ::ServiceDesk::CustomEmails::Logger
def execute
settings = ServiceDeskSetting.safe_find_or_create_by!(project_id: project.id)
params[:project... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ServiceDeskSettings::UpdateService, :aggregate_failures, feature_category: :service_desk do
describe '#execute' do
let_it_be(:settings) do
create(:service_desk_setting, outgoing_name: 'original name', custom_email: 'user@example.com')
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class ExportCsvService < ExportCsv::BaseService
NotAvailableError = StandardError.new('This feature is currently behind a feature flag and it is not available.')
def csv_data
raise NotAvailableError u... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::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(:work_item_1) { c... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class DeleteTaskService
def initialize(work_item:, lock_version:, current_user: nil, task_params: {})
@work_item = work_item
@current_user = current_user
@task_params = task_params
@lock_... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::DeleteTaskService, feature_category: :team_planning do
let_it_be(:project) { create(:project) }
let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
let_it_be_with_refind(:task) { create(:work_item, project: pr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class PrepareImportCsvService < Import::PrepareService
extend ::Gitlab::Utils::Override
private
override :worker
def worker
ImportWorkItemsCsvWorker
end
override :success_message
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::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(:uploa... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class TaskListReferenceReplacementService
STALE_OBJECT_MESSAGE = 'Stale work item. Check lock version'
def initialize(work_item:, current_user:, work_item_reference:, line_number_start:, line_number_end:, t... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::TaskListReferenceReplacementService, feature_category: :team_planning do
let_it_be(:developer) { create(:user) }
let_it_be(:project) { create(:project, :repository).tap { |project| project.add_developer(developer) } }
let_it_be(:singl... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class ImportCsvService < ImportCsv::BaseService
extend ::Gitlab::Utils::Override
FeatureNotAvailableError = StandardError.new(
'This feature is currently behind a feature flag and it is not available.... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::ImportCsvService, feature_category: :team_planning do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be(:author) { create(:user, username: 'csv_author') }
let(:file) { fixture_file_upload('spec/fi... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class CreateFromTaskService
def initialize(work_item:, perform_spam_check: true, current_user: nil, work_item_params: {})
@work_item = work_item
@current_user = current_user
@work_item_params =... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::CreateFromTaskService, feature_category: :team_planning do
let_it_be(:project) { create(:project) }
let_it_be(:developer) { create(:user) }
let_it_be(:list_work_item, refind: true) { create(:work_item, project: project, description: "... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class TaskListReferenceRemovalService
STALE_OBJECT_MESSAGE = 'Stale work item. Check lock version'
def initialize(work_item:, task:, line_number_start:, line_number_end:, lock_version:, current_user:)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::TaskListReferenceRemovalService, feature_category: :team_planning do
let_it_be(:developer) { create(:user) }
let_it_be(:project) { create(:project, :repository).tap { |project| project.add_developer(developer) } }
let_it_be(:task) { c... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class BuildService < ::Issues::BuildService
private
def model_klass
::WorkItem
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::BuildService, feature_category: :team_planning do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:guest) { create(:user) }
let(:user) { guest }
before_all do
project.add_guest(guest)
end
describe '#execut... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
# Create and link operations are not run inside a transaction in this class
# because CreateFromTaskService also creates a transaction.
# This class should always be run inside a transaction as we could end up w... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::CreateAndLinkService, feature_category: :portfolio_management do
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:user) { create(:user) }
let_it_be(:related_work_item, refind: tr... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class UpdateService < ::Issues::UpdateService
extend Gitlab::Utils::Override
include WidgetableService
def initialize(container:, current_user: nil, params: {}, perform_spam_check: false, widget_params:... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::UpdateService, feature_category: :team_planning do
let_it_be(:developer) { create(:user) }
let_it_be(:guest) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:parent) { create(:work_item, project: project) }
le... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class CreateService < Issues::CreateService
extend ::Gitlab::Utils::Override
include WidgetableService
def initialize(container:, perform_spam_check: true, current_user: nil, params: {}, widget_params: ... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::CreateService, feature_category: :team_planning do
include AfterNextHelpers
RSpec.shared_examples 'creates work item in container' do |container_type|
let_it_be_with_reload(:project) { create(:project) }
let_it_be_with_reload(:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
class DeleteService < Issuable::DestroyService
def execute(work_item)
unless current_user.can?(:delete_work_item, work_item)
return ::ServiceResponse.error(message: 'User not authorized to delete w... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::DeleteService, feature_category: :team_planning do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:guest) { create(:user) }
let_it_be(:work_item, refind: true) { create(:work_item, project: project, author: guest) }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Callbacks
class AwardEmoji < Base
def before_update
return unless params.present? && params.key?(:name) && params.key?(:action)
return unless has_permission?(:award_emoji)
e... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Callbacks::AwardEmoji, feature_category: :team_planning do
let_it_be(:reporter) { create(:user) }
let_it_be(:unauthorized_user) { create(:user) }
let_it_be(:project) { create(:project, :private) }
let_it_be(:work_item) { create(:wor... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module RelatedWorkItemLinks
class DestroyService < BaseService
def initialize(work_item, user, params)
@work_item = work_item
@current_user = user
@params = params.dup
@fail... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::RelatedWorkItemLinks::DestroyService, feature_category: :portfolio_management do
describe '#execute' do
let_it_be(:project) { create(:project_empty_repo, :private) }
let_it_be(:other_project) { create(:project_empty_repo, :private... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module RelatedWorkItemLinks
class CreateService < IssuableLinks::CreateService
extend ::Gitlab::Utils::Override
def execute
return error(_('No matching work item found.'), 404) unless can?(c... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::RelatedWorkItemLinks::CreateService, feature_category: :portfolio_management do
describe '#execute' do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module ParentLinks
class BaseService < IssuableLinks::CreateService
extend ::Gitlab::Utils::Override
private
def set_parent(issuable, work_item)
link = WorkItems::ParentLink.for_work_... | # frozen_string_literal: true
require 'spec_helper'
module WorkItems
class ParentLinksService < WorkItems::ParentLinks::BaseService; end
end
RSpec.describe WorkItems::ParentLinks::BaseService, feature_category: :portfolio_management do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module ParentLinks
class ReorderService < WorkItems::ParentLinks::BaseService
private
override :relate_issuables
def relate_issuables(work_item)
notes_are_expected = work_item.work_ite... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::ParentLinks::ReorderService, feature_category: :portfolio_management do
describe '#execute' do
let_it_be(:reporter) { create(:user) }
let_it_be(:guest) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be_w... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module ParentLinks
class DestroyService < IssuableLinks::DestroyService
attr_reader :link, :current_user, :parent, :child
def initialize(link, user)
@link = link
@current_user = user... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::ParentLinks::DestroyService, feature_category: :team_planning do
describe '#execute' do
let_it_be(:reporter) { create(:user) }
let_it_be(:guest) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:work_it... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module ParentLinks
class CreateService < WorkItems::ParentLinks::BaseService
private
override :relate_issuables
def relate_issuables(work_item)
link = set_parent(issuable, work_item)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::ParentLinks::CreateService, feature_category: :portfolio_management do
describe '#execute' do
let_it_be(:user) { create(:user) }
let_it_be(:guest) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:work_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module CurrentUserTodosService
class UpdateService < WorkItems::Widgets::BaseService
def before_update_in_transaction(params:)
return unless params.present? && params.key?(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::CurrentUserTodosService::UpdateService, feature_category: :team_planning do
let_it_be(:reporter) { create(:user) }
let_it_be(:project) { create(:project, :private) }
let_it_be(:current_user) { reporter }
let_it_be(:work_ite... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module HierarchyService
class UpdateService < WorkItems::Widgets::HierarchyService::BaseService
INVALID_RELATIVE_POSITION_ERROR = 'Relative position is not valid.'
CHILDREN_R... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::HierarchyService::UpdateService, feature_category: :portfolio_management do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:work_item) { create(:work_item, project: project) }
let_it_... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module HierarchyService
class CreateService < WorkItems::Widgets::HierarchyService::BaseService
def after_create_in_transaction(params:)
return unless params.present?
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::HierarchyService::CreateService, feature_category: :portfolio_management do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:parent_item) { create(:work_item, project: project) }
let(:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module NotificationsService
class UpdateService < WorkItems::Widgets::BaseService
def before_update_in_transaction(params:)
return unless params.present? && params.key?(:su... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::NotificationsService::UpdateService, feature_category: :team_planning do
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, :private, group: group) }
let_it_be(:guest) { create(:user).tap { |u| projec... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module DescriptionService
class UpdateService < WorkItems::Widgets::BaseService
def before_update_callback(params: {})
params[:description] = nil if new_type_excludes_widge... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::DescriptionService::UpdateService, feature_category: :portfolio_management do
let_it_be(:random_user) { create(:user) }
let_it_be(:author) { create(:user) }
let_it_be(:guest) { create(:user) }
let_it_be(:reporter) { create(... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module LabelsService
class UpdateService < WorkItems::Widgets::BaseService
def prepare_update_params(params: {})
if new_type_excludes_widget?
params[:remove_lab... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::LabelsService::UpdateService, feature_category: :team_planning do
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:label1) { create(:label, project: project) }
let_it_be... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module StartAndDueDateService
class UpdateService < WorkItems::Widgets::BaseService
def before_update_callback(params: {})
return widget.work_item.assign_attributes({ start... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::StartAndDueDateService::UpdateService, feature_category: :portfolio_management do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user).tap { |user| project.add_reporter(user) } }
let_it_be_with_reload(:wo... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WorkItems
module Widgets
module AssigneesService
class UpdateService < WorkItems::Widgets::BaseService
def before_update_in_transaction(params:)
params[:assignee_ids] = [] if new_type_excludes_widg... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WorkItems::Widgets::AssigneesService::UpdateService, :freeze_time, feature_category: :portfolio_management do
let_it_be(:reporter) { create(:user) }
let_it_be(:project) { create(:project, :private) }
let_it_be(:new_assignee) { create(:user) }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Webauthn
class RegisterService < BaseService
def initialize(user, params, challenge)
@user = user
@params = params
@challenge = challenge
end
def execute
registration = WebauthnRegistratio... | # frozen_string_literal: true
require 'spec_helper'
require 'webauthn/fake_client'
RSpec.describe Webauthn::RegisterService, feature_category: :system_access do
let(:client) { WebAuthn::FakeClient.new(origin) }
let(:user) { create(:user) }
let(:challenge) { Base64.strict_encode64(SecureRandom.random_bytes(32)) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Webauthn
class AuthenticateService < BaseService
def initialize(user, device_response, challenge)
@user = user
@device_response = device_response
@challenge = challenge
end
def execute
par... | # frozen_string_literal: true
require 'spec_helper'
require 'webauthn/fake_client'
RSpec.describe Webauthn::AuthenticateService, feature_category: :system_access do
let(:client) { WebAuthn::FakeClient.new(origin) }
let(:user) { create(:user) }
let(:challenge) { Base64.strict_encode64(SecureRandom.random_bytes(3... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Webauthn
class DestroyService < BaseService
attr_reader :webauthn_registration, :user, :current_user
def initialize(current_user, user, webauthn_registrations_id)
@current_user = current_user
@user = user... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Webauthn::DestroyService, feature_category: :system_access do
let(:user) { create(:user, :two_factor_via_webauthn, registrations_count: 1) }
let(:current_user) { user }
describe '#execute' do
let(:webauthn_id) { user.webauthn_registrations.... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class CreateEventService < BaseService
def execute
::Packages::Event.unique_counters_for(event_scope, event_name, originator_type).each do |event_name|
::Gitlab::UsageDataCounters::HLLRedisCounter.t... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::CreateEventService, feature_category: :package_registry do
let(:scope) { 'generic' }
let(:event_name) { 'push_package' }
let(:params) do
{
scope: scope,
event_name: event_name
}
end
subject { described_class.ne... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
# WARNING: ensure that permissions are verified before using this service.
class MarkPackageFilesForDestructionService
BATCH_SIZE = 500
def initialize(package_files)
@package_files = package_files
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::MarkPackageFilesForDestructionService, :aggregate_failures,
feature_category: :package_registry do
let(:service) { described_class.new(package_files) }
describe '#execute', :aggregate_failures do
let(:batch_deadline) { nil }
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class UpdatePackageFileService
delegate :file, to: :@package_file
def initialize(package_file, params)
@package_file = package_file
@params = params
end
def execute
check_params
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::UpdatePackageFileService, feature_category: :package_registry do
let_it_be(:another_package) { create(:package) }
let_it_be(:old_file_name) { 'old_file_name.txt' }
let_it_be(:new_file_name) { 'new_file_name.txt' }
let(:package) { pac... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class CreatePackageFileService
attr_reader :package, :params
def initialize(package, params)
@package = package
@params = params
end
def execute
package_file = package.package_files... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::CreatePackageFileService, feature_category: :package_registry do
let_it_be(:package) { create(:maven_package) }
let_it_be(:user) { create(:user) }
let(:service) { described_class.new(package, params) }
describe '#execute' do
sub... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class UpdateTagsService
include Gitlab::Utils::StrongMemoize
def initialize(package, tags = [])
@package = package
@tags = tags
end
def execute
return if @tags.empty?
tags_to... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::UpdateTagsService, feature_category: :package_registry do
let_it_be(:package, reload: true) { create(:nuget_package) }
let(:tags) { %w[test-tag tag1 tag2 tag3] }
let(:service) { described_class.new(package, tags) }
describe '#execut... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class RemoveTagService < BaseService
attr_reader :package_tag
def initialize(package_tag)
raise ArgumentError, "Package tag must be set" if package_tag.blank?
@package_tag = package_tag
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::RemoveTagService, feature_category: :package_registry do
let!(:package_tag) { create(:packages_tag) }
describe '#execute' do
subject { described_class.new(package_tag).execute }
context 'with existing tag' do
it { expect {... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class MarkPackageForDestructionService < BaseContainerService
alias_method :package, :container
def execute
return service_response_error("You don't have access to this package", 403) unless user_can_d... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::MarkPackageForDestructionService, feature_category: :package_registry do
let_it_be(:user) { create(:user) }
let_it_be_with_reload(:package) { create(:npm_package) }
describe '#execute' do
subject(:service) { described_class.new(co... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class CreateTemporaryPackageService < ::Packages::CreatePackageService
PACKAGE_VERSION = '0.0.0'
def execute(package_type, name: 'Temporary.Package')
create_package!(package_type,
name: name,
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::CreateTemporaryPackageService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be(:params) { {} }
let_it_be(:package_name) { 'my-package' }
let_it_be(:packag... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
class MarkPackagesForDestructionService
include BaseServiceUtility
BATCH_SIZE = 20
UNAUTHORIZED_RESPONSE = ServiceResponse.error(
message: "You don't have the permission to perform this action",
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::MarkPackagesForDestructionService, :sidekiq_inline, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be_with_reload(:packages) { create_list(:npm_package, 3, project: project) }
let(:user) { proje... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
# rubocop: disable Gitlab/BulkInsert
class CreateDependencyService < BaseService
attr_reader :package, :dependencies
def initialize(package, dependencies)
@package = package
@dependencies = depe... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::CreateDependencyService, feature_category: :package_registry do
describe '#execute' do
let_it_be(:namespace) { create(:namespace) }
let_it_be(:version) { '1.0.1' }
let_it_be(:package_name) { "@#{namespace.path}/my-app" }
co... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module MlModel
class CreatePackageFileService < BaseService
def execute
::Packages::Package.transaction do
package = find_or_create_package
find_or_create_model_version(package)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::MlModel::CreatePackageFileService, feature_category: :mlops do
describe '#execute' do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be(:pipeline) { create(:ci_pipeline, user: user, project: ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module MlModel
class FindOrCreatePackageService < ::Packages::CreatePackageService
def execute
find_or_create_package!(::Packages::Package.package_types['ml_model'])
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::MlModel::FindOrCreatePackageService, feature_category: :mlops do
let_it_be(:project) { create(:project) }
let_it_be(:user) { project.creator }
let_it_be(:ci_build) { create(:ci_build, :running, user: user, project: project) }
let(:b... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Pypi
class CreatePackageService < ::Packages::CreatePackageService
include ::Gitlab::Utils::StrongMemoize
def execute
::Packages::Package.transaction do
meta = Packages::Pypi... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Pypi::CreatePackageService, :aggregate_failures, feature_category: :package_registry do
include PackagesManagerApiSpecHelpers
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let(:sha256) { '1' * 64 }
le... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Go
class CreatePackageService < BaseService
GoZipSizeError = Class.new(StandardError)
attr_accessor :version
def initialize(project, user = nil, version:)
super(project, user)
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Go::CreatePackageService, feature_category: :package_registry do
let_it_be(:project) { create :project_empty_repo, path: 'my-go-lib' }
let_it_be(:mod) { create :go_module, project: project }
before_all do
create :go_module_commit,... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Go
class SyncPackagesService < BaseService
include Gitlab::Golang
def initialize(project, ref, path = '')
super(project)
@ref = ref
@path = path
raise Argumen... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Go::SyncPackagesService, feature_category: :package_registry do
include_context 'basic Go module'
let(:params) { { info: true, mod: true, zip: true } }
describe '#execute_async' do
it 'schedules a package refresh' do
expect... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class GenerateDistributionKeyService
include Gitlab::Utils::StrongMemoize
def initialize(params: {})
@params = params
end
def execute
using_pinentry do |ctx... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::GenerateDistributionKeyService, feature_category: :package_registry do
let(:params) { {} }
subject { described_class.new(params: params) }
let(:response) { subject.execute }
it 'returns an Hash', :aggregate_failures do
... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class UpdateDistributionService
def initialize(distribution, params)
@distribution = distribution
@params = params
@components = params.delete(:components)
@a... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::UpdateDistributionService, feature_category: :package_registry do
RSpec.shared_examples 'Update Debian Distribution' do |expected_message, expected_components, expected_architectures, component_file_delta = 0|
it 'returns Servi... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class FindOrCreateIncomingService < ::Packages::CreatePackageService
def execute
find_or_create_package!(:debian, name: ::Packages::Debian::INCOMING_PACKAGE_NAME, version: nil)
e... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::FindOrCreateIncomingService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
subject(:service) { described_class.new(project, user) }
describe '#execute' do... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
# Returns .deb file metadata
class ExtractDebMetadataService
CommandFailedError = Class.new(StandardError)
def initialize(file_path)
@file_path = file_path
end
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::ExtractDebMetadataService, feature_category: :package_registry do
subject { described_class.new(file_path) }
let(:file_name) { 'libsample0_1.2.3~alpha2_amd64.deb' }
let(:file_path) { "spec/fixtures/packages/debian/#{file_name}"... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class CreatePackageFileService
def initialize(package:, current_user:, params: {})
@package = package
@current_user = current_user
@params = params
end
def... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::CreatePackageFileService, feature_category: :package_registry do
include WorkhorseHelpers
let_it_be(:package) { create(:debian_incoming, without_package_files: true) }
let_it_be(:current_user) { create(:user) }
describe '#e... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class CreateDistributionService
def initialize(container, user, params)
@container = container
@params = params
@params[:creator] = user
@components = params.d... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::CreateDistributionService, feature_category: :package_registry do
RSpec.shared_examples 'Create Debian Distribution' do |expected_message, expected_components, expected_architectures|
let_it_be(:container) { create(container_ty... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class ExtractChangesMetadataService
include Gitlab::Utils::StrongMemoize
ExtractionError = Class.new(StandardError)
def initialize(package_file)
@package_file = package_f... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::ExtractChangesMetadataService, feature_category: :package_registry do
describe '#execute' do
let_it_be(:incoming) { create(:debian_incoming) }
let_it_be(:temp_package) do
create(:debian_package, without_package_files:... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class ExtractMetadataService
include Gitlab::Utils::StrongMemoize
ExtractionError = Class.new(StandardError)
def initialize(package_file)
@package_file = package_file
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::ExtractMetadataService, feature_category: :package_registry do
let(:service) { described_class.new(package_file) }
subject { service.execute }
RSpec.shared_context 'with Debian package file' do |trait|
let(:package_file) ... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class GenerateDistributionService
include Gitlab::Utils::StrongMemoize
include ExclusiveLeaseGuard
ONE_HOUR = 1.hour.freeze
# used by ExclusiveLeaseGuard
DEFAULT_LEAS... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::GenerateDistributionService, feature_category: :package_registry do
include_context 'with published Debian package'
let(:service) { described_class.new(distribution) }
[:project, :group].each do |container_type|
context "... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
# Parse String as Debian RFC822 control data format
# https://manpages.debian.org/unstable/dpkg-dev/deb822.5
class ParseDebian822Service
InvalidDebian822Error = Class.new(StandardError... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::ParseDebian822Service, feature_category: :package_registry do
subject { described_class.new(input) }
context 'with dpkg-deb --field output' do
let(:input) do
<<~HEREDOC
Package: libsample0
Source: sampl... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class SignDistributionService
include Gitlab::Utils::StrongMemoize
def initialize(distribution, content, detach: false)
@distribution = distribution
@content = content
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::SignDistributionService, feature_category: :package_registry do
let_it_be(:group) { create(:group, :public) }
let(:content) { FFaker::Lorem.paragraph }
let(:service) { described_class.new(distribution, content, detach: detach)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Debian
class ProcessPackageFileService
include ExclusiveLeaseGuard
include Gitlab::Utils::StrongMemoize
SOURCE_FIELD_SPLIT_REGEX = /[ ()]/
# used by ExclusiveLeaseGuard
DEFAU... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Debian::ProcessPackageFileService, feature_category: :package_registry do
include ExclusiveLeaseHelpers
let_it_be(:distribution) { create(:debian_project_distribution, :with_file, suite: 'unstable') }
let(:debian_file_metadatum) { pa... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Maven
class CreatePackageService < ::Packages::CreatePackageService
def execute
app_group, _, app_name = params[:name].rpartition('/')
app_group.tr!('/', '.')
create_package!(... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Maven::CreatePackageService, feature_category: :package_registry do
let(:project) { create(:project) }
let(:user) { create(:user) }
let(:app_name) { 'my-app' }
let(:version) { '1.0-SNAPSHOT' }
let(:path) { "my/company/app/#{app_name... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Maven
class FindOrCreatePackageService < BaseService
SNAPSHOT_TERM = '-SNAPSHOT'
MAX_FILE_NAME_LENGTH = 5000
def execute
return ServiceResponse.error(message: 'File name is too lo... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Maven::FindOrCreatePackageService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let(:app_name) { 'my-app' }
let(:path) { "sandbox/test/app/#{app_name}" }
let(:ve... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Maven
module Metadata
class AppendPackageFileService
XML_CONTENT_TYPE = 'application/xml'
DEFAULT_CONTENT_TYPE = 'application/octet-stream'
MD5_FILE_NAME = "#{Metadata.filena... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Packages::Maven::Metadata::AppendPackageFileService, feature_category: :package_registry do
let_it_be(:package) { create(:maven_package, version: nil) }
let(:service) { described_class.new(package: package, metadata_content: content) }
let(:c... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Maven
module Metadata
class CreatePluginsXmlService < BaseCreateXmlService
XPATH_PLUGIN_ARTIFACT_ID = '//plugin/artifactId'
XPATH_PLUGINS = '//metadata/plugins'
EMPTY_PLUGINS_... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Packages::Maven::Metadata::CreatePluginsXmlService, feature_category: :package_registry do
let_it_be(:group_id) { 'my/test' }
let_it_be(:package) { create(:maven_package, name: group_id, version: nil) }
let(:plugins_in_database) { %w[one-mave... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Maven
module Metadata
class SyncService < BaseContainerService
include Gitlab::Utils::StrongMemoize
alias_method :project, :container
MAX_FILE_SIZE = 10.megabytes.freeze
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Packages::Maven::Metadata::SyncService, feature_category: :package_registry do
using RSpec::Parameterized::TableSyntax
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be_with_reload(:versionless_package_fo... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Maven
module Metadata
class CreateVersionsXmlService < BaseCreateXmlService
XPATH_VERSIONING = '//metadata/versioning'
XPATH_VERSIONS = '//versions'
XPATH_VERSION = '//version... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Packages::Maven::Metadata::CreateVersionsXmlService, feature_category: :package_registry do
let_it_be(:package) { create(:maven_package, version: nil) }
let(:versions_in_database) { %w[1.3 2.0-SNAPSHOT 1.6 1.4 1.5-SNAPSHOT] }
let(:versions_in... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Composer
class ComposerJsonService
InvalidJson = Class.new(StandardError)
def initialize(project, target)
@project = project
@target = target
end
def execute
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Composer::ComposerJsonService, feature_category: :package_registry do
describe '#execute' do
let(:branch) { project.repository.find_branch('master') }
let(:target) { branch.target }
subject { described_class.new(project, target... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Composer
class CreatePackageService < ::Packages::CreatePackageService
include ::Gitlab::Utils::StrongMemoize
def execute
# fetches json outside of transaction
composer_json
... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Composer::CreatePackageService, feature_category: :package_registry do
include PackagesManagerApiSpecHelpers
let_it_be(:package_name) { 'composer-package-name' }
let_it_be(:json) { { name: package_name }.to_json }
let_it_be(:project)... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Composer
class VersionParserService
def initialize(tag_name: nil, branch_name: nil)
@tag_name = tag_name
@branch_name = branch_name
end
def execute
if @tag_name.p... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Composer::VersionParserService, feature_category: :package_registry do
let_it_be(:params) { {} }
describe '#execute' do
using RSpec::Parameterized::TableSyntax
subject { described_class.new(tag_name: tagname, branch_name: branch... |
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rubygems
class DependencyResolverService < BaseService
include Gitlab::Utils::StrongMemoize
DEFAULT_PLATFORM = 'ruby'
def execute
unless Ability.allowed?(current_user, :read_pac... | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rubygems::DependencyResolverService, feature_category: :package_registry do
let_it_be(:project) { create(:project, :private) }
let_it_be(:package) { create(:package, project: project) }
let_it_be(:user) { create(:user) }
let(:gem_nam... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.